From a4a68354d506aba9b5afb114c091236347db5145 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 14:17:04 +0200
Subject: [PATCH 01/42] cleanup

---
 2026-04-16-cloudflare-driver.md  | 535 -------------------------------
 2026-04-17_build-macos-binary.md | 287 -----------------
 2 files changed, 822 deletions(-)
 delete mode 100644 2026-04-16-cloudflare-driver.md
 delete mode 100644 2026-04-17_build-macos-binary.md

diff --git a/2026-04-16-cloudflare-driver.md b/2026-04-16-cloudflare-driver.md
deleted file mode 100644
index cb3631d..0000000
--- a/2026-04-16-cloudflare-driver.md
+++ /dev/null
@@ -1,535 +0,0 @@
-# Plan: Cloudflare Driver For `hyper-browser-simulator`
-
-## Recommendation
-
-The generic backend seam already exists in the current codebase:
-
-- `ParticipantDriverSession` in `browser/src/participant/shared/runtime.rs` is the real backend contract.
-- `FrontendAutomation` in `browser/src/participant/local/frontend.rs` is now local-Chromium-only.
-
-So the Cloudflare work should build on the current `ParticipantDriverSession` runtime instead of reviving the older concrete `FrontendDriver` idea.
-
-Recommended shape:
-
-- Keep the actual driver implementation in `client-simulator-browser`, under `browser/src/participant/cloudflare/`.
-- Add one new workspace crate for the generated worker client, for example `cloudflare-worker-client/`.
-- Do not put the driver implementation itself in a separate crate. That would create a dependency cycle because `client-simulator-browser` owns the `ParticipantDriverSession` trait and also needs to construct the driver.
-- Reuse the existing Rust auth flow for Hyper Core. The driver should obtain or reuse the `hyper_session` cookie locally and pass the raw cookie value to the worker during session creation.
-- Treat the worker's `sessionId` as a private implementation detail of the driver. Nothing above `CloudflareSession` should know about it.
-- Cache authoritative state from worker responses and use a low-frequency worker state poll to implement `wait_for_termination()`. Note that the cloudflare Browser Rendering instance will terminate after its keep-alive timeout passes without inactivity. The driver and cloudflare worker needs to connect regularly to the instance to keep it alive.
-
-## Related Project
-
-The counterpart worker project lives at:
-
-- `/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator`
-
-The most relevant files in that repo for this plan are:
-
-- worker/API entrypoint: `/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator/worker/src/index.ts`
-- worker routes and schemas: `/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator/worker/src/api/`
-- current worker automation logic: `/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator/worker/src/api/logic.ts`
-- current generated-client example: `/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator/cli/`
-- counterpart implementation plan: `/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator/plans/2026-04-16_hyper-browser-simulator-support.md`
-
-## Current State
-
-What is already in place:
-
-- The shared runtime and driver contract are implemented.
-- `LocalChromiumSession` is the production local backend.
-- `RemoteStubSession` is a simulated remote backend.
-- `browser/src/participant/cloudflare/mod.rs` is an empty placeholder.
-- `ParticipantBackendKind` only supports `local` and `remote-stub`.
-- The TUI already has backend selection.
-
-What is missing for a real Cloudflare backend:
-
-- a generated Rust client for the worker API in this repo
-- a `CloudflareSession` implementation of `ParticipantDriverSession`
-- config for the worker base URL and request behavior
-- spawn/store wiring for the new backend
-- tests against a mock worker
-
-The cloudflare-browser-simulator repo already has a worker implementation following `/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator/plans/2026-04-16_hyper-browser-simulator-support.md`. You can run a local worker using the justfile commands at `/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator/justfile`. If the worker API is not sufficient or could be made more ergonomic for the driver, you can modify its implementation and OpenAPI spec as needed.
-
-## Design Decisions
-
-### Use a generated client crate, not hand-written HTTP
-
-The worker repo already treats its OpenAPI document as canonical. Mirror that pattern here.
-
-Recommended crate layout:
-
-- `cloudflare-worker-client/`
-  - `build.rs`
-  - `openapi/cloudflare-browser-simulator.json`
-  - `src/generated.rs`
-  - `src/lib.rs`
-  - `src/client.rs`
-
-Responsibilities:
-
-- own the committed OpenAPI copy used by this repo
-- generate the Rust client with `progenitor`
-- expose a thin ergonomic wrapper around the generated client
-- keep `reqwest` transport, timeout, base URL, and error formatting out of `browser/`
-
-### Keep the Cloudflare driver in `browser/`
-
-Recommended files:
-
-- `browser/src/participant/cloudflare/mod.rs`
-- `browser/src/participant/cloudflare/session.rs`
-- `browser/src/participant/cloudflare/config.rs`
-- `browser/src/participant/cloudflare/mapping.rs`
-
-Responsibilities:
-
-- map `ParticipantLaunchSpec` to worker create-session requests
-- map `ParticipantMessage` to worker command requests
-- translate worker state into `ParticipantState`
-- forward worker log entries into `ParticipantLogMessage`
-- own `sessionId`, cached state, and termination polling
-
-### Reuse the existing auth stack
-
-For Hyper Core:
-
-- use `HyperSessionCookieManger` exactly as the local backend does
-- if a cookie is already available, reuse it
-- otherwise fetch one with `fetch_new_cookie(base_url, username)`
-- send only the cookie value to the worker
-
-The worker should set that cookie into the browser context before navigation. Do not duplicate the guest-auth flow inside the worker.
-
-### Keep backend-specific limitations at the driver boundary
-
-Cloudflare differs from local Chromium in a few important ways:
-
-- always headless
-- no local user data dir
-- no local fake-media files from the Rust host
-- WebRTC-only in practice
-
-The driver should absorb those differences by:
-
-- logging when a setting is ignored or normalized
-- exposing the actual applied state from the worker
-- not changing the `Participant`, TUI command surface, or shared runtime just to model Cloudflare internals
-
-## Scope
-
-In scope for this implementation:
-
-- new `cloudflare` backend kind
-- Hyper Core and Hyper Lite support through the worker
-- full `ParticipantMessage` coverage
-- accurate `ParticipantState` refreshes
-- proper close and unexpected-termination handling
-- generated OpenAPI client in this repo
-
-Explicit non-goals for v1:
-
-- headed Cloudflare sessions
-- remote support for local fake-media files or URLs
-- sharing DOM selector code across Rust and TypeScript through a new abstraction layer
-- exposing worker-specific identifiers outside the driver
-
-## Progress Tracker
-
-Overall status: `phase 6 automated validation added; explicit Cloudflare keep-alive polling implemented; manual smoke validation pending`
-
-Cross-repo dependency:
-
-- This plan depends on the worker contract described in `/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator/plans/2026-04-16_hyper-browser-simulator-support.md`.
-
-Milestones:
-
-- [x] Phase 1: Freeze the worker contract and add the generated-client crate
-- [x] Phase 2: Add Cloudflare backend config and spawn wiring
-- [x] Phase 3: Implement `CloudflareSession` start and close
-- [x] Phase 4: Implement command handling, cached state, and termination polling
-- [x] Phase 5: Add TUI and UX handling for backend-specific limitations
-- [ ] Phase 6: Validate with unit, integration, and manual tests
-
-Latest implementation note:
-
-- the Cloudflare driver now sends explicit `POST /sessions/{sessionId}/keep-alive` requests on its background poll loop and clamps that loop to a safe interval within the configured Browser Rendering inactivity window
-- the worker-side `sessionTimeoutMs` is now treated as the Browser Rendering `keep_alive` inactivity timeout instead of a hard session lifetime, so active sessions can outlive 10 minutes when the simulator keeps sending commands
-
-## Detailed Plan
-
-### Phase 1: Freeze the worker contract and add the generated-client crate
-
-Goal:
-
-- make the worker API a typed dependency of this repo
-- avoid hand-written request and response structs
-
-Changes:
-
-- add a new workspace member, for example `cloudflare-worker-client`
-- add `progenitor`, `progenitor-client`, `openapiv3`, `prettyplease`, `syn`, and the runtime `reqwest` pieces needed for generated code
-- copy the canonical worker spec into this repo under the new crate
-- add `build.rs` to generate the client from the committed spec
-- expose a small wrapper API for:
-  - constructing a client from base URL and timeouts
-  - formatting API errors into `eyre::Report`
-  - convenient methods for create, command, state, and close calls
-
-TDD steps:
-
-- [x] add a failing test for client construction and base URL normalization
-- [x] add a failing test for worker error translation into actionable Rust errors
-- [x] implement the wrapper until those tests pass
-
-Implemented in this phase:
-
-- added the `cloudflare-worker-client` workspace crate
-- copied the canonical worker OpenAPI spec into `cloudflare-worker-client/openapi/cloudflare-browser-simulator.json`
-- added `build.rs`-driven client generation with `progenitor`
-- exposed a thin wrapper with base URL normalization, typed session helpers, and `eyre` error formatting
-- added focused unit tests covering base URL normalization and actionable worker error translation
-
-Completion criteria:
-
-- `client-simulator-browser` can depend on the generated client crate without any direct OpenAPI or `reqwest` boilerplate
-- the worker contract is represented by generated Rust types in this repo
-
-### Phase 2: Add Cloudflare backend config and spawn wiring
-
-Goal:
-
-- make Cloudflare a first-class backend selection
-
-Recommended config shape:
-
-```yaml
-backend: cloudflare
-cloudflare:
-  base_url: https://cloudflare-browser-simulator.hyper-video.workers.dev
-  request_timeout_seconds: 30
-  session_timeout_ms: 600000
-  navigation_timeout_ms: 45000
-  selector_timeout_ms: 20000
-  debug: false
-  health_poll_interval_ms: 5000
-```
-
-Recommended code changes:
-
-- extend `ParticipantBackendKind` in `config/src/client_config.rs` with `Cloudflare`
-- add a `CloudflareConfig` struct in `config/`
-- update `config/src/lib.rs` and `config/src/default-config.yaml`
-- update the TUI backend picker to include `cloudflare`
-- replace separate `spawn_local()` and `spawn_remote_stub()` calls from the TUI with one backend-dispatching store method to stay DRY
-- add `ParticipantStore::spawn(config)` or equivalent central dispatch
-- add `Participant::spawn_cloudflare(...)` or equivalent internal constructor
-
-Recommended simplification:
-
-- do not add a large new TUI editor for every Cloudflare field in the first patch
-- keep backend selection in the TUI
-- keep advanced Cloudflare settings configurable through YAML first
-
-TDD steps:
-
-- [x] add failing config parsing tests for `backend: cloudflare` and the nested `cloudflare` block
-- [x] add a failing store test proving backend dispatch reaches the Cloudflare constructor
-- [x] implement the config and dispatch changes until the tests pass
-
-Implemented in this phase:
-
-- extended `ParticipantBackendKind` with `cloudflare`
-- added `CloudflareConfig` in `config/` and threaded it through `Config` plus the default YAML
-- updated config parsing tests to cover `backend: cloudflare` and the nested `cloudflare` block
-- replaced the TUI's direct local vs remote-stub branching with `ParticipantStore::spawn(config)` backend dispatch
-- added `Participant::spawn(config, ...)` and `Participant::spawn_cloudflare(...)` dispatch wiring
-- added a minimal `CloudflareSession` placeholder so the Cloudflare backend path can be constructed and routed without implementing the real driver yet
-- added a browser-store test proving Cloudflare backend dispatch reaches the Cloudflare constructor
-
-Notes:
-
-- the Cloudflare backend now parses and dispatches correctly, but the placeholder session still returns an explicit "not implemented yet" start error until Phase 3
-
-Completion criteria:
-
-- the user can select `cloudflare` as a backend
-- the simulator can construct a Cloudflare-backed participant session from config
-
-### Phase 3: Implement `CloudflareSession` start and close
-
-Goal:
-
-- create a real remote participant backend with correct lifecycle semantics
-
-Recommended `CloudflareSession` fields:
-
-- `launch_spec: ParticipantLaunchSpec`
-- `cloudflare_config: CloudflareConfig`
-- `log_sender: UnboundedSender<ParticipantLogMessage>`
-- `session_id: Option<String>`
-- `cached_state: ParticipantState`
-- auth dependencies needed to lazily obtain a cookie for Hyper Core
-
-`start()` should:
-
-- prepare the create-session request from `ParticipantLaunchSpec`
-- fetch or reuse a `hyper_session` cookie for Hyper Core if needed
-- call the worker create endpoint
-- store `sessionId`
-- initialize `cached_state` from the worker response
-- forward worker log entries into the participant log channel
-
-`close()` should:
-
-- call the worker close endpoint if a session exists
-- clear local session state
-- be idempotent
-
-TDD steps:
-
-- [x] add a failing integration test against a mock worker for successful start
-- [x] add a failing integration test for close-after-start
-- [x] add a failing test for Hyper Core cookie injection into the create request
-- [x] implement `start()` and `close()` until those tests pass
-
-Implemented in this phase:
-
-- added `cloudflare-worker-client` as a browser-crate dependency and used it from the Cloudflare driver lifecycle
-- replaced the placeholder `CloudflareSession` start failure with real worker `create_session` and `close_session` calls
-- reused an already-borrowed Hyper Core cookie when available and otherwise fetched one locally through `HyperSessionCookieManger` before sending only the raw cookie value to the worker
-- mapped `ParticipantLaunchSpec` settings into the worker create request and mapped worker participant state back into Rust `ParticipantState`
-- cached the initial worker state locally so the shared runtime can publish accurate state immediately after startup
-- made `close()` idempotent when no worker session exists
-- added a mock-HTTP lifecycle test covering guest-cookie fetch, worker create payload, initial state caching, and worker close dispatch
-
-Notes:
-
-- `handle_command()` still returns an explicit "not implemented yet" error for Cloudflare commands
-- `wait_for_termination()` is still pending and will be implemented with worker state polling in Phase 4
-
-Completion criteria:
-
-- a Cloudflare participant can be started and closed through the shared runtime
-- no Cloudflare identifiers leak above the driver
-
-### Phase 4: Implement command handling, cached state, and termination polling
-
-Goal:
-
-- reach full runtime compatibility with the command/state contract
-
-Implementation notes:
-
-- map every `ParticipantMessage` variant to the worker command API
-- update `cached_state` from worker command responses
-- make `refresh_state()` return the cached authoritative state from the last worker response
-- reserve explicit worker state calls for:
-  - termination polling
-  - recovery or debugging paths
-
-Recommended command semantics:
-
-- `Join` -> worker join command
-- `Leave` -> worker leave command, keep the backend session alive
-- `ToggleAudio` -> worker toggle audio command
-- `ToggleVideo` -> worker toggle video command
-- `ToggleScreenshare` -> worker toggle screenshare command
-- `SetNoiseSuppression` -> worker set noise suppression command
-- `SetWebcamResolutions` -> worker set webcam resolution command
-- `ToggleBackgroundBlur` -> worker toggle blur command
-
-Termination handling:
-
-- spawn a background polling task after `start()`
-- hit the worker state endpoint at a low frequency
-- if the worker reports the session missing, closed, or failed, send a `DriverTermination`
-- stop the poll cleanly during intentional close
-
-TDD steps:
-
-- [x] add one failing test per command mapping
-- [x] add a failing test proving `refresh_state()` reflects command responses without extra network calls
-- [x] add a failing test for unexpected termination on worker `404` or equivalent closed-session signal
-- [x] implement command handling and polling until the tests pass
-
-Implemented in this phase:
-
-- mapped the full `ParticipantMessage` surface onto the worker command API and updated the Cloudflare cached state from each command response
-- changed `refresh_state()` to return the in-memory cached worker state instead of making extra network calls
-- added a background worker-state poller that refreshes cached state during health checks and reports unexpected worker-side session loss through `wait_for_termination()`
-- stopped the poller cleanly during intentional close so the runtime can distinguish expected shutdown from backend loss
-- expanded the Cloudflare driver tests to cover command payload mapping, cache-only refresh behavior, and termination reporting on worker-state failures
-
-Notes:
-
-- the driver now reaches command/state parity with the shared runtime contract
-- Phase 5 is still the next unimplemented slice and will focus on backend-specific UX and limitation handling
-
-Completion criteria:
-
-- `CloudflareSession` supports the full `ParticipantMessage` surface
-- runtime state remains accurate after start and every command
-- unexpected worker-side session loss reaches `wait_for_termination()`
-
-### Phase 5: Add TUI and UX handling for backend-specific limitations
-
-Goal:
-
-- keep the UI understandable without overcomplicating it
-
-Recommended behavior:
-
-- allow all existing participant controls to remain visible
-- when the backend cannot honor a local-only setting, surface that through logs and resulting state
-- keep the TUI layout stable in the first iteration
-
-Specific decisions to encode:
-
-- `headless` is ignored for Cloudflare because the backend is always headless
-- local fake-media file and URL selections are ignored for Cloudflare
-- transport should normalize to `WebRTC`; if the user configured `WebTransport`, log the normalization and reflect `WebRTC` in state
-
-Optional follow-up, not required for the first implementation:
-
-- annotate unsupported fields in the TUI when `backend == cloudflare`
-
-TDD steps:
-
-- [x] add a failing test for transport normalization
-- [x] add a failing test for ignored fake-media settings producing a log entry
-- [x] implement the minimal UX behavior needed for those tests
-
-Implemented in this phase:
-
-- added Cloudflare-only launch-option handling so the driver can reason about headless and fake-media selections without introducing TUI-specific branching into the shared runtime
-- normalized Cloudflare create-session requests to `WebRTC` when the user configured `WebTransport`, and emitted a warning log explaining the normalization
-- added warning logs when the Cloudflare backend is asked to honor `headless: false` or a local fake-media file/URL selection that the worker cannot use
-- kept the existing TUI layout and controls unchanged so backend-specific behavior stays visible through logs and resulting participant state instead of extra UI forks
-- expanded the Cloudflare driver tests to cover transport normalization plus ignored-setting log emission
-
-Notes:
-
-- the simulator still exposes the existing controls, but Cloudflare-specific limitations are now surfaced predictably at session start
-- Phase 6 remains the next open slice and is limited to broader automated and manual validation
-
-Completion criteria:
-
-- backend-specific behavior is visible and predictable
-- the UI does not need backend-specific branching for every participant command
-
-### Phase 6: Validate with unit, integration, and manual tests
-
-Goal:
-
-- verify the backend works without a real Cloudflare dependency in automated tests
-
-Automated tests:
-
-- add unit tests close to the Cloudflare mapping and config code
-- add integration tests in `browser/tests/` with a mock HTTP server such as `wiremock`
-- exercise the shared runtime with a real `CloudflareSession` against mocked worker responses
-
-Suggested automated scenarios:
-
-- start success for Hyper Core
-- start success for Hyper Lite
-- command success for every `ParticipantMessage` variant
-- command failure logging without crashing the runtime
-- close after leave
-- unexpected termination detection
-- config parsing and backend dispatch
-
-Manual validation:
-
-- `just test`
-- `just clippy`
-- run the worker locally and point the simulator at it through the new Cloudflare config block
-- join a Hyper Core room
-- join a Hyper Lite room
-- exercise audio, video, screenshare, noise suppression, resolution, blur, leave, and close
-
-Implemented in this phase:
-
-- added `browser/tests/cloudflare_driver.rs` to exercise the Cloudflare backend through the public `Participant` runtime instead of the driver internals
-- covered a Hyper Lite end-to-end flow where mocked worker responses drive the shared participant state through start, join, audio toggle, video toggle, and close
-- covered a command-failure path to prove the shared runtime keeps the participant alive after a worker command error and can still close cleanly
-- covered unexpected termination handling by letting the worker state poll fail and asserting the public participant state transitions to stopped
-- covered the Hyper Core auth path through the public backend spawn flow, including guest-cookie fetch, `/api/v1/auth/me/name`, and propagation of the fetched `hyper_session` cookie into the worker create request
-
-Notes:
-
-- existing unit coverage in `browser/src/participant/cloudflare/mod.rs` and config/runtime tests remain in place; this phase adds the missing browser-level integration layer on top
-- manual smoke validation against a real local worker has not been executed yet, so this phase is not marked complete
-
-Completion criteria:
-
-- automated tests cover the driver contract
-- manual smoke tests pass against a real worker
-
-## Recommended File Changes
-
-Rust workspace:
-
-- `Cargo.toml`
-- `browser/Cargo.toml`
-- `config/src/client_config.rs`
-- `config/src/lib.rs`
-- `config/src/default-config.yaml`
-- `browser/src/participant/mod.rs`
-- `browser/src/participant/shared/store.rs`
-- `browser/src/participant/cloudflare/mod.rs`
-- `tui/src/tui/components/browser_start.rs`
-
-New files and directories:
-
-- `cloudflare-worker-client/Cargo.toml`
-- `cloudflare-worker-client/build.rs`
-- `cloudflare-worker-client/openapi/cloudflare-browser-simulator.json`
-- `cloudflare-worker-client/src/generated.rs`
-- `cloudflare-worker-client/src/lib.rs`
-- `cloudflare-worker-client/src/client.rs`
-- `browser/tests/cloudflare_driver.rs`
-
-## Risks And Mitigations
-
-### Risk: a separate driver crate causes a dependency cycle
-
-Mitigation:
-
-- keep the generated client in a new crate
-- keep the actual `CloudflareSession` in `client-simulator-browser`
-
-### Risk: double round-trips for every command
-
-Mitigation:
-
-- use create and command responses as authoritative state updates
-- do not immediately re-fetch state after every command just because the runtime has a `refresh_state()` hook
-
-### Risk: Cloudflare session lifetime is shorter than local Chromium sessions
-
-Mitigation:
-
-- surface the configured keep-alive limits clearly in config and logs
-- rely on the termination poller so the runtime reflects worker-side expiry promptly
-
-### Risk: fake-media parity becomes a scope trap
-
-Mitigation:
-
-- explicitly ship v1 with synthetic worker media only
-- keep local fake-media handling local-only
-
-## Recommended First Patch Set
-
-The first implementation PR in this repo should do only this:
-
-1. add the generated-client crate
-2. add Cloudflare config and backend selection
-3. add the `CloudflareSession` skeleton with start and close only
-4. add mock-worker integration tests for start and close
-
-That gives a reviewable base. Command parity and polish can land immediately after.
diff --git a/2026-04-17_build-macos-binary.md b/2026-04-17_build-macos-binary.md
deleted file mode 100644
index b1b8486..0000000
--- a/2026-04-17_build-macos-binary.md
+++ /dev/null
@@ -1,287 +0,0 @@
-# Plan: Build macOS Binary Distribution
-
-## Goal
-
-Set this repo up to ship prebuilt macOS binaries for colleagues without requiring a local Rust toolchain.
-
-Keep the implementation simple:
-
-- use `dist` (`cargo-dist`) to build release archives and generate the release workflow,
-- make local macOS Chrome discovery work outside the Nix shell,
-- run the macOS release builds on Blacksmith macOS runners.
-
-This plan is intentionally limited to shipping the `hyper-client-simulator` CLI for macOS.
-It does not try to redesign the runtime, build a `.app` bundle, or add extra packaging formats unless `dist` gives them to us cheaply.
-
-## Constraints And Assumptions
-
-- The shipped binary still depends on a locally installed Chrome/Chromium runtime.
-- The current code only discovers Chrome via `PATH`, which is not enough for normal macOS machines.
-- `ffmpeg` is only needed for custom fake-media conversion. That should not block the base distribution plan.
-- This repo is already a normal Rust workspace with a root binary package, which fits `dist` well.
-
-## Implementation Steps
-
-### 1. Add `dist` configuration for macOS release artifacts
-
-STATUS: completed
-
-Objective:
-
-- introduce the minimal `dist` config needed to build release archives for:
-  - `aarch64-apple-darwin`
-  - `x86_64-apple-darwin`
-
-Work:
-
-- install `dist` locally using our nix flake and the `cargo-dist` derivation and initialize the workspace with `dist init`
-- commit the generated `Cargo.toml` metadata and any generated workflow/config files
-- keep the initial target list macOS-only instead of enabling a larger cross-platform matrix right now
-- make sure the root package metadata is present and suitable for generated release artifacts:
-  - `description`
-  - `homepage` or a repository/homepage value usable by release tooling
-- use the generated `profile.dist` instead of inventing custom release profiles
-
-Expected result:
-
-- `dist` can produce release archives for both macOS architectures from this workspace
-- the repo has a standard `dist` config that can be regenerated later with `dist init`
-
-Notes:
-
-- `dist` can also manage Homebrew later, but the base GitHub Release artifact flow should land first.
-- Avoid custom `dist` scripting unless the generated defaults prove insufficient.
-
-### 2. Add `just` commands for local release workflows
-
-STATUS: completed
-
-Objective:
-
-- make local release-related operations obvious and repeatable
-
-Work:
-
-- add a small set of `justfile` commands, likely:
-  - `just dist-init`
-  - `just dist-generate`
-  - `just dist-plan`
-  - `just dist-build`
-- keep the commands thin wrappers around `dist`
-- prefer names that match the `dist` subcommands directly
-
-Expected result:
-
-- contributors can regenerate config and test release builds locally without remembering `dist` syntax
-
-Notes:
-
-- Do not add a large release DSL to `justfile`
-- Do not duplicate CI logic in `just`; keep it as a thin local entrypoint
-
-### 3. Extend Chrome discovery for normal macOS installs
-
-STATUS: completed
-
-Objective:
-
-- make the released binary work on a colleague’s Mac without relying on the Nix shell adding Chrome to `PATH`
-
-Current code:
-
-- `browser/src/participant/local/session.rs` looks up:
-  - `chromium`
-  - `google-chrome`
-  - `google-chrome-stable`
-  - `chrome`
-- if none are on `PATH`, startup fails
-
-Work:
-
-- keep the existing `PATH` lookup first
-- add a macOS fallback that checks common app-bundle executable locations, starting with:
-  - `/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`
-- optionally also check:
-  - `/Applications/Chromium.app/Contents/MacOS/Chromium`
-  - `~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`
-- return the first existing executable path
-- keep the change scoped to one helper, likely `get_binary()`
-- add focused unit coverage for the path-resolution logic if the function can be made testable without filesystem-heavy integration tests
-
-Expected result:
-
-- the binary works on standard macOS setups where Chrome is installed in `/Applications`
-
-Notes:
-
-- Keep this as detection logic only
-- Do not add a full browser-install manager
-- Do not introduce a macOS-only CLI flag unless the fallback logic turns out to be too brittle
-
-### 4. Generate the GitHub release workflow with `dist`
-
-STATUS: completed
-
-Objective:
-
-- let `dist` own the release workflow rather than hand-writing a separate packaging pipeline
-
-Work:
-
-- use `dist`’s GitHub CI integration so `.github/workflows/release.yml` is generated from config
-- review the generated workflow and only make the smallest necessary customizations
-- keep the CI model close to upstream `dist` conventions so `dist init` / `dist generate` stay usable later
-
-Expected result:
-
-- release builds are driven by a standard `dist` workflow and tag-based release process
-
-Notes:
-
-- Avoid hand-maintaining a fully custom release workflow if `dist` can express the same thing in config
-- If workflow customization is needed, prefer `dist` config knobs over direct YAML edits
-
-### 5. Route macOS targets to Blacksmith macOS runners
-
-STATUS: completed
-
-Objective:
-
-- build macOS release artifacts on Blacksmith using the requested runner class
-
-Work:
-
-- configure `dist` custom runners for the macOS targets so generated release jobs use:
-  - `blacksmith-12vcpu-macos-latest`
-- keep any non-macOS global/planning jobs on the simplest supported runner unless there is a strong reason to move them too
-- confirm the generated workflow still remains mostly `dist`-managed
-
-Expected result:
-
-- macOS artifact jobs run on Blacksmith instead of GitHub-hosted macOS runners
-
-Notes:
-
-- The main customization point should be `dist`’s GitHub custom runner configuration, not a hand-edited workflow matrix
-- If `dist` requires a separate global runner setting for plan/host jobs, keep that explicit and minimal
-
-### 6. Validate the end-to-end release path
-
-STATUS: completed
-
-Objective:
-
-- confirm the new flow works before relying on it for colleague distribution
-
-Work:
-
-- run the local `just dist-plan` / `just dist-build` commands
-- verify the generated artifacts include the `hyper-client-simulator` binary for both macOS targets
-- open or inspect the generated release workflow
-- if practical, test one dry-run or pre-release tag in GitHub Actions
-- verify the binary can find Chrome on a normal macOS install outside the Nix shell
-
-Expected result:
-
-- confidence that a tagged release will produce usable macOS artifacts
-
-### 7. Add Homebrew installer support
-
-STATUS: implemented in-repo, pending GitHub secret setup
-
-Objective:
-
-- let colleagues install `hyper-client-simulator` with Homebrew instead of manually downloading release archives
-
-Work:
-
-- enable the `homebrew` installer in `dist`
-- publish to the dedicated tap `hypervideo/homebrew-tap`
-- configure the required Homebrew metadata in `dist` so generated formulae point at the GitHub Release artifacts for this repo
-- regenerate the `dist` release workflow so Homebrew publishing is managed by `dist` rather than a separate hand-written pipeline
-- document the expected install flow for users, including:
-  - `brew tap ...`
-  - `brew install hyper-client-simulator`
-- verify the generated Homebrew formula installs the macOS binary and that the installed binary still relies on the local Chrome/Chromium runtime as expected
-
-Current state:
-
-- `dist-workspace.toml` enables the `homebrew` installer, sets `tap = "hypervideo/homebrew-tap"`, and asks `dist` to run the `homebrew` publish job
-- `.github/workflows/release.yml` is generated from `dist` and includes the `publish-homebrew-formula` job that pushes `Formula/*.rb` into the tap repo using `HOMEBREW_TAP_TOKEN`
-- the public tap repository now exists at `https://github.com/hypervideo/homebrew-tap`
-- local verification on 2026-04-20 succeeded:
-  - `cargo dist manifest --artifacts=all --output-format=json --no-local-paths --allow-dirty --tag=v0.1.0` reported `hyper-client-simulator.rb` plus the macOS release archives
-  - `cargo dist build --target aarch64-apple-darwin --artifacts=all --allow-dirty --tag=v0.1.0` generated a real arm64 archive and formula
-  - installing that generated formula from a throwaway local tap succeeded
-  - `hyper-client-simulator --help` ran successfully after the Homebrew install
-- the installed Homebrew package contains the simulator binary and README only; it does not bundle Chrome/Chromium, so runtime browser discovery still depends on the local machine as intended
-
-Remaining GitHub setup:
-
-1. create a GitHub token with write access to `hypervideo/homebrew-tap`
-2. add that token as the `HOMEBREW_TAP_TOKEN` secret on `hypervideo/browser-simulator`
-3. push a stable version tag so the `Release` workflow publishes the formula into the tap
-
-Expected user install flow:
-
-- `brew tap hypervideo/tap`
-- `brew install hyper-client-simulator`
-- `brew upgrade hyper-client-simulator`
-
-Expected result:
-
-- tagged releases publish both plain GitHub Release archives and a Homebrew formula
-- colleagues can install or upgrade with `brew`
-
-Notes:
-
-- Keep Homebrew support scoped to the existing macOS CLI distribution
-- Do not broaden this into notarization, `.app` bundling, or extra installer formats
-- Prefer `dist`'s native Homebrew support over maintaining a custom formula by hand
-- Homebrew only tracks the latest published formula version; prereleases do not publish unless `publish-prereleases` is explicitly enabled
-
-## Suggested Order Of Execution
-
-1. Add `dist` config.
-2. Add the `just` commands.
-3. Fix macOS Chrome discovery.
-4. Generate and review the release workflow.
-5. Configure Blacksmith runners through `dist`.
-6. Validate the local and CI release flow.
-7. Add Homebrew installer support once the base release flow is stable.
-
-## Non-Goals For This Pass
-
-- building a signed `.app` bundle
-- notarization
-- DMG packaging
-- automatic Chrome installation
-- broad Linux/Windows release support
-
-Homebrew is a follow-up phase after the base GitHub Release artifact flow is stable.
-
-## Documentation References
-
-- dist introduction: https://axodotdev.github.io/cargo-dist/book/introduction.html
-- dist install: https://axodotdev.github.io/cargo-dist/book/install.html
-- dist simple workspace guide: https://axodotdev.github.io/cargo-dist/book/workspaces/simple-guide.html
-- dist config reference, including `github-custom-runners`: https://axodotdev.github.io/cargo-dist/book/reference/config.html
-- dist Homebrew installer docs, for later follow-up: https://axodotdev.github.io/cargo-dist/book/installers/homebrew.html
-- Blacksmith quickstart and runner-tag mapping: https://docs.blacksmith.sh/introduction/quickstart
-
-## Practical Deliverables
-
-When this plan is implemented, the resulting diff should roughly contain:
-
-- `Cargo.toml` updates for `dist`
-- `justfile` release commands
-- a small macOS Chrome discovery change in `browser/src/participant/local/session.rs`
-- a generated `.github/workflows/release.yml`
-- any `dist`-managed config files generated by initialization
-
-If the Homebrew follow-up is implemented too, the resulting diff should also roughly contain:
-
-- `dist` installer config enabling Homebrew
-- any Homebrew-specific `dist` metadata needed for the chosen tap
-- regenerated `dist` release workflow changes required for Homebrew publishing
-- short contributor or user-facing install docs showing the `brew tap` / `brew install` flow

From 615d9aadef04a3d8933d8168cbcce5b6759fbc8f Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:06:55 +0200
Subject: [PATCH 02/42] build(browser): add aws-config, aws-sdk-devicefarm,
 thirtyfour deps

---
 Cargo.lock         | 899 +++++++++++++++++++++++++++++++++++++++++++--
 Cargo.toml         |   3 +
 browser/Cargo.toml |   3 +
 3 files changed, 867 insertions(+), 38 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ebf7fac..32e8055 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -97,6 +97,15 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
+[[package]]
+name = "arc-swap"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a3a1fd6f75306b68087b831f025c712524bcb19aad54e557b1129cfa0a2b207"
+dependencies = [
+ "rustversion",
+]
+
 [[package]]
 name = "arraydeque"
 version = "0.5.1"
@@ -152,6 +161,44 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
+[[package]]
+name = "aws-config"
+version = "1.8.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "517aa062d8bd9015ee23d6daa5e1c1372328412fdae4e6c4c1be9b69c6ad37a2"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-sdk-sts",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-schema",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "http 1.4.0",
+ "time",
+ "tokio",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "aws-credential-types"
+version = "1.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f20799b373a1be121fe3005fba0c2090af9411573878f224df44b42727fcaf7"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "zeroize",
+]
+
 [[package]]
 name = "aws-lc-rs"
 version = "1.16.3"
@@ -174,6 +221,310 @@ dependencies = [
  "fs_extra",
 ]
 
+[[package]]
+name = "aws-runtime"
+version = "1.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ed8e8c52d2dc2390ad9f15647fe663f71e9780b4262c190fbb823a32721566"
+dependencies = [
+ "aws-credential-types",
+ "aws-sigv4",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "bytes-utils",
+ "fastrand",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "percent-encoding",
+ "pin-project-lite",
+ "tracing",
+ "uuid",
+]
+
+[[package]]
+name = "aws-sdk-devicefarm"
+version = "1.105.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f81a9aa2b25d3f45676bafe80560d9b39b9c3a31344d0f33db44274d4ad942df"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-observability",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "http 0.2.12",
+ "http 1.4.0",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sdk-sts"
+version = "1.105.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59f4f8065fe615dbed9096458ba98dda6d641553ffd5aedd27e37e65211aca9f"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-observability",
+ "aws-smithy-query",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-smithy-xml",
+ "aws-types",
+ "fastrand",
+ "http 0.2.12",
+ "http 1.4.0",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sigv4"
+version = "1.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7083fb918b38474ac65ffbf8a69fc8792d36879f4ac5f1667b43aec61efe9a5"
+dependencies = [
+ "aws-credential-types",
+ "aws-smithy-http",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "form_urlencoded",
+ "hex",
+ "hmac",
+ "http 0.2.12",
+ "http 1.4.0",
+ "percent-encoding",
+ "sha2 0.11.0",
+ "time",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-async"
+version = "1.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ffcaf626bdda484571968400c326a244598634dc75fd451325a54ad1a59acfc"
+dependencies = [
+ "futures-util",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "aws-smithy-http"
+version = "0.63.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba1ab2dc1c2c3749ead27180d333c42f11be8b0e934058fb4b2258ee8dbe5231"
+dependencies = [
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "bytes-utils",
+ "futures-core",
+ "futures-util",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "http-body-util",
+ "percent-encoding",
+ "pin-project-lite",
+ "pin-utils",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-http-client"
+version = "1.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a2f165a7feee6f263028b899d0a181987f4fa7179a6411a32a439fba7c5f769"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "h2 0.3.27",
+ "h2 0.4.14",
+ "http 0.2.12",
+ "http 1.4.0",
+ "http-body 0.4.6",
+ "hyper 0.14.32",
+ "hyper 1.9.0",
+ "hyper-rustls 0.24.2",
+ "hyper-rustls 0.27.9",
+ "hyper-util",
+ "pin-project-lite",
+ "rustls 0.21.12",
+ "rustls 0.23.40",
+ "rustls-native-certs",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls 0.26.4",
+ "tower",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-json"
+version = "0.62.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "517089205f18ab4adc5a3e02888cb139bbbbb2e168eac9f396216925d1fbeaf5"
+dependencies = [
+ "aws-smithy-runtime-api",
+ "aws-smithy-schema",
+ "aws-smithy-types",
+]
+
+[[package]]
+name = "aws-smithy-observability"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06c2315d173edbf1920da8ba3a7189695827002e4c0fc961973ab1c54abca9c"
+dependencies = [
+ "aws-smithy-runtime-api",
+]
+
+[[package]]
+name = "aws-smithy-query"
+version = "0.60.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a56d79744fb3edb5d722ef79d86081e121d3b9422cb209eb03aea6aa4f21ebd"
+dependencies = [
+ "aws-smithy-types",
+ "urlencoding",
+]
+
+[[package]]
+name = "aws-smithy-runtime"
+version = "1.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e6f5caf6fea86f8c2206541ab5857cfcda9013426cdbe8fa0098b9e2d32182"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-http-client",
+ "aws-smithy-observability",
+ "aws-smithy-runtime-api",
+ "aws-smithy-schema",
+ "aws-smithy-types",
+ "bytes",
+ "fastrand",
+ "http 0.2.12",
+ "http 1.4.0",
+ "http-body 0.4.6",
+ "http-body 1.0.1",
+ "http-body-util",
+ "pin-project-lite",
+ "pin-utils",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-runtime-api"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc117c179ecf39a62a0a3f49f600e9ac26a7ad7dd172177999f83933af776c32"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api-macros",
+ "aws-smithy-types",
+ "bytes",
+ "http 0.2.12",
+ "http 1.4.0",
+ "pin-project-lite",
+ "tokio",
+ "tracing",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-smithy-runtime-api-macros"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d7396fd9500589e62e460e987ecb671bad374934e55ec3b5f498cc7a8a8a7b7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "aws-smithy-schema"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7442cb268338f0eb8278140a107c046756aa01093d8ef5e99628d34ae09c94f5"
+dependencies = [
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "http 1.4.0",
+]
+
+[[package]]
+name = "aws-smithy-types"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "056b66dbce2f81cc0c1e2b05bb402eb58f8a3530479d650efadd5bbae9a4050b"
+dependencies = [
+ "base64-simd",
+ "bytes",
+ "bytes-utils",
+ "futures-core",
+ "http 0.2.12",
+ "http 1.4.0",
+ "http-body 0.4.6",
+ "http-body 1.0.1",
+ "http-body-util",
+ "itoa",
+ "num-integer",
+ "pin-project-lite",
+ "pin-utils",
+ "ryu",
+ "serde",
+ "time",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "aws-smithy-xml"
+version = "0.60.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce02add1aa3677d022f8adf81dcbe3046a95f17a1b1e8979c145cd21d3d22b3"
+dependencies = [
+ "xmlparser",
+]
+
+[[package]]
+name = "aws-types"
+version = "1.3.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d16bf10b03a3c01e6b3b7d47cd964e873ffe9e7d4e80fad16bd4c077cb068531"
+dependencies = [
+ "aws-credential-types",
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-schema",
+ "aws-smithy-types",
+ "rustc_version",
+ "tracing",
+]
+
 [[package]]
 name = "backtrace"
 version = "0.3.76"
@@ -195,6 +546,16 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "base64-simd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195"
+dependencies = [
+ "outref",
+ "vsimd",
+]
+
 [[package]]
 name = "better-panic"
 version = "0.3.0"
@@ -274,6 +635,16 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bytes-utils"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dafe3a8757b027e2be6e4e5601ed563c55989fcf1546e933c66c8eb3a058d35"
+dependencies = [
+ "bytes",
+ "either",
+]
+
 [[package]]
 name = "castaway"
 version = "0.2.4"
@@ -430,6 +801,8 @@ checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 name = "client-simulator-browser"
 version = "0.3.4"
 dependencies = [
+ "aws-config",
+ "aws-sdk-devicefarm",
  "chromiumoxide",
  "chrono",
  "client-simulator-config",
@@ -441,6 +814,7 @@ dependencies = [
  "serde",
  "serde_json",
  "strum 0.28.0",
+ "thirtyfour",
  "tokio",
  "tokio-util",
  "tracing",
@@ -526,6 +900,12 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "cmov"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c9ea0ac24bc397ab3c98583a3c9ba74fa56b09a4449bbe172b9b1ddb016027a"
+
 [[package]]
 name = "color-eyre"
 version = "0.6.5"
@@ -616,6 +996,27 @@ version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
 
+[[package]]
+name = "const_format"
+version = "0.2.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4481a617ad9a412be3b97c5d403fef8ed023103368908b9c50af598ff467cc1e"
+dependencies = [
+ "const_format_proc_macros",
+ "konst",
+]
+
+[[package]]
+name = "const_format_proc_macros"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
 [[package]]
 name = "convert_case"
 version = "0.6.0"
@@ -707,6 +1108,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "crossterm"
 version = "0.28.1"
@@ -782,6 +1192,15 @@ dependencies = [
  "phf",
 ]
 
+[[package]]
+name = "ctutils"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e"
+dependencies = [
+ "cmov",
+]
+
 [[package]]
 name = "darling"
 version = "0.23.0"
@@ -885,6 +1304,7 @@ dependencies = [
  "block-buffer 0.12.0",
  "const-oid",
  "crypto-common 0.2.1",
+ "ctutils",
 ]
 
 [[package]]
@@ -896,6 +1316,15 @@ dependencies = [
  "dirs-sys",
 ]
 
+[[package]]
+name = "dirs"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
+dependencies = [
+ "dirs-sys",
+]
+
 [[package]]
 name = "dirs-sys"
 version = "0.5.0"
@@ -1016,6 +1445,12 @@ dependencies = [
  "regex",
 ]
 
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
 [[package]]
 name = "filedescriptor"
 version = "0.8.3"
@@ -1027,6 +1462,16 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "filetime"
+version = "0.2.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
+dependencies = [
+ "cfg-if",
+ "libc",
+]
+
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.9"
@@ -1045,6 +1490,17 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+ "zlib-rs",
+]
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -1072,6 +1528,17 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "fs4"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e72ed92b67c146290f88e9c89d60ca163ea417a446f61ffd7b72df3e7f1dfd5"
+dependencies = [
+ "rustix 1.1.4",
+ "tokio",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "fs_extra"
 version = "1.3.0"
@@ -1228,6 +1695,25 @@ version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 
+[[package]]
+name = "h2"
+version = "0.3.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http 0.2.12",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
 [[package]]
 name = "h2"
 version = "0.4.14"
@@ -1239,7 +1725,7 @@ dependencies = [
  "fnv",
  "futures-core",
  "futures-sink",
- "http",
+ "http 1.4.0",
  "indexmap",
  "slab",
  "tokio",
@@ -1294,6 +1780,26 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "hmac"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f"
+dependencies = [
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "http"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
 [[package]]
 name = "http"
 version = "1.4.0"
@@ -1304,6 +1810,17 @@ dependencies = [
  "itoa",
 ]
 
+[[package]]
+name = "http-body"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
+dependencies = [
+ "bytes",
+ "http 0.2.12",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "http-body"
 version = "1.0.1"
@@ -1311,7 +1828,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
  "bytes",
- "http",
+ "http 1.4.0",
 ]
 
 [[package]]
@@ -1322,8 +1839,8 @@ checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
 dependencies = [
  "bytes",
  "futures-core",
- "http",
- "http-body",
+ "http 1.4.0",
+ "http-body 1.0.1",
  "pin-project-lite",
 ]
 
@@ -1333,6 +1850,12 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
 [[package]]
 name = "human-panic"
 version = "2.0.8"
@@ -1358,6 +1881,30 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "hyper"
+version = "0.14.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2 0.3.27",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "socket2 0.5.10",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "want",
+]
+
 [[package]]
 name = "hyper"
 version = "1.9.0"
@@ -1368,9 +1915,9 @@ dependencies = [
  "bytes",
  "futures-channel",
  "futures-core",
- "h2",
- "http",
- "http-body",
+ "h2 0.4.14",
+ "http 1.4.0",
+ "http-body 1.0.1",
  "httparse",
  "itoa",
  "pin-project-lite",
@@ -1401,18 +1948,34 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "hyper-rustls"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
+dependencies = [
+ "futures-util",
+ "http 0.2.12",
+ "hyper 0.14.32",
+ "log",
+ "rustls 0.21.12",
+ "tokio",
+ "tokio-rustls 0.24.1",
+]
+
 [[package]]
 name = "hyper-rustls"
 version = "0.27.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"
 dependencies = [
- "http",
- "hyper",
+ "http 1.4.0",
+ "hyper 1.9.0",
  "hyper-util",
- "rustls",
+ "rustls 0.23.40",
+ "rustls-native-certs",
  "tokio",
- "tokio-rustls",
+ "tokio-rustls 0.26.4",
  "tower-service",
 ]
 
@@ -1426,14 +1989,14 @@ dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
- "http",
- "http-body",
- "hyper",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "hyper 1.9.0",
  "ipnet",
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2",
+ "socket2 0.6.3",
  "system-configuration",
  "tokio",
  "tower-service",
@@ -1780,6 +2343,21 @@ dependencies = [
  "thiserror 2.0.18",
 ]
 
+[[package]]
+name = "konst"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "128133ed7824fcd73d6e7b17957c5eb7bacb885649bd8c69708b2331a10bcefb"
+dependencies = [
+ "konst_macro_rules",
+]
+
+[[package]]
+name = "konst_macro_rules"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4933f3f57a8e9d9da04db23fb153356ecaf00cbd14aee46279c33dc80925c37"
+
 [[package]]
 name = "lab"
 version = "0.11.0"
@@ -1941,6 +2519,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
 dependencies = [
  "adler2",
+ "simd-adler32",
 ]
 
 [[package]]
@@ -2022,6 +2601,15 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -2118,6 +2706,12 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "outref"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
+
 [[package]]
 name = "owo-colors"
 version = "4.3.0"
@@ -2147,6 +2741,12 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "pastey"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
+
 [[package]]
 name = "pathdiff"
 version = "0.2.3"
@@ -2199,7 +2799,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "89815c69d36021a140146f26659a81d6c2afa33d216d736dd4be5381a7362220"
 dependencies = [
  "pest",
- "sha2",
+ "sha2 0.10.9",
 ]
 
 [[package]]
@@ -2260,6 +2860,12 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
 [[package]]
 name = "portable-atomic"
 version = "1.13.1"
@@ -2361,7 +2967,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6e349eed84b9a1a6a5dbe478d335e3df73d32a93c5eefe571c9b8cb298aab5d"
 dependencies = [
  "heck",
- "http",
+ "http 1.4.0",
  "indexmap",
  "openapiv3",
  "proc-macro2",
@@ -2422,8 +3028,8 @@ dependencies = [
  "quinn-proto",
  "quinn-udp",
  "rustc-hash",
- "rustls",
- "socket2",
+ "rustls 0.23.40",
+ "socket2 0.6.3",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
@@ -2443,7 +3049,7 @@ dependencies = [
  "rand 0.9.4",
  "ring",
  "rustc-hash",
- "rustls",
+ "rustls 0.23.40",
  "rustls-pki-types",
  "slab",
  "thiserror 2.0.18",
@@ -2461,7 +3067,7 @@ dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2",
+ "socket2 0.6.3",
  "tracing",
  "windows-sys 0.60.2",
 ]
@@ -2690,6 +3296,12 @@ dependencies = [
  "regex-syntax",
 ]
 
+[[package]]
+name = "regex-lite"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
+
 [[package]]
 name = "regex-syntax"
 version = "0.8.10"
@@ -2720,12 +3332,12 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2",
- "http",
- "http-body",
+ "h2 0.4.14",
+ "http 1.4.0",
+ "http-body 1.0.1",
  "http-body-util",
- "hyper",
- "hyper-rustls",
+ "hyper 1.9.0",
+ "hyper-rustls 0.27.9",
  "hyper-util",
  "js-sys",
  "log",
@@ -2733,7 +3345,7 @@ dependencies = [
  "percent-encoding",
  "pin-project-lite",
  "quinn",
- "rustls",
+ "rustls 0.23.40",
  "rustls-pki-types",
  "rustls-platform-verifier",
  "serde",
@@ -2741,7 +3353,7 @@ dependencies = [
  "serde_urlencoded",
  "sync_wrapper",
  "tokio",
- "tokio-rustls",
+ "tokio-rustls 0.26.4",
  "tokio-util",
  "tower",
  "tower-http",
@@ -2814,6 +3426,18 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "rustls"
+version = "0.21.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
+dependencies = [
+ "log",
+ "ring",
+ "rustls-webpki 0.101.7",
+ "sct",
+]
+
 [[package]]
 name = "rustls"
 version = "0.23.40"
@@ -2823,7 +3447,7 @@ dependencies = [
  "aws-lc-rs",
  "once_cell",
  "rustls-pki-types",
- "rustls-webpki",
+ "rustls-webpki 0.103.13",
  "subtle",
  "zeroize",
 ]
@@ -2861,10 +3485,10 @@ dependencies = [
  "jni",
  "log",
  "once_cell",
- "rustls",
+ "rustls 0.23.40",
  "rustls-native-certs",
  "rustls-platform-verifier-android",
- "rustls-webpki",
+ "rustls-webpki 0.103.13",
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
@@ -2877,6 +3501,16 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
+[[package]]
+name = "rustls-webpki"
+version = "0.101.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
 [[package]]
 name = "rustls-webpki"
 version = "0.103.13"
@@ -2951,6 +3585,16 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
+[[package]]
+name = "sct"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
 [[package]]
 name = "security-framework"
 version = "3.7.0"
@@ -3031,6 +3675,7 @@ version = "1.0.149"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
 dependencies = [
+ "indexmap",
  "itoa",
  "memchr",
  "serde",
@@ -3038,6 +3683,17 @@ dependencies = [
  "zmij",
 ]
 
+[[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "serde_spanned"
 version = "1.1.1"
@@ -3117,6 +3773,17 @@ dependencies = [
  "digest 0.10.7",
 ]
 
+[[package]]
+name = "sha2"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "digest 0.11.3",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -3173,6 +3840,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
 [[package]]
 name = "simd_cesu8"
 version = "1.1.1"
@@ -3207,6 +3880,16 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
+[[package]]
+name = "socket2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "socket2"
 version = "0.6.3"
@@ -3229,6 +3912,15 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
+[[package]]
+name = "stringmatch"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6aadc0801d92f0cdc26127c67c4b8766284f52a5ba22894f285e3101fa57d05d"
+dependencies = [
+ "regex",
+]
+
 [[package]]
 name = "strip-ansi-escapes"
 version = "0.2.1"
@@ -3369,6 +4061,17 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "tar"
+version = "0.4.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
 [[package]]
 name = "temp-dir"
 version = "0.2.0"
@@ -3433,7 +4136,7 @@ dependencies = [
  "pest_derive",
  "phf",
  "serde",
- "sha2",
+ "sha2 0.10.9",
  "signal-hook 0.3.18",
  "siphasher",
  "terminfo",
@@ -3450,6 +4153,50 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "thirtyfour"
+version = "0.36.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "801f15adc5e2882c13b36d48003e5512b017e7b89ebf5fb35d59074a261e6afb"
+dependencies = [
+ "arc-swap",
+ "async-trait",
+ "base64",
+ "bytes",
+ "cfg-if",
+ "const_format",
+ "dirs",
+ "flate2",
+ "fs4",
+ "futures-util",
+ "http 1.4.0",
+ "indexmap",
+ "pastey",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "stringmatch",
+ "tar",
+ "thirtyfour-macros",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "url",
+ "zip",
+]
+
+[[package]]
+name = "thirtyfour-macros"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cf0ffc3ba4368e99597bd6afd83f4ff6febad66d9ae541ab46e697d32285fc0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -3568,7 +4315,7 @@ dependencies = [
  "mio",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2",
+ "socket2 0.6.3",
  "tokio-macros",
  "windows-sys 0.61.2",
 ]
@@ -3584,13 +4331,23 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "tokio-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+dependencies = [
+ "rustls 0.21.12",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-rustls"
 version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
- "rustls",
+ "rustls 0.23.40",
  "tokio",
 ]
 
@@ -3658,8 +4415,8 @@ dependencies = [
  "bitflags 2.11.1",
  "bytes",
  "futures-util",
- "http",
- "http-body",
+ "http 1.4.0",
+ "http-body 1.0.1",
  "iri-string",
  "pin-project-lite",
  "tower",
@@ -3782,7 +4539,7 @@ checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
 dependencies = [
  "bytes",
  "data-encoding",
- "http",
+ "http 1.4.0",
  "httparse",
  "log",
  "rand 0.9.4",
@@ -3791,6 +4548,12 @@ dependencies = [
  "utf-8",
 ]
 
+[[package]]
+name = "typed-path"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e28f89b80c87b8fb0cf04ab448d5dd0dd0ade2f8891bae878de66a75a28600e"
+
 [[package]]
 name = "typenum"
 version = "1.20.0"
@@ -3910,6 +4673,12 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
 [[package]]
 name = "utf-8"
 version = "0.7.6"
@@ -3953,6 +4722,12 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "vsimd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64"
+
 [[package]]
 name = "vte"
 version = "0.14.1"
@@ -4164,7 +4939,7 @@ dependencies = [
  "getrandom 0.3.4",
  "mac_address",
  "serde",
- "sha2",
+ "sha2 0.10.9",
  "thiserror 1.0.69",
  "uuid",
 ]
@@ -4654,6 +5429,22 @@ version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
 
+[[package]]
+name = "xattr"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
+dependencies = [
+ "libc",
+ "rustix 1.1.4",
+]
+
+[[package]]
+name = "xmlparser"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
+
 [[package]]
 name = "yaml-rust2"
 version = "0.10.4"
@@ -4787,8 +5578,40 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "zip"
+version = "8.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d04a6b5381502aa6087c94c669499eb1602eb9c5e8198e534de571f7154809b"
+dependencies = [
+ "crc32fast",
+ "flate2",
+ "indexmap",
+ "memchr",
+ "typed-path",
+ "zopfli",
+]
+
+[[package]]
+name = "zlib-rs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513"
+
 [[package]]
 name = "zmij"
 version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zopfli"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
+dependencies = [
+ "bumpalo",
+ "crc32fast",
+ "log",
+ "simd-adler32",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 6e38da0..87345c9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,6 +16,8 @@ homepage = "https://github.com/hypervideo/browser-simulator"
 repository = "https://github.com/hypervideo/browser-simulator"
 
 [workspace.dependencies]
+aws-config = { version = "1", default-features = false, features = ["behavior-version-latest", "rt-tokio", "rustls"] }
+aws-sdk-devicefarm = { version = "1", default-features = false, features = ["behavior-version-latest", "rt-tokio", "rustls"] }
 better-panic = "0.3.0"
 chromiumoxide = { version = "0.9.1", features = ["bytes"], default-features = false }
 chrono = { version = "0.4.44", features = ["serde"] }
@@ -41,6 +43,7 @@ signal-hook = "0.4.4"
 strip-ansi-escapes = "0.2.1"
 strum = { version = "0.28.0", features = ["derive"] }
 temp-dir = "0.2.0"
+thirtyfour = "0.36"
 tokio = { version = "1.52.2", default-features = false, features = ["macros", "rt-multi-thread", "sync", "signal"] }
 tokio-util = "0.7.18"
 tracing = "0.1.44"
diff --git a/browser/Cargo.toml b/browser/Cargo.toml
index 3fa0f8b..453fff4 100644
--- a/browser/Cargo.toml
+++ b/browser/Cargo.toml
@@ -6,6 +6,8 @@ edition.workspace = true
 repository.workspace = true
 
 [dependencies]
+aws-config.workspace = true
+aws-sdk-devicefarm.workspace = true
 chromiumoxide.workspace = true
 chrono.workspace = true
 derive_more.workspace = true
@@ -15,6 +17,7 @@ reqwest.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 strum.workspace = true
+thirtyfour.workspace = true
 tokio.workspace = true
 tokio-util.workspace = true
 tracing.workspace = true

From 4b65ea5d1f2b4ea27ef31e8cb3ddf43ec4f30cfe Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:09:54 +0200
Subject: [PATCH 03/42] test(browser): pin local command symbols before
 frontend extraction

---
 browser/src/participant/local/commands.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/browser/src/participant/local/commands.rs b/browser/src/participant/local/commands.rs
index 2fb9bfa..bbb63bf 100644
--- a/browser/src/participant/local/commands.rs
+++ b/browser/src/participant/local/commands.rs
@@ -133,3 +133,13 @@ create_eval_setter!(
     set_force_webrtc,
     "function f(value) { return hyper.settings.sessionDebug.actions.setForceWebrtc(value); }"
 );
+
+#[cfg(test)]
+mod tests {
+    #[tokio::test]
+    async fn module_exports_getters_and_setters() {
+        // Compile-time pin: these symbols must continue to exist after the refactor.
+        let _ = super::get_noise_suppression;
+        let _ = super::set_noise_suppression::<bool>;
+    }
+}

From 5f1dfb71374fb35f78d288fe3d8fa982d001a818 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:10:39 +0200
Subject: [PATCH 04/42] refactor(browser): add driver-agnostic BrowserDriver
 trait + FrontendContext

---
 browser/src/participant/frontend/driver.rs | 80 ++++++++++++++++++++++
 browser/src/participant/frontend/mod.rs    | 11 +++
 browser/src/participant/mod.rs             |  1 +
 3 files changed, 92 insertions(+)
 create mode 100644 browser/src/participant/frontend/driver.rs
 create mode 100644 browser/src/participant/frontend/mod.rs

diff --git a/browser/src/participant/frontend/driver.rs b/browser/src/participant/frontend/driver.rs
new file mode 100644
index 0000000..836989a
--- /dev/null
+++ b/browser/src/participant/frontend/driver.rs
@@ -0,0 +1,80 @@
+use super::super::shared::{
+    messages::{
+        ParticipantLogMessage,
+        ParticipantMessage,
+    },
+    ParticipantLaunchSpec,
+    ParticipantState,
+};
+use eyre::Result;
+use futures::future::BoxFuture;
+use std::time::Duration;
+use tokio::sync::mpsc::UnboundedSender;
+
+/// Driver-agnostic browser operations used by the Hyper frontend automation.
+///
+/// The `eval` contract is uniform across drivers: `js_body` is a JavaScript
+/// statement list; the optional `arg` is available as `arguments[0]`; use
+/// `return` to produce a value. Implementations adapt this to their engine
+/// (chromiumoxide wraps it as `function() { <js_body> }` invoked with `arg`;
+/// WebDriver passes `js_body`/`arg` straight to `execute`).
+pub(in crate::participant) trait BrowserDriver: Send + Sync {
+    fn goto(&self, url: &str) -> BoxFuture<'_, Result<()>>;
+    /// True if at least one element matches `selector` right now.
+    fn exists(&self, selector: &str) -> BoxFuture<'_, Result<bool>>;
+    /// Poll until `selector` exists or `timeout` elapses.
+    fn wait_for(&self, selector: &str, timeout: Duration) -> BoxFuture<'_, Result<()>>;
+    fn click(&self, selector: &str) -> BoxFuture<'_, Result<()>>;
+    /// Focus the element, clear its value, then type `text`.
+    fn fill(&self, selector: &str, text: &str) -> BoxFuture<'_, Result<()>>;
+    /// Read an attribute of the first element matching `selector`.
+    /// `Ok(None)` if the element exists but the attribute is absent.
+    fn attribute(&self, selector: &str, name: &str) -> BoxFuture<'_, Result<Option<String>>>;
+    fn eval(&self, js_body: &str, arg: Option<serde_json::Value>) -> BoxFuture<'_, Result<serde_json::Value>>;
+    /// Set a cookie for `domain`. Drivers that require being on-origin first
+    /// (WebDriver) must navigate to the origin before setting it.
+    fn set_cookie(&self, domain: &str, name: &str, value: &str) -> BoxFuture<'_, Result<()>>;
+}
+
+/// Context shared by every frontend automation, parameterised over the driver.
+pub(in crate::participant) struct FrontendContext {
+    pub(in crate::participant) launch_spec: ParticipantLaunchSpec,
+    pub(in crate::participant) driver: Box<dyn BrowserDriver>,
+    pub(in crate::participant) sender: UnboundedSender<ParticipantLogMessage>,
+}
+
+impl std::fmt::Debug for FrontendContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FrontendContext")
+            .field("launch_spec", &self.launch_spec)
+            .finish_non_exhaustive()
+    }
+}
+
+impl FrontendContext {
+    pub(in crate::participant) fn participant_name(&self) -> &str {
+        &self.launch_spec.username
+    }
+
+    pub(in crate::participant) fn send_log_message(&self, level: &str, message: impl ToString) {
+        if let Err(err) = self
+            .sender
+            .send(ParticipantLogMessage::new(level, self.participant_name(), message))
+        {
+            trace!(participant = %self.participant_name(), "Failed to send log message: {err}");
+        }
+    }
+}
+
+/// The DOM automation contract for a concrete Hyper frontend (HyperCore/HyperLite).
+pub(in crate::participant) trait FrontendAutomation: Send {
+    fn join(&mut self) -> BoxFuture<'_, Result<()>>;
+    fn leave(&mut self) -> BoxFuture<'_, Result<()>>;
+    fn handle_command(&mut self, message: ParticipantMessage) -> BoxFuture<'_, Result<()>>;
+    fn refresh_state(&mut self) -> BoxFuture<'_, Result<ParticipantState>>;
+}
+
+/// Decode the legacy `data-test-state="true"|"false"` attribute.
+pub(in crate::participant) fn decode_test_state(value: Option<String>) -> Option<bool> {
+    value.map(|value| value == "true")
+}
diff --git a/browser/src/participant/frontend/mod.rs b/browser/src/participant/frontend/mod.rs
new file mode 100644
index 0000000..4cc389e
--- /dev/null
+++ b/browser/src/participant/frontend/mod.rs
@@ -0,0 +1,11 @@
+//! Driver-agnostic Hyper frontend automation, shared by the Local (chromiumoxide)
+//! and Device Farm (WebDriver) backends.
+
+mod driver;
+
+pub(in crate::participant) use driver::{
+    decode_test_state,
+    BrowserDriver,
+    FrontendAutomation,
+    FrontendContext,
+};
diff --git a/browser/src/participant/mod.rs b/browser/src/participant/mod.rs
index 7776c31..4a77863 100644
--- a/browser/src/participant/mod.rs
+++ b/browser/src/participant/mod.rs
@@ -47,6 +47,7 @@ use tokio_util::sync::{
 };
 
 mod cloudflare;
+mod frontend;
 mod local;
 mod remote_stub;
 pub mod shared;

From 45e6b2316db7f92130f257a48be21fe38b6244ae Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:11:13 +0200
Subject: [PATCH 05/42] refactor(browser): move selectors + retarget commands
 to BrowserDriver [wip]

---
 browser/src/participant/frontend/commands.rs  |  83 ++++++++++
 .../{local => frontend}/selectors.rs          |   0
 browser/src/participant/local/commands.rs     | 145 ------------------
 3 files changed, 83 insertions(+), 145 deletions(-)
 create mode 100644 browser/src/participant/frontend/commands.rs
 rename browser/src/participant/{local => frontend}/selectors.rs (100%)
 delete mode 100644 browser/src/participant/local/commands.rs

diff --git a/browser/src/participant/frontend/commands.rs b/browser/src/participant/frontend/commands.rs
new file mode 100644
index 0000000..31f1fa8
--- /dev/null
+++ b/browser/src/participant/frontend/commands.rs
@@ -0,0 +1,83 @@
+use super::driver::BrowserDriver;
+use client_simulator_config::{
+    NoiseSuppression,
+    WebcamResolution,
+};
+use eyre::{
+    Context as _,
+    Result,
+};
+
+// Getters return a value via `return <expr>;`. Setters mutate and ignore the result.
+const NOISE_SUPPRESSION_GET: &str = "return hyper.settings.media.noiseSuppression;";
+const NOISE_SUPPRESSION_SET: &str = "hyper.settings.media.actions.setNoiseSuppression(arguments[0]);";
+const AUTO_GAIN_GET: &str = "return hyper.settings.media.autoGainControl;";
+const AUTO_GAIN_SET: &str = "hyper.settings.media.actions.setAutoGainControl(arguments[0]);";
+const BACKGROUND_BLUR_GET: &str = "return hyper.settings.media.backgroundBlur;";
+const BACKGROUND_BLUR_SET: &str = "hyper.settings.media.actions.setBackgroundBlur(arguments[0]);";
+const CAMERA_RES_GET: &str = "return hyper.settings.videoCodec.videoResolutionForWebcamEncoder.name;";
+const CAMERA_RES_SET: &str = "hyper.settings.videoCodec.actions.setVideoResolutionForWebcamEncoder(arguments[0]);";
+const FORCE_WEBRTC_GET: &str = "return hyper.settings.sessionDebug.forceWebrtc;";
+const FORCE_WEBRTC_SET: &str = "hyper.settings.sessionDebug.actions.setForceWebrtc(arguments[0]);";
+
+async fn get_string(driver: &dyn BrowserDriver, js: &str) -> Result<String> {
+    let value = driver.eval(js, None).await?;
+    serde_json::from_value(value).context("failed to read string from eval result")
+}
+
+async fn get_bool(driver: &dyn BrowserDriver, js: &str) -> Result<bool> {
+    let value = driver.eval(js, None).await?;
+    serde_json::from_value(value).context("failed to read bool from eval result")
+}
+
+async fn set_value<S: serde::Serialize>(driver: &dyn BrowserDriver, js: &str, value: S) -> Result<()> {
+    let arg = serde_json::to_value(value).context("failed to serialize eval argument")?;
+    driver.eval(js, Some(arg)).await?;
+    Ok(())
+}
+
+pub(super) async fn get_noise_suppression(driver: &dyn BrowserDriver) -> Result<NoiseSuppression> {
+    get_string(driver, NOISE_SUPPRESSION_GET)
+        .await?
+        .parse::<NoiseSuppression>()
+        .context("failed to parse NoiseSuppression from string")
+}
+
+pub(super) async fn set_noise_suppression(driver: &dyn BrowserDriver, value: NoiseSuppression) -> Result<()> {
+    set_value(driver, NOISE_SUPPRESSION_SET, value.to_string()).await
+}
+
+pub(super) async fn get_auto_gain_control(driver: &dyn BrowserDriver) -> Result<bool> {
+    get_bool(driver, AUTO_GAIN_GET).await
+}
+
+pub(super) async fn set_auto_gain_control(driver: &dyn BrowserDriver, value: bool) -> Result<()> {
+    set_value(driver, AUTO_GAIN_SET, value).await
+}
+
+pub(super) async fn get_background_blur(driver: &dyn BrowserDriver) -> Result<bool> {
+    get_bool(driver, BACKGROUND_BLUR_GET).await
+}
+
+pub(super) async fn set_background_blur(driver: &dyn BrowserDriver, value: bool) -> Result<()> {
+    set_value(driver, BACKGROUND_BLUR_SET, value).await
+}
+
+pub(super) async fn get_outgoing_camera_resolution(driver: &dyn BrowserDriver) -> Result<WebcamResolution> {
+    get_string(driver, CAMERA_RES_GET)
+        .await?
+        .parse::<WebcamResolution>()
+        .context("failed to parse WebcamResolution from string")
+}
+
+pub(super) async fn set_outgoing_camera_resolution(driver: &dyn BrowserDriver, value: &WebcamResolution) -> Result<()> {
+    set_value(driver, CAMERA_RES_SET, value.to_string()).await
+}
+
+pub(super) async fn get_force_webrtc(driver: &dyn BrowserDriver) -> Result<bool> {
+    get_bool(driver, FORCE_WEBRTC_GET).await
+}
+
+pub(super) async fn set_force_webrtc(driver: &dyn BrowserDriver, value: bool) -> Result<()> {
+    set_value(driver, FORCE_WEBRTC_SET, value).await
+}
diff --git a/browser/src/participant/local/selectors.rs b/browser/src/participant/frontend/selectors.rs
similarity index 100%
rename from browser/src/participant/local/selectors.rs
rename to browser/src/participant/frontend/selectors.rs
diff --git a/browser/src/participant/local/commands.rs b/browser/src/participant/local/commands.rs
deleted file mode 100644
index bbb63bf..0000000
--- a/browser/src/participant/local/commands.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-use chromiumoxide::{
-    cdp::js_protocol::runtime::{
-        CallArgument,
-        CallFunctionOnParams,
-    },
-    js::Evaluation,
-    Page,
-};
-use client_simulator_config::{
-    NoiseSuppression,
-    WebcamResolution,
-};
-use eyre::{
-    Context as _,
-    Result,
-};
-
-macro_rules! create_eval_getter {
-    ($fn_name:ident, $js_function:expr, $result_type:ty, $convert_into:ty) => {
-        pub async fn $fn_name(page: &Page) -> Result<$convert_into> {
-            create_eval_getter!($fn_name, $js_function, $result_type);
-            let value = $fn_name(page).await?;
-            value.parse::<$convert_into>().context(format!(
-                "failed to parse {} from string",
-                stringify!($result_type)
-            ))
-        }
-    };
-
-    ($fn_name:ident, $js_function:expr, $result_type:ty) => {
-        pub async fn $fn_name(page: &Page) -> Result<$result_type> {
-            let function = CallFunctionOnParams::builder()
-                .function_declaration($js_function)
-                .build()
-                .map_err(|e| eyre::eyre!("failed to build {} command: {e}", stringify!($fn_name)))?;
-
-            let evaluation = Evaluation::Function(function);
-
-            page.evaluate(evaluation)
-                .await
-                .context(format!("failed to evaluate {}", stringify!($fn_name)))
-                .and_then(|e| {
-                    e.into_value::<$result_type>().context(format!(
-                        "failed to convert evaluation result to {}",
-                        stringify!($result_type)
-                    ))
-                })
-        }
-    };
-}
-
-macro_rules! create_eval_setter {
-    ($fn_name:ident, $js_function:expr) => {
-        pub async fn $fn_name<S>(page: &Page, value: S) -> Result<()>
-        where
-            S: serde::Serialize,
-        {
-            let value = serde_json::to_value(value)
-                .context(format!("failed to serialize value for {}", stringify!($fn_name)))?;
-            let argument = CallArgument::builder().value(value).build();
-            let function = CallFunctionOnParams::builder()
-                .function_declaration($js_function)
-                .arguments(vec![argument])
-                .build()
-                .map_err(|e| eyre::eyre!("failed to build {} command: {e}", stringify!($fn_name)))?;
-
-            debug!("evaluating {function:?}");
-
-            let evaluation = Evaluation::Function(function);
-
-            page.evaluate(evaluation)
-                .await
-                .context(format!("failed to evaluate {}", stringify!($fn_name)))?;
-
-            Ok(())
-        }
-    };
-}
-
-create_eval_getter!(
-    get_noise_suppression,
-    "function f() { return hyper.settings.media.noiseSuppression; }",
-    String,
-    NoiseSuppression
-);
-
-create_eval_setter!(
-    set_noise_suppression,
-    "function f(noiseSuppression) { hyper.settings.media.actions.setNoiseSuppression(noiseSuppression); }"
-);
-
-create_eval_getter!(
-    get_auto_gain_control,
-    "function f() { return hyper.settings.media.autoGainControl; }",
-    bool
-);
-
-create_eval_setter!(
-    set_auto_gain_control,
-    "function f(value) { hyper.settings.media.actions.setAutoGainControl(value); }"
-);
-
-create_eval_getter!(
-    get_background_blur,
-    "function f() { return hyper.settings.media.backgroundBlur; }",
-    bool
-);
-
-create_eval_setter!(
-    set_background_blur,
-    "function f(value) { return hyper.settings.media.actions.setBackgroundBlur(value); }"
-);
-
-create_eval_getter!(
-    get_outgoing_camera_resolution,
-    "function f() { return hyper.settings.videoCodec.videoResolutionForWebcamEncoder.name; }",
-    String,
-    WebcamResolution
-);
-
-create_eval_setter!(
-    set_outgoing_camera_resolution,
-    "function f(value) { return hyper.settings.videoCodec.actions.setVideoResolutionForWebcamEncoder(value); }"
-);
-
-create_eval_getter!(
-    get_force_webrtc,
-    "function f() { return hyper.settings.sessionDebug.forceWebrtc; }",
-    bool
-);
-
-create_eval_setter!(
-    set_force_webrtc,
-    "function f(value) { return hyper.settings.sessionDebug.actions.setForceWebrtc(value); }"
-);
-
-#[cfg(test)]
-mod tests {
-    #[tokio::test]
-    async fn module_exports_getters_and_setters() {
-        // Compile-time pin: these symbols must continue to exist after the refactor.
-        let _ = super::get_noise_suppression;
-        let _ = super::set_noise_suppression::<bool>;
-    }
-}

From 12648ec30fa8b463aa59c8dd5c3a2ae14c1bfa7e Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:13:27 +0200
Subject: [PATCH 06/42] refactor(browser): move HyperCore/HyperLite automation
 behind BrowserDriver [wip]

---
 browser/src/participant/frontend/builder.rs   |  62 +++++++
 .../participant/{local => frontend}/core.rs   | 157 ++++++++----------
 .../participant/{local => frontend}/lite.rs   | 151 ++++++++---------
 browser/src/participant/frontend/mod.rs       |   9 +
 browser/src/participant/local/frontend.rs     |  64 -------
 5 files changed, 209 insertions(+), 234 deletions(-)
 create mode 100644 browser/src/participant/frontend/builder.rs
 rename browser/src/participant/{local => frontend}/core.rs (68%)
 rename browser/src/participant/{local => frontend}/lite.rs (82%)
 delete mode 100644 browser/src/participant/local/frontend.rs

diff --git a/browser/src/participant/frontend/builder.rs b/browser/src/participant/frontend/builder.rs
new file mode 100644
index 0000000..2f05368
--- /dev/null
+++ b/browser/src/participant/frontend/builder.rs
@@ -0,0 +1,62 @@
+use super::{
+    core::ParticipantInner,
+    driver::{
+        FrontendAutomation,
+        FrontendContext,
+    },
+    lite::ParticipantInnerLite,
+};
+use crate::{
+    auth::{
+        BorrowedCookie,
+        HyperSessionCookieManger,
+    },
+    participant::shared::ResolvedFrontendKind,
+};
+use eyre::Result;
+
+/// How to authenticate the frontend. HyperLite needs no cookie.
+pub(in crate::participant) enum FrontendAuth {
+    HyperCore {
+        cookie: Option<BorrowedCookie>,
+        cookie_manager: HyperSessionCookieManger,
+    },
+    HyperLite,
+}
+
+impl FrontendAuth {
+    pub(in crate::participant) fn for_kind(
+        kind: ResolvedFrontendKind,
+        cookie: Option<BorrowedCookie>,
+        cookie_manager: HyperSessionCookieManger,
+    ) -> Self {
+        match kind {
+            ResolvedFrontendKind::HyperCore => Self::HyperCore { cookie, cookie_manager },
+            ResolvedFrontendKind::HyperLite => Self::HyperLite,
+        }
+    }
+}
+
+/// Builds the concrete `FrontendAutomation` for a context + auth, shared by all backends.
+pub(in crate::participant) struct FrontendKindBuilder;
+
+impl FrontendKindBuilder {
+    pub(in crate::participant) async fn build(
+        context: FrontendContext,
+        auth: FrontendAuth,
+    ) -> Result<Box<dyn FrontendAutomation>> {
+        match auth {
+            FrontendAuth::HyperCore { cookie, cookie_manager } => {
+                let cookie = if let Some(cookie) = cookie {
+                    cookie
+                } else {
+                    cookie_manager
+                        .fetch_new_cookie(context.launch_spec.base_url(), context.participant_name())
+                        .await?
+                };
+                Ok(Box::new(ParticipantInner::new(context, cookie)))
+            }
+            FrontendAuth::HyperLite => Ok(Box::new(ParticipantInnerLite::new(context))),
+        }
+    }
+}
diff --git a/browser/src/participant/local/core.rs b/browser/src/participant/frontend/core.rs
similarity index 68%
rename from browser/src/participant/local/core.rs
rename to browser/src/participant/frontend/core.rs
index 6c443fd..b4acff4 100644
--- a/browser/src/participant/local/core.rs
+++ b/browser/src/participant/frontend/core.rs
@@ -17,18 +17,14 @@ use super::{
         set_noise_suppression,
         set_outgoing_camera_resolution,
     },
-    frontend::{
-        element_state,
+    driver::{
+        decode_test_state,
         FrontendAutomation,
         FrontendContext,
     },
+    selectors::classic,
 };
-use crate::{
-    auth::BorrowedCookie,
-    participant::local::selectors::classic,
-    util::wait_for_element,
-};
-use chromiumoxide::Element;
+use crate::auth::BorrowedCookie;
 use client_simulator_config::{
     NoiseSuppression,
     TransportMode,
@@ -57,12 +53,17 @@ impl ParticipantInner {
     }
 
     async fn set_cookie(&self) -> Result<()> {
-        let domain = self.context.launch_spec.session_url.host_str().unwrap_or("localhost");
-        let cookie = self.auth.as_browser_cookie_for(domain)?;
-
+        let domain = self
+            .context
+            .launch_spec
+            .session_url
+            .host_str()
+            .unwrap_or("localhost")
+            .to_owned();
+        let value = self.auth.raw_value().to_owned();
         self.context
-            .page
-            .set_cookies(vec![cookie])
+            .driver
+            .set_cookie(&domain, "hyper_session", &value)
             .await
             .context("failed to set cookie")?;
 
@@ -81,26 +82,22 @@ impl ParticipantInner {
         self.set_cookie().await?;
 
         self.context
-            .page
-            .goto(self.context.launch_spec.session_url.to_string())
+            .driver
+            .goto(self.context.launch_spec.session_url.as_str())
             .await
             .context("failed to wait for navigation response")?;
 
         debug!(participant = %self.participant_name(), "Navigated to page");
         self.context.send_log_message("debug", "Navigated to page");
 
-        let input = wait_for_element(&self.context.page, classic::NAME_INPUT, Duration::from_secs(30))
+        self.context
+            .driver
+            .wait_for(classic::NAME_INPUT, Duration::from_secs(30))
             .await
             .context("failed to find input name field")?;
-        input
-            .focus()
-            .await
-            .context("failed to focus on the name input")?
-            .call_js_fn("function() { this.value = ''; }", true)
-            .await
-            .context("failed to empty current name")?;
-        input
-            .type_str(&self.context.launch_spec.username)
+        self.context
+            .driver
+            .fill(classic::NAME_INPUT, &self.context.launch_spec.username)
             .await
             .context("failed to insert name")?;
 
@@ -113,7 +110,10 @@ impl ParticipantInner {
             ),
         );
 
-        wait_for_element(&self.context.page, classic::JOIN_BUTTON, Duration::from_secs(30)).await?;
+        self.context
+            .driver
+            .wait_for(classic::JOIN_BUTTON, Duration::from_secs(30))
+            .await?;
 
         if let Err(err) = self.apply_all_settings(true).await {
             error!(
@@ -123,16 +123,17 @@ impl ParticipantInner {
         }
 
         self.context
-            .find_element(classic::JOIN_BUTTON)
-            .await?
-            .click()
+            .driver
+            .click(classic::JOIN_BUTTON)
             .await
             .context("failed to click join button")?;
 
         debug!(participant = %self.participant_name(), "Clicked on the join button");
         self.context.send_log_message("debug", "Clicked on the join button");
 
-        wait_for_element(&self.context.page, classic::LEAVE_BUTTON, Duration::from_secs(30))
+        self.context
+            .driver
+            .wait_for(classic::LEAVE_BUTTON, Duration::from_secs(30))
             .await
             .context("We haven't joined the space, cannot find the leave button")?;
 
@@ -144,20 +145,21 @@ impl ParticipantInner {
 
     async fn apply_all_settings(&self, in_lobby: bool) -> Result<()> {
         let settings = &self.context.launch_spec.settings;
+        let driver = self.context.driver.as_ref();
 
-        set_auto_gain_control(&self.context.page, settings.auto_gain_control)
+        set_auto_gain_control(driver, settings.auto_gain_control)
             .await
             .context("failed to set auto gain control")?;
-        set_noise_suppression(&self.context.page, settings.noise_suppression)
+        set_noise_suppression(driver, settings.noise_suppression)
             .await
             .context("failed to set noise suppression")?;
-        set_background_blur(&self.context.page, settings.blur)
+        set_background_blur(driver, settings.blur)
             .await
             .context("failed to set background blur")?;
-        set_outgoing_camera_resolution(&self.context.page, &settings.resolution)
+        set_outgoing_camera_resolution(driver, &settings.resolution)
             .await
             .context("failed to set outgoing camera resolution")?;
-        set_force_webrtc(&self.context.page, settings.transport == TransportMode::WebRTC)
+        set_force_webrtc(driver, settings.transport == TransportMode::WebRTC)
             .await
             .context("failed to set transport mode")?;
 
@@ -177,9 +179,9 @@ impl ParticipantInner {
     }
 
     async fn leave_session(&mut self) -> Result<()> {
-        self.leave_button()
-            .await?
-            .click()
+        self.context
+            .driver
+            .click(classic::LEAVE_BUTTON)
             .await
             .context("Could not click on the leave space button")?;
 
@@ -190,9 +192,9 @@ impl ParticipantInner {
     }
 
     async fn toggle_audio_inner(&self) -> Result<()> {
-        self.mute_button()
-            .await?
-            .click()
+        self.context
+            .driver
+            .click(classic::MUTE_BUTTON)
             .await
             .context("Could not click on the toggle audio button")?;
 
@@ -203,9 +205,9 @@ impl ParticipantInner {
     }
 
     async fn toggle_video_inner(&self) -> Result<()> {
-        self.camera_button()
-            .await?
-            .click()
+        self.context
+            .driver
+            .click(classic::VIDEO_BUTTON)
             .await
             .context("Could not click on the toggle camera button")?;
 
@@ -216,9 +218,9 @@ impl ParticipantInner {
     }
 
     async fn toggle_screen_share_inner(&self) -> Result<()> {
-        self.screen_share_button()
-            .await?
-            .click()
+        self.context
+            .driver
+            .click(classic::SCREEN_SHARE_BUTTON)
             .await
             .context("Could not click on the toggle screen share button")
             .map(|_| ())
@@ -227,7 +229,7 @@ impl ParticipantInner {
     async fn set_webcam_resolutions_inner(&self, value: WebcamResolution) -> Result<()> {
         debug!(participant = %self.participant_name(), "Changing to {value} resolution");
 
-        set_outgoing_camera_resolution(&self.context.page, &value)
+        set_outgoing_camera_resolution(self.context.driver.as_ref(), &value)
             .await
             .context("Failed to set outgoing camera resolution")?;
 
@@ -242,7 +244,7 @@ impl ParticipantInner {
         self.context
             .send_log_message("info", format!("Changing noise suppression to {value}"));
 
-        set_noise_suppression(&self.context.page, value)
+        set_noise_suppression(self.context.driver.as_ref(), value)
             .await
             .context("Failed to set noise suppression level")?;
 
@@ -250,39 +252,26 @@ impl ParticipantInner {
     }
 
     async fn toggle_auto_gain_control_inner(&self) -> Result<()> {
-        let auto_gain_control = get_auto_gain_control(&self.context.page).await?;
-        set_auto_gain_control(&self.context.page, !auto_gain_control)
+        let driver = self.context.driver.as_ref();
+        let auto_gain_control = get_auto_gain_control(driver).await?;
+        set_auto_gain_control(driver, !auto_gain_control)
             .await
             .context("Failed to set auto gain control")?;
         Ok(())
     }
 
     async fn toggle_background_blur_inner(&self) -> Result<()> {
-        let background_blur = get_background_blur(&self.context.page).await?;
-        set_background_blur(&self.context.page, !background_blur)
+        let driver = self.context.driver.as_ref();
+        let background_blur = get_background_blur(driver).await?;
+        set_background_blur(driver, !background_blur)
             .await
             .context("Failed to set background blur")?;
         Ok(())
     }
 
-    async fn leave_button(&self) -> Result<Element> {
-        self.context.find_element(classic::LEAVE_BUTTON).await
-    }
-
-    async fn mute_button(&self) -> Result<Element> {
-        self.context.find_element(classic::MUTE_BUTTON).await
-    }
-
-    async fn camera_button(&self) -> Result<Element> {
-        self.context.find_element(classic::VIDEO_BUTTON).await
-    }
-
-    async fn screen_share_button(&self) -> Result<Element> {
-        self.context.find_element(classic::SCREEN_SHARE_BUTTON).await
-    }
-
     async fn refresh_state_inner(&self) -> Result<ParticipantState> {
-        let joined = self.leave_button().await.is_ok();
+        let driver = self.context.driver.as_ref();
+        let joined = driver.exists(classic::LEAVE_BUTTON).await.unwrap_or(false);
         let mut state = ParticipantState {
             username: self.context.launch_spec.username.clone(),
             running: true,
@@ -290,43 +279,43 @@ impl ParticipantInner {
             ..Default::default()
         };
 
-        if let Ok(value) = get_noise_suppression(&self.context.page).await {
+        if let Ok(value) = get_noise_suppression(driver).await {
             state.noise_suppression = value;
         }
 
-        if let Ok(value) = get_auto_gain_control(&self.context.page).await {
+        if let Ok(value) = get_auto_gain_control(driver).await {
             state.auto_gain_control = value;
         }
 
-        if let Ok(mute_button) = self.mute_button().await {
-            if let Some(value) = element_state(&mute_button).await {
-                state.muted = !value;
+        if let Ok(value) = driver.attribute(classic::MUTE_BUTTON, "data-test-state").await {
+            if let Some(active) = decode_test_state(value) {
+                state.muted = !active;
             }
         }
 
-        if let Ok(camera_button) = self.camera_button().await {
-            if let Some(element_state) = element_state(&camera_button).await {
-                state.video_activated = element_state;
+        if let Ok(value) = driver.attribute(classic::VIDEO_BUTTON, "data-test-state").await {
+            if let Some(active) = decode_test_state(value) {
+                state.video_activated = active;
             }
         }
 
-        if let Ok(screen_share_button) = self.screen_share_button().await {
-            if let Some(element_state) = element_state(&screen_share_button).await {
-                state.screenshare_activated = element_state;
+        if let Ok(value) = driver.attribute(classic::SCREEN_SHARE_BUTTON, "data-test-state").await {
+            if let Some(active) = decode_test_state(value) {
+                state.screenshare_activated = active;
             }
         }
 
-        if let Ok(value) = get_force_webrtc(&self.context.page).await {
+        if let Ok(value) = get_force_webrtc(driver).await {
             if value {
                 state.transport_mode = TransportMode::WebRTC;
             }
         }
 
-        if let Ok(value) = get_outgoing_camera_resolution(&self.context.page).await {
+        if let Ok(value) = get_outgoing_camera_resolution(driver).await {
             state.webcam_resolution = value;
         }
 
-        if let Ok(blur) = get_background_blur(&self.context.page).await {
+        if let Ok(blur) = get_background_blur(driver).await {
             state.background_blur = blur;
         }
 
diff --git a/browser/src/participant/local/lite.rs b/browser/src/participant/frontend/lite.rs
similarity index 82%
rename from browser/src/participant/local/lite.rs
rename to browser/src/participant/frontend/lite.rs
index e08ec41..d0a569c 100644
--- a/browser/src/participant/local/lite.rs
+++ b/browser/src/participant/frontend/lite.rs
@@ -5,17 +5,14 @@ use super::{
         messages::ParticipantMessage,
         ParticipantState,
     },
-    frontend::{
-        element_state,
+    driver::{
+        decode_test_state,
+        BrowserDriver,
         FrontendAutomation,
         FrontendContext,
     },
+    selectors::lite,
 };
-use crate::{
-    participant::local::selectors::lite,
-    util::wait_for_element,
-};
-use chromiumoxide::Element;
 use client_simulator_config::{
     NoiseSuppression,
     TransportMode,
@@ -57,8 +54,8 @@ impl ParticipantInnerLite {
 
     async fn join_session(&mut self) -> Result<()> {
         self.context
-            .page
-            .goto(self.context.launch_spec.session_url.to_string())
+            .driver
+            .goto(self.context.launch_spec.session_url.as_str())
             .await
             .context("failed to wait for navigation response")?;
 
@@ -75,9 +72,8 @@ impl ParticipantInnerLite {
                 self.prepare_lobby().await?;
 
                 self.context
-                    .find_element(lite::JOIN_BUTTON)
-                    .await?
-                    .click()
+                    .driver
+                    .click(lite::JOIN_BUTTON)
                     .await
                     .context("failed to click join button")?;
 
@@ -86,7 +82,9 @@ impl ParticipantInnerLite {
             }
         }
 
-        wait_for_element(&self.context.page, lite::LEAVE_BUTTON, Duration::from_secs(30))
+        self.context
+            .driver
+            .wait_for(lite::LEAVE_BUTTON, Duration::from_secs(30))
             .await
             .context("We haven't joined the space, cannot find the leave button")?;
 
@@ -109,11 +107,11 @@ impl ParticipantInnerLite {
         let start = Instant::now();
 
         loop {
-            if self.context.page.find_element(lite::LEAVE_BUTTON).await.is_ok() {
+            if self.context.driver.exists(lite::LEAVE_BUTTON).await.unwrap_or(false) {
                 return Ok(LiteEntryPoint::InCall);
             }
 
-            if self.context.page.find_element(lite::JOIN_BUTTON).await.is_ok() {
+            if self.context.driver.exists(lite::JOIN_BUTTON).await.unwrap_or(false) {
                 return Ok(LiteEntryPoint::Lobby);
             }
 
@@ -130,16 +128,10 @@ impl ParticipantInnerLite {
     }
 
     async fn prepare_lobby(&self) -> Result<()> {
-        if let Ok(input) = self.context.find_element(lite::NAME_INPUT).await {
-            input
-                .focus()
-                .await
-                .context("failed to focus on the Lite display name input")?
-                .call_js_fn("function() { this.value = ''; }", true)
-                .await
-                .context("failed to empty current Lite display name")?;
-            input
-                .type_str(&self.context.launch_spec.username)
+        if self.context.driver.exists(lite::NAME_INPUT).await.unwrap_or(false) {
+            self.context
+                .driver
+                .fill(lite::NAME_INPUT, &self.context.launch_spec.username)
                 .await
                 .context("failed to insert Lite display name")?;
 
@@ -182,16 +174,22 @@ impl ParticipantInnerLite {
     }
 
     async fn leave_session(&mut self) -> Result<()> {
-        self.leave_button()
-            .await?
-            .click()
+        self.context
+            .driver
+            .click(lite::LEAVE_BUTTON)
             .await
             .context("Could not click on the leave space button")?;
 
-        match wait_for_element(&self.context.page, lite::LEAVE_CONFIRM_BUTTON, Duration::from_secs(5)).await {
-            Ok(button) => {
-                button
-                    .click()
+        match self
+            .context
+            .driver
+            .wait_for(lite::LEAVE_CONFIRM_BUTTON, Duration::from_secs(5))
+            .await
+        {
+            Ok(()) => {
+                self.context
+                    .driver
+                    .click(lite::LEAVE_CONFIRM_BUTTON)
                     .await
                     .context("Could not confirm leaving the Lite meeting")?;
                 debug!(participant = %self.participant_name(), "Confirmed the Lite leave dialog");
@@ -212,9 +210,9 @@ impl ParticipantInnerLite {
     }
 
     async fn toggle_audio_inner(&self) -> Result<()> {
-        self.mute_button()
-            .await?
-            .click()
+        self.context
+            .driver
+            .click(lite::MUTE_BUTTON)
             .await
             .context("Could not click on the toggle audio button")?;
         info!(participant = %self.participant_name(), "Toggled audio");
@@ -223,9 +221,9 @@ impl ParticipantInnerLite {
     }
 
     async fn toggle_video_inner(&self) -> Result<()> {
-        self.camera_button()
-            .await?
-            .click()
+        self.context
+            .driver
+            .click(lite::VIDEO_BUTTON)
             .await
             .context("Could not click on the toggle camera button")?;
         info!(participant = %self.participant_name(), "Toggled camera");
@@ -234,9 +232,9 @@ impl ParticipantInnerLite {
     }
 
     async fn toggle_screen_share_inner(&self) -> Result<()> {
-        self.screen_share_button()
-            .await?
-            .click()
+        self.context
+            .driver
+            .click(lite::SCREEN_SHARE_BUTTON)
             .await
             .context("Could not click on the toggle screen share button")?;
         info!(participant = %self.participant_name(), "Toggled screen share");
@@ -293,16 +291,17 @@ impl ParticipantInnerLite {
     }
 
     async fn click_if_present(&self, selector: &str, action: &str) -> Result<bool> {
-        let Ok(element) = self.context.page.find_element(selector).await else {
+        if !self.context.driver.exists(selector).await.unwrap_or(false) {
             debug!(
                 participant = %self.participant_name(),
                 "Could not find Lite control for {action}: {selector}"
             );
             return Ok(false);
-        };
+        }
 
-        element
-            .click()
+        self.context
+            .driver
+            .click(selector)
             .await
             .with_context(|| format!("Could not click Lite control for {action}: {selector}"))?;
         debug!(participant = %self.participant_name(), "Clicked Lite control for {action}");
@@ -318,59 +317,39 @@ impl ParticipantInnerLite {
             .send_log_message("debug", format!("{feature} changes not supported in lite frontend"));
     }
 
-    async fn leave_button(&self) -> Result<Element> {
-        self.context.find_element(lite::LEAVE_BUTTON).await
-    }
-
-    async fn mute_button(&self) -> Result<Element> {
-        self.context.find_element(lite::MUTE_BUTTON).await
-    }
-
-    async fn camera_button(&self) -> Result<Element> {
-        self.context.find_element(lite::VIDEO_BUTTON).await
-    }
-
-    async fn screen_share_button(&self) -> Result<Element> {
-        self.context.find_element(lite::SCREEN_SHARE_BUTTON).await
-    }
-
     async fn audio_enabled(&self) -> Result<Option<bool>> {
-        let button = match self.mute_button().await {
-            Ok(button) => button,
-            Err(_) => return Ok(None),
-        };
+        let driver = self.context.driver.as_ref();
 
         Ok(audio_enabled_from_button_state(
-            element_state(&button).await,
-            aria_pressed(&button).await,
-            aria_label(&button).await.as_deref(),
+            decode_test_state(driver.attribute(lite::MUTE_BUTTON, "data-test-state").await?),
+            aria_pressed(driver, lite::MUTE_BUTTON).await,
+            aria_label(driver, lite::MUTE_BUTTON).await.as_deref(),
         ))
     }
 
     async fn video_enabled(&self) -> Result<Option<bool>> {
-        let button = match self.camera_button().await {
-            Ok(button) => button,
-            Err(_) => return Ok(None),
-        };
+        let driver = self.context.driver.as_ref();
 
         Ok(video_enabled_from_button_state(
-            element_state(&button).await,
-            aria_pressed(&button).await,
-            aria_label(&button).await.as_deref(),
+            decode_test_state(driver.attribute(lite::VIDEO_BUTTON, "data-test-state").await?),
+            aria_pressed(driver, lite::VIDEO_BUTTON).await,
+            aria_label(driver, lite::VIDEO_BUTTON).await.as_deref(),
         ))
     }
 
     async fn screen_share_enabled(&self) -> Result<Option<bool>> {
-        let button = match self.screen_share_button().await {
-            Ok(button) => button,
-            Err(_) => return Ok(None),
-        };
+        let driver = self.context.driver.as_ref();
 
-        Ok(element_state(&button).await.or(aria_pressed(&button).await))
+        Ok(decode_test_state(
+            driver
+                .attribute(lite::SCREEN_SHARE_BUTTON, "data-test-state")
+                .await?,
+        )
+        .or(aria_pressed(driver, lite::SCREEN_SHARE_BUTTON).await))
     }
 
     async fn refresh_state_inner(&self) -> Result<ParticipantState> {
-        let joined = self.leave_button().await.is_ok();
+        let joined = self.context.driver.exists(lite::LEAVE_BUTTON).await.unwrap_or(false);
         let mut state = ParticipantState {
             username: self.context.launch_spec.username.clone(),
             running: true,
@@ -400,17 +379,17 @@ impl ParticipantInnerLite {
     }
 }
 
-async fn aria_pressed(element: &Element) -> Option<bool> {
-    element
-        .attribute("aria-pressed")
+async fn aria_pressed(driver: &dyn BrowserDriver, selector: &str) -> Option<bool> {
+    driver
+        .attribute(selector, "aria-pressed")
         .await
         .ok()
         .flatten()
         .and_then(|value| value.parse().ok())
 }
 
-async fn aria_label(element: &Element) -> Option<String> {
-    element.attribute("aria-label").await.ok().flatten()
+async fn aria_label(driver: &dyn BrowserDriver, selector: &str) -> Option<String> {
+    driver.attribute(selector, "aria-label").await.ok().flatten()
 }
 
 fn audio_enabled_from_button_state(
diff --git a/browser/src/participant/frontend/mod.rs b/browser/src/participant/frontend/mod.rs
index 4cc389e..9fc6ab3 100644
--- a/browser/src/participant/frontend/mod.rs
+++ b/browser/src/participant/frontend/mod.rs
@@ -1,8 +1,17 @@
 //! Driver-agnostic Hyper frontend automation, shared by the Local (chromiumoxide)
 //! and Device Farm (WebDriver) backends.
 
+mod builder;
+mod commands;
+mod core;
 mod driver;
+mod lite;
+mod selectors;
 
+pub(in crate::participant) use builder::{
+    FrontendAuth,
+    FrontendKindBuilder,
+};
 pub(in crate::participant) use driver::{
     decode_test_state,
     BrowserDriver,
diff --git a/browser/src/participant/local/frontend.rs b/browser/src/participant/local/frontend.rs
deleted file mode 100644
index ba5becd..0000000
--- a/browser/src/participant/local/frontend.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use super::super::shared::{
-    messages::{
-        ParticipantLogMessage,
-        ParticipantMessage,
-    },
-    ParticipantLaunchSpec,
-    ParticipantState,
-};
-use chromiumoxide::{
-    Element,
-    Page,
-};
-use eyre::{
-    Context as _,
-    Result,
-};
-use futures::future::BoxFuture;
-use tokio::sync::mpsc::UnboundedSender;
-
-/// Local-only context shared by the Chromium session and frontend automation.
-#[derive(Debug)]
-pub(super) struct FrontendContext {
-    pub(super) launch_spec: ParticipantLaunchSpec,
-    pub(super) page: Page,
-    pub(super) sender: UnboundedSender<ParticipantLogMessage>,
-}
-
-impl FrontendContext {
-    pub(super) fn participant_name(&self) -> &str {
-        &self.launch_spec.username
-    }
-
-    pub(super) fn send_log_message(&self, level: &str, message: impl ToString) {
-        if let Err(err) = self
-            .sender
-            .send(ParticipantLogMessage::new(level, self.participant_name(), message))
-        {
-            trace!(participant = %self.participant_name(), "Failed to send log message: {err}");
-        }
-    }
-
-    pub(super) async fn find_element(&self, selector: &str) -> Result<Element> {
-        self.page
-            .find_element(selector)
-            .await
-            .context(format!("Could not find the {selector} element"))
-    }
-}
-
-/// Local DOM automation contract for a concrete Hyper frontend.
-pub(super) trait FrontendAutomation: Send {
-    fn join(&mut self) -> BoxFuture<'_, Result<()>>;
-    fn leave(&mut self) -> BoxFuture<'_, Result<()>>;
-    fn handle_command(&mut self, message: ParticipantMessage) -> BoxFuture<'_, Result<()>>;
-    fn refresh_state(&mut self) -> BoxFuture<'_, Result<ParticipantState>>;
-}
-
-pub(super) async fn element_state(el: &Element) -> Option<bool> {
-    el.attribute("data-test-state")
-        .await
-        .ok()
-        .unwrap_or(None)
-        .map(|value| value == "true")
-}

From 7328970e4c188f785f4896f3d1a7fabcb0b964b3 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:16:40 +0200
Subject: [PATCH 07/42] refactor(browser): drive Local backend through
 ChromiumDriver (no behavior change)

---
 browser/src/lib.rs                            |   1 -
 browser/src/participant/frontend/lite.rs      |   8 +-
 browser/src/participant/frontend/mod.rs       |   1 -
 .../src/participant/local/chromium_driver.rs  | 158 ++++++++++++++++++
 browser/src/participant/local/mod.rs          |   6 +-
 browser/src/participant/local/session.rs      |  63 ++-----
 browser/src/util.rs                           |  24 ---
 7 files changed, 178 insertions(+), 83 deletions(-)
 create mode 100644 browser/src/participant/local/chromium_driver.rs
 delete mode 100644 browser/src/util.rs

diff --git a/browser/src/lib.rs b/browser/src/lib.rs
index 5181d8a..cc1def2 100644
--- a/browser/src/lib.rs
+++ b/browser/src/lib.rs
@@ -3,4 +3,3 @@ extern crate tracing;
 
 pub mod auth;
 pub mod participant;
-pub mod util;
diff --git a/browser/src/participant/frontend/lite.rs b/browser/src/participant/frontend/lite.rs
index d0a569c..fbf44dd 100644
--- a/browser/src/participant/frontend/lite.rs
+++ b/browser/src/participant/frontend/lite.rs
@@ -339,13 +339,9 @@ impl ParticipantInnerLite {
 
     async fn screen_share_enabled(&self) -> Result<Option<bool>> {
         let driver = self.context.driver.as_ref();
+        let data_test_state = driver.attribute(lite::SCREEN_SHARE_BUTTON, "data-test-state").await?;
 
-        Ok(decode_test_state(
-            driver
-                .attribute(lite::SCREEN_SHARE_BUTTON, "data-test-state")
-                .await?,
-        )
-        .or(aria_pressed(driver, lite::SCREEN_SHARE_BUTTON).await))
+        Ok(decode_test_state(data_test_state).or(aria_pressed(driver, lite::SCREEN_SHARE_BUTTON).await))
     }
 
     async fn refresh_state_inner(&self) -> Result<ParticipantState> {
diff --git a/browser/src/participant/frontend/mod.rs b/browser/src/participant/frontend/mod.rs
index 9fc6ab3..daca152 100644
--- a/browser/src/participant/frontend/mod.rs
+++ b/browser/src/participant/frontend/mod.rs
@@ -13,7 +13,6 @@ pub(in crate::participant) use builder::{
     FrontendKindBuilder,
 };
 pub(in crate::participant) use driver::{
-    decode_test_state,
     BrowserDriver,
     FrontendAutomation,
     FrontendContext,
diff --git a/browser/src/participant/local/chromium_driver.rs b/browser/src/participant/local/chromium_driver.rs
new file mode 100644
index 0000000..02f9f2d
--- /dev/null
+++ b/browser/src/participant/local/chromium_driver.rs
@@ -0,0 +1,158 @@
+use crate::participant::frontend::BrowserDriver;
+use chromiumoxide::{
+    cdp::js_protocol::runtime::{
+        CallArgument,
+        CallFunctionOnParams,
+    },
+    js::Evaluation,
+    Page,
+};
+use eyre::{
+    Context as _,
+    Result,
+};
+use futures::{
+    future::BoxFuture,
+    FutureExt as _,
+};
+use std::time::{
+    Duration,
+    Instant,
+};
+
+/// `BrowserDriver` implementation backed by a local chromiumoxide `Page` (CDP).
+pub(crate) struct ChromiumDriver {
+    page: Page,
+}
+
+impl ChromiumDriver {
+    pub(crate) fn new(page: Page) -> Self {
+        Self { page }
+    }
+}
+
+impl BrowserDriver for ChromiumDriver {
+    fn goto(&self, url: &str) -> BoxFuture<'_, Result<()>> {
+        let url = url.to_owned();
+        async move {
+            self.page.goto(url).await.context("failed to navigate")?;
+            Ok(())
+        }
+        .boxed()
+    }
+
+    fn exists(&self, selector: &str) -> BoxFuture<'_, Result<bool>> {
+        let selector = selector.to_owned();
+        async move { Ok(self.page.find_element(selector).await.is_ok()) }.boxed()
+    }
+
+    fn wait_for(&self, selector: &str, timeout: Duration) -> BoxFuture<'_, Result<()>> {
+        let selector = selector.to_owned();
+        async move {
+            let start = Instant::now();
+            loop {
+                if self.page.find_element(&selector).await.is_ok() {
+                    return Ok(());
+                }
+                if start.elapsed() > timeout {
+                    eyre::bail!("timeout waiting for selector {selector}");
+                }
+                tokio::time::sleep(Duration::from_millis(100)).await;
+            }
+        }
+        .boxed()
+    }
+
+    fn click(&self, selector: &str) -> BoxFuture<'_, Result<()>> {
+        let selector = selector.to_owned();
+        async move {
+            self.page
+                .find_element(&selector)
+                .await
+                .with_context(|| format!("Could not find {selector}"))?
+                .click()
+                .await
+                .with_context(|| format!("Could not click {selector}"))?;
+            Ok(())
+        }
+        .boxed()
+    }
+
+    fn fill(&self, selector: &str, text: &str) -> BoxFuture<'_, Result<()>> {
+        let selector = selector.to_owned();
+        let text = text.to_owned();
+        async move {
+            let element = self
+                .page
+                .find_element(&selector)
+                .await
+                .with_context(|| format!("Could not find {selector}"))?;
+            element
+                .focus()
+                .await
+                .context("failed to focus element")?
+                .call_js_fn("function() { this.value = ''; }", true)
+                .await
+                .context("failed to clear element")?;
+            element.type_str(&text).await.context("failed to type into element")?;
+            Ok(())
+        }
+        .boxed()
+    }
+
+    fn attribute(&self, selector: &str, name: &str) -> BoxFuture<'_, Result<Option<String>>> {
+        let selector = selector.to_owned();
+        let name = name.to_owned();
+        async move {
+            match self.page.find_element(&selector).await {
+                Ok(element) => Ok(element.attribute(&name).await.ok().flatten()),
+                Err(_) => Ok(None),
+            }
+        }
+        .boxed()
+    }
+
+    fn eval(&self, js_body: &str, arg: Option<serde_json::Value>) -> BoxFuture<'_, Result<serde_json::Value>> {
+        let declaration = format!("function() {{ {js_body} }}");
+        async move {
+            let mut builder = CallFunctionOnParams::builder().function_declaration(declaration);
+            if let Some(arg) = arg {
+                let argument = CallArgument::builder().value(arg).build();
+                builder = builder.arguments(vec![argument]);
+            }
+            let function = builder
+                .build()
+                .map_err(|e| eyre::eyre!("failed to build eval command: {e}"))?;
+            let result = self
+                .page
+                .evaluate(Evaluation::Function(function))
+                .await
+                .context("failed to evaluate script")?;
+            Ok(result.into_value().unwrap_or(serde_json::Value::Null))
+        }
+        .boxed()
+    }
+
+    fn set_cookie(&self, domain: &str, name: &str, value: &str) -> BoxFuture<'_, Result<()>> {
+        use chromiumoxide::cdp::browser_protocol::network::CookieParam;
+
+        let domain = domain.to_owned();
+        let name = name.to_owned();
+        let value = value.to_owned();
+        async move {
+            let cookie = CookieParam::builder()
+                .name(name)
+                .value(value)
+                .domain(domain)
+                .path("/")
+                .build()
+                .map_err(|e| eyre::eyre!("failed to build cookie: {e}"))?;
+            self.page
+                .set_cookies(vec![cookie])
+                .await
+                .context("failed to set cookie")?;
+            Ok(())
+        }
+        .boxed()
+    }
+}
diff --git a/browser/src/participant/local/mod.rs b/browser/src/participant/local/mod.rs
index f27431b..0bb6ba8 100644
--- a/browser/src/participant/local/mod.rs
+++ b/browser/src/participant/local/mod.rs
@@ -1,6 +1,2 @@
-pub(super) mod commands;
-pub(super) mod core;
-pub(super) mod frontend;
-pub(super) mod lite;
-pub(super) mod selectors;
+mod chromium_driver;
 pub(super) mod session;
diff --git a/browser/src/participant/local/session.rs b/browser/src/participant/local/session.rs
index 6f57143..3a2373f 100644
--- a/browser/src/participant/local/session.rs
+++ b/browser/src/participant/local/session.rs
@@ -1,16 +1,15 @@
+use super::chromium_driver::ChromiumDriver;
 use crate::{
     auth::{
         BorrowedCookie,
         HyperSessionCookieManger,
     },
     participant::{
-        local::{
-            core::ParticipantInner,
-            frontend::{
-                FrontendAutomation,
-                FrontendContext,
-            },
-            lite::ParticipantInnerLite,
+        frontend::{
+            FrontendAuth,
+            FrontendAutomation,
+            FrontendContext,
+            FrontendKindBuilder,
         },
         shared::{
             messages::{
@@ -20,7 +19,6 @@ use crate::{
             DriverTermination,
             ParticipantDriverSession,
             ParticipantLaunchSpec,
-            ResolvedFrontendKind,
         },
     },
 };
@@ -72,7 +70,7 @@ pub(crate) struct LocalChromiumSession {
     launch_spec: ParticipantLaunchSpec,
     browser_config: BrowserConfig,
     sender: UnboundedSender<ParticipantLogMessage>,
-    frontend_builder: Option<LocalFrontendBuilder>,
+    frontend_builder: Option<FrontendAuth>,
     automation: Option<Box<dyn FrontendAutomation>>,
     browser: Option<Browser>,
     page: Option<Page>,
@@ -82,14 +80,6 @@ pub(crate) struct LocalChromiumSession {
     termination_rx: watch::Receiver<Option<DriverTermination>>,
 }
 
-enum LocalFrontendBuilder {
-    HyperCore {
-        auth: Option<BorrowedCookie>,
-        cookie_manager: HyperSessionCookieManger,
-    },
-    HyperLite,
-}
-
 impl LocalChromiumSession {
     pub(crate) fn new(
         launch_spec: ParticipantLaunchSpec,
@@ -98,10 +88,7 @@ impl LocalChromiumSession {
         auth: Option<BorrowedCookie>,
         cookie_manager: HyperSessionCookieManger,
     ) -> Self {
-        let frontend_builder = match launch_spec.frontend_kind {
-            ResolvedFrontendKind::HyperCore => LocalFrontendBuilder::HyperCore { auth, cookie_manager },
-            ResolvedFrontendKind::HyperLite => LocalFrontendBuilder::HyperLite,
-        };
+        let frontend_builder = FrontendAuth::for_kind(launch_spec.frontend_kind, auth, cookie_manager);
         let (termination_tx, termination_rx) = watch::channel(None);
 
         Self {
@@ -137,17 +124,19 @@ impl LocalChromiumSession {
         let detached_target_task =
             drive_detached_target_events(&self.launch_spec.username, &mut browser, self.termination_tx.clone()).await?;
 
-        let frontend_builder = self
+        let auth = self
             .frontend_builder
             .take()
-            .context("local frontend builder already consumed")?;
-        let automation = frontend_builder
-            .build(FrontendContext {
+            .context("local frontend auth already consumed")?;
+        let automation = FrontendKindBuilder::build(
+            FrontendContext {
                 launch_spec: self.launch_spec.clone(),
-                page: page.clone(),
+                driver: Box::new(ChromiumDriver::new(page.clone())),
                 sender: self.sender.clone(),
-            })
-            .await?;
+            },
+            auth,
+        )
+        .await?;
 
         self.browser = Some(browser);
         self.page = Some(page);
@@ -283,24 +272,6 @@ impl ParticipantDriverSession for LocalChromiumSession {
     }
 }
 
-impl LocalFrontendBuilder {
-    async fn build(self, context: FrontendContext) -> Result<Box<dyn FrontendAutomation>> {
-        match self {
-            Self::HyperCore { auth, cookie_manager } => {
-                let auth = if let Some(cookie) = auth {
-                    cookie
-                } else {
-                    cookie_manager
-                        .fetch_new_cookie(context.launch_spec.base_url(), context.participant_name())
-                        .await?
-                };
-                Ok(Box::new(ParticipantInner::new(context, auth)))
-            }
-            Self::HyperLite => Ok(Box::new(ParticipantInnerLite::new(context))),
-        }
-    }
-}
-
 const CHROME_BINARY_NAMES: &[&str] = &["chromium", "google-chrome", "google-chrome-stable", "chrome"];
 #[cfg(any(test, target_os = "macos"))]
 const MACOS_GOOGLE_CHROME_APP_BINARY: &str = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
diff --git a/browser/src/util.rs b/browser/src/util.rs
deleted file mode 100644
index 5765f38..0000000
--- a/browser/src/util.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use chromiumoxide::{
-    Element,
-    Page,
-};
-use eyre::Result;
-use std::time::Duration;
-
-/// Poll for a DOM element until it appears or the timeout elapses.
-pub(crate) async fn wait_for_element(page: &Page, selector: &str, timeout: Duration) -> Result<Element> {
-    let now = std::time::Instant::now();
-
-    loop {
-        if let Ok(element) = page.find_element(selector).await {
-            return Ok(element);
-        }
-
-        // Sleep for a short duration to avoid busy waiting.
-        tokio::time::sleep(Duration::from_millis(100)).await;
-
-        if now.elapsed() > timeout {
-            return Err(eyre::eyre!("timeout waiting for element: {}", selector));
-        }
-    }
-}

From 2c962999fb383a34456777a62bbe0ae5a36aeeb7 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:33:42 +0200
Subject: [PATCH 08/42] feat(browser): add WebDriverDriver (thirtyfour)
 BrowserDriver impl

---
 browser/src/participant/device_farm/mod.rs    |   4 +
 .../device_farm/webdriver_driver.rs           | 155 ++++++++++++++++++
 browser/src/participant/mod.rs                |   1 +
 3 files changed, 160 insertions(+)
 create mode 100644 browser/src/participant/device_farm/mod.rs
 create mode 100644 browser/src/participant/device_farm/webdriver_driver.rs

diff --git a/browser/src/participant/device_farm/mod.rs b/browser/src/participant/device_farm/mod.rs
new file mode 100644
index 0000000..e0d93b5
--- /dev/null
+++ b/browser/src/participant/device_farm/mod.rs
@@ -0,0 +1,4 @@
+mod webdriver_driver;
+
+#[allow(unused_imports)]
+pub(crate) use webdriver_driver::WebDriverDriver;
diff --git a/browser/src/participant/device_farm/webdriver_driver.rs b/browser/src/participant/device_farm/webdriver_driver.rs
new file mode 100644
index 0000000..8a89eb2
--- /dev/null
+++ b/browser/src/participant/device_farm/webdriver_driver.rs
@@ -0,0 +1,155 @@
+use crate::participant::frontend::BrowserDriver;
+use eyre::{
+    Context as _,
+    Result,
+};
+use futures::{
+    future::BoxFuture,
+    FutureExt as _,
+};
+use std::time::Duration;
+use thirtyfour::{
+    By,
+    Cookie,
+    WebDriver,
+};
+
+/// `BrowserDriver` implementation backed by a remote Selenium `WebDriver`
+/// (AWS Device Farm Test Grid endpoint).
+#[allow(dead_code)]
+pub(crate) struct WebDriverDriver {
+    driver: WebDriver,
+}
+
+#[allow(dead_code)]
+impl WebDriverDriver {
+    pub(crate) fn new(driver: WebDriver) -> Self {
+        Self { driver }
+    }
+
+    /// Consume the driver and end the remote session.
+    pub(crate) async fn quit(self) -> Result<()> {
+        self.driver.quit().await.context("failed to quit WebDriver session")
+    }
+
+    /// A cheap no-op WebDriver command, used by the keep-alive poller to stay
+    /// inside `aws:idleTimeoutSecs` and to detect a dead session.
+    pub(crate) async fn ping(&self) -> Result<()> {
+        self.driver
+            .current_url()
+            .await
+            .context("WebDriver session is not responsive")?;
+        Ok(())
+    }
+}
+
+impl BrowserDriver for WebDriverDriver {
+    fn goto(&self, url: &str) -> BoxFuture<'_, Result<()>> {
+        let url = url.to_owned();
+        async move { self.driver.goto(&url).await.context("failed to navigate") }.boxed()
+    }
+
+    fn exists(&self, selector: &str) -> BoxFuture<'_, Result<bool>> {
+        let selector = selector.to_owned();
+        async move { Ok(self.driver.find(By::Css(&selector)).await.is_ok()) }.boxed()
+    }
+
+    fn wait_for(&self, selector: &str, timeout: Duration) -> BoxFuture<'_, Result<()>> {
+        let selector = selector.to_owned();
+        async move {
+            let start = std::time::Instant::now();
+            loop {
+                if self.driver.find(By::Css(&selector)).await.is_ok() {
+                    return Ok(());
+                }
+                if start.elapsed() > timeout {
+                    eyre::bail!("timeout waiting for selector {selector}");
+                }
+                tokio::time::sleep(Duration::from_millis(200)).await;
+            }
+        }
+        .boxed()
+    }
+
+    fn click(&self, selector: &str) -> BoxFuture<'_, Result<()>> {
+        let selector = selector.to_owned();
+        async move {
+            self.driver
+                .find(By::Css(&selector))
+                .await
+                .with_context(|| format!("Could not find {selector}"))?
+                .click()
+                .await
+                .with_context(|| format!("Could not click {selector}"))
+        }
+        .boxed()
+    }
+
+    fn fill(&self, selector: &str, text: &str) -> BoxFuture<'_, Result<()>> {
+        let selector = selector.to_owned();
+        let text = text.to_owned();
+        async move {
+            let element = self
+                .driver
+                .find(By::Css(&selector))
+                .await
+                .with_context(|| format!("Could not find {selector}"))?;
+            element.clear().await.context("failed to clear element")?;
+            element.send_keys(&text).await.context("failed to type into element")?;
+            Ok(())
+        }
+        .boxed()
+    }
+
+    fn attribute(&self, selector: &str, name: &str) -> BoxFuture<'_, Result<Option<String>>> {
+        let selector = selector.to_owned();
+        let name = name.to_owned();
+        async move {
+            match self.driver.find(By::Css(&selector)).await {
+                Ok(element) => element
+                    .attr(&name)
+                    .await
+                    .with_context(|| format!("failed to read attribute {name}")),
+                Err(_) => Ok(None),
+            }
+        }
+        .boxed()
+    }
+
+    fn eval(&self, js_body: &str, arg: Option<serde_json::Value>) -> BoxFuture<'_, Result<serde_json::Value>> {
+        let js_body = js_body.to_owned();
+        async move {
+            let args = match arg {
+                Some(value) => vec![value],
+                None => vec![],
+            };
+            let ret = self
+                .driver
+                .execute(&js_body, args)
+                .await
+                .context("failed to execute script")?;
+            Ok(ret.json().clone())
+        }
+        .boxed()
+    }
+
+    fn set_cookie(&self, domain: &str, name: &str, value: &str) -> BoxFuture<'_, Result<()>> {
+        let domain = domain.to_owned();
+        let name = name.to_owned();
+        let value = value.to_owned();
+        async move {
+            // WebDriver requires being on the target origin before adding a cookie.
+            let origin = format!("https://{domain}/");
+            self.driver
+                .goto(&origin)
+                .await
+                .with_context(|| format!("failed to open origin {origin} before setting cookie"))?;
+            let mut cookie = Cookie::new(name, value);
+            cookie.set_domain(domain);
+            cookie.set_path("/");
+            self.driver.add_cookie(cookie).await.context("failed to add cookie")?;
+            Ok(())
+        }
+        .boxed()
+    }
+}
diff --git a/browser/src/participant/mod.rs b/browser/src/participant/mod.rs
index 4a77863..b0fbaa6 100644
--- a/browser/src/participant/mod.rs
+++ b/browser/src/participant/mod.rs
@@ -47,6 +47,7 @@ use tokio_util::sync::{
 };
 
 mod cloudflare;
+mod device_farm;
 mod frontend;
 mod local;
 mod remote_stub;

From 9b482cac02a264f71080d2c39d3d402b86bf1b30 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:37:42 +0200
Subject: [PATCH 09/42] feat(config): add DeviceFarmConfig

---
 config/src/device_farm_config.rs | 65 ++++++++++++++++++++++++++++++++
 config/src/lib.rs                |  2 +
 2 files changed, 67 insertions(+)
 create mode 100644 config/src/device_farm_config.rs

diff --git a/config/src/device_farm_config.rs b/config/src/device_farm_config.rs
new file mode 100644
index 0000000..d276150
--- /dev/null
+++ b/config/src/device_farm_config.rs
@@ -0,0 +1,65 @@
+use serde::{
+    Deserialize,
+    Serialize,
+};
+
+const DEFAULT_REGION: &str = "us-west-2";
+
+/// Configuration for the AWS Device Farm desktop-browser ("Test Grid") backend.
+///
+/// Credentials are NOT stored here; they are resolved from the standard AWS
+/// credential chain (env vars / shared profile) by `aws-config` at runtime.
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DeviceFarmConfig {
+    /// ARN of the Device Farm Test Grid project (from Terraform output).
+    pub project_arn: String,
+    /// AWS region; Device Farm Test Grid is only available in us-west-2.
+    pub region: String,
+    /// Lifetime requested for the generated Selenium connection URL.
+    pub url_expires_seconds: u64,
+    /// `aws:maxDurationSecs` capability - hard cap on total session length.
+    pub session_max_duration_ms: u64,
+    /// `aws:idleTimeoutSecs` capability - max gap between WebDriver commands.
+    pub idle_timeout_ms: u64,
+    pub navigation_timeout_ms: u64,
+    pub selector_timeout_ms: u64,
+    /// How often the keep-alive poller pings the live session.
+    pub health_poll_interval_ms: u64,
+    pub debug: bool,
+}
+
+impl DeviceFarmConfig {
+    pub fn is_default(&self) -> bool {
+        self == &Self::default()
+    }
+}
+
+impl Default for DeviceFarmConfig {
+    fn default() -> Self {
+        Self {
+            project_arn: String::new(),
+            region: DEFAULT_REGION.to_owned(),
+            url_expires_seconds: 300,
+            session_max_duration_ms: 1_800_000,
+            idle_timeout_ms: 180_000,
+            navigation_timeout_ms: 45_000,
+            selector_timeout_ms: 20_000,
+            health_poll_interval_ms: 30_000,
+            debug: false,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn default_targets_us_west_2_and_is_default() {
+        let config = DeviceFarmConfig::default();
+        assert_eq!(config.region, "us-west-2");
+        assert!(config.is_default());
+        // Poll interval must stay safely inside the idle timeout window.
+        assert!(config.health_poll_interval_ms < config.idle_timeout_ms);
+    }
+}
diff --git a/config/src/lib.rs b/config/src/lib.rs
index 2d7fef7..bef897b 100644
--- a/config/src/lib.rs
+++ b/config/src/lib.rs
@@ -6,6 +6,7 @@ mod args;
 mod browser_config;
 mod client_config;
 mod cloudflare_config;
+mod device_farm_config;
 pub mod media;
 mod participant_config;
 
@@ -30,6 +31,7 @@ pub use client_config::{
     WebcamResolutionIter,
 };
 pub use cloudflare_config::CloudflareConfig;
+pub use device_farm_config::DeviceFarmConfig;
 use color_eyre::Result;
 use eyre::Context as _;
 pub use participant_config::{

From 2e00441527d4cf9b1ef2ff98ce4dfc7d6daf0cbb Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:38:22 +0200
Subject: [PATCH 10/42] feat(config): add AwsDeviceFarm participant backend
 kind

---
 config/src/client_config.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/config/src/client_config.rs b/config/src/client_config.rs
index 9544125..b9d672e 100644
--- a/config/src/client_config.rs
+++ b/config/src/client_config.rs
@@ -98,6 +98,7 @@ pub enum ParticipantBackendKind {
     Local,
     Cloudflare,
     RemoteStub,
+    AwsDeviceFarm,
 }
 
 impl ParticipantBackendKind {
@@ -105,3 +106,17 @@ impl ParticipantBackendKind {
         matches!(self, Self::Local)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::ParticipantBackendKind;
+    use std::str::FromStr as _;
+
+    #[test]
+    fn aws_device_farm_round_trips_kebab_case() {
+        let kind = ParticipantBackendKind::from_str("aws-device-farm").unwrap();
+        assert_eq!(kind, ParticipantBackendKind::AwsDeviceFarm);
+        assert_eq!(kind.to_string(), "aws-device-farm");
+        assert!(!kind.is_local());
+    }
+}

From d01ff2332e7a0e79d299105326809aa5806a3e68 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:39:54 +0200
Subject: [PATCH 11/42] feat(config): wire device_farm config into Config +
 defaults

---
 browser/src/participant/mod.rs |  1 +
 config/src/default-config.yaml | 10 +++++
 config/src/lib.rs              | 70 +++++++++++++++++++++++++++++++++-
 3 files changed, 80 insertions(+), 1 deletion(-)

diff --git a/browser/src/participant/mod.rs b/browser/src/participant/mod.rs
index b0fbaa6..ed66f36 100644
--- a/browser/src/participant/mod.rs
+++ b/browser/src/participant/mod.rs
@@ -85,6 +85,7 @@ impl Participant {
             ParticipantBackendKind::Local => Self::spawn_with_app_config(config, cookie_manager),
             ParticipantBackendKind::Cloudflare => Self::spawn_cloudflare(config, cookie_manager),
             ParticipantBackendKind::RemoteStub => Self::spawn_remote_stub(config, cookie_manager),
+            ParticipantBackendKind::AwsDeviceFarm => eyre::bail!("AWS Device Farm backend is not implemented yet"),
         }
     }
 
diff --git a/config/src/default-config.yaml b/config/src/default-config.yaml
index 0ea0fb8..20df613 100644
--- a/config/src/default-config.yaml
+++ b/config/src/default-config.yaml
@@ -33,6 +33,16 @@ cloudflare:
   selector_timeout_ms: 20000
   debug: false
   health_poll_interval_ms: 5000
+device_farm:
+  project_arn: ''
+  region: us-west-2
+  url_expires_seconds: 300
+  session_max_duration_ms: 1800000
+  idle_timeout_ms: 180000
+  navigation_timeout_ms: 45000
+  selector_timeout_ms: 20000
+  health_poll_interval_ms: 30000
+  debug: false
 audio_enabled: true
 video_enabled: true
 auto_gain_control: true
diff --git a/config/src/lib.rs b/config/src/lib.rs
index bef897b..b86312e 100644
--- a/config/src/lib.rs
+++ b/config/src/lib.rs
@@ -31,8 +31,8 @@ pub use client_config::{
     WebcamResolutionIter,
 };
 pub use cloudflare_config::CloudflareConfig;
-pub use device_farm_config::DeviceFarmConfig;
 use color_eyre::Result;
+pub use device_farm_config::DeviceFarmConfig;
 use eyre::Context as _;
 pub use participant_config::{
     generate_random_name,
@@ -63,6 +63,8 @@ pub struct Config {
     pub backend: ParticipantBackendKind,
     #[serde(default, skip_serializing_if = "CloudflareConfig::is_default")]
     pub cloudflare: CloudflareConfig,
+    #[serde(default, skip_serializing_if = "DeviceFarmConfig::is_default")]
+    pub device_farm: DeviceFarmConfig,
     #[serde(default)]
     pub audio_enabled: bool,
     #[serde(default)]
@@ -131,6 +133,38 @@ impl config::Source for Config {
                 .into(),
             );
         }
+        if !self.device_farm.is_default() {
+            cache.insert(
+                "device_farm".to_string(),
+                config::ValueKind::Table(HashMap::from_iter([
+                    ("project_arn".to_string(), self.device_farm.project_arn.clone().into()),
+                    ("region".to_string(), self.device_farm.region.clone().into()),
+                    (
+                        "url_expires_seconds".to_string(),
+                        self.device_farm.url_expires_seconds.into(),
+                    ),
+                    (
+                        "session_max_duration_ms".to_string(),
+                        self.device_farm.session_max_duration_ms.into(),
+                    ),
+                    ("idle_timeout_ms".to_string(), self.device_farm.idle_timeout_ms.into()),
+                    (
+                        "navigation_timeout_ms".to_string(),
+                        self.device_farm.navigation_timeout_ms.into(),
+                    ),
+                    (
+                        "selector_timeout_ms".to_string(),
+                        self.device_farm.selector_timeout_ms.into(),
+                    ),
+                    (
+                        "health_poll_interval_ms".to_string(),
+                        self.device_farm.health_poll_interval_ms.into(),
+                    ),
+                    ("debug".to_string(), self.device_farm.debug.into()),
+                ]))
+                .into(),
+            );
+        }
         if let Some(url) = &self.url {
             cache.insert("url".to_string(), url.to_string().into());
         }
@@ -347,4 +381,38 @@ cloudflare:
         assert!(config.cloudflare.debug);
         assert_eq!(config.cloudflare.health_poll_interval_ms, 2_000);
     }
+
+    #[test]
+    fn parses_aws_device_farm_backend_and_nested_device_farm_config() {
+        let config: Config = config::Config::builder()
+            .add_source(Config::default())
+            .add_source(config::File::from_str(
+                r#"
+backend: aws-device-farm
+device_farm:
+  project_arn: arn:aws:devicefarm:us-west-2:123456789012:testgrid-project:abc
+  region: us-west-2
+  url_expires_seconds: 300
+  session_max_duration_ms: 1800000
+  idle_timeout_ms: 180000
+  navigation_timeout_ms: 45000
+  selector_timeout_ms: 20000
+  health_poll_interval_ms: 30000
+  debug: true
+"#,
+                config::FileFormat::Yaml,
+            ))
+            .build()
+            .expect("failed to build config")
+            .try_deserialize()
+            .expect("failed to deserialize config");
+
+        assert_eq!(config.backend, ParticipantBackendKind::AwsDeviceFarm);
+        assert_eq!(
+            config.device_farm.project_arn,
+            "arn:aws:devicefarm:us-west-2:123456789012:testgrid-project:abc"
+        );
+        assert_eq!(config.device_farm.region, "us-west-2");
+        assert!(config.device_farm.debug);
+    }
 }

From e5616eb1b10bab9d41991ac89a81cd2925845e76 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:48:26 +0200
Subject: [PATCH 12/42] feat(browser): add TestGridApi seam over
 aws-sdk-devicefarm

---
 browser/src/participant/device_farm/mod.rs    |  6 +++
 .../src/participant/device_farm/test_grid.rs  | 54 +++++++++++++++++++
 2 files changed, 60 insertions(+)
 create mode 100644 browser/src/participant/device_farm/test_grid.rs

diff --git a/browser/src/participant/device_farm/mod.rs b/browser/src/participant/device_farm/mod.rs
index e0d93b5..496b2d1 100644
--- a/browser/src/participant/device_farm/mod.rs
+++ b/browser/src/participant/device_farm/mod.rs
@@ -1,4 +1,10 @@
+mod test_grid;
 mod webdriver_driver;
 
+#[allow(unused_imports)]
+pub(crate) use test_grid::{
+    AwsTestGrid,
+    TestGridApi,
+};
 #[allow(unused_imports)]
 pub(crate) use webdriver_driver::WebDriverDriver;
diff --git a/browser/src/participant/device_farm/test_grid.rs b/browser/src/participant/device_farm/test_grid.rs
new file mode 100644
index 0000000..0f01689
--- /dev/null
+++ b/browser/src/participant/device_farm/test_grid.rs
@@ -0,0 +1,54 @@
+use eyre::{
+    Context as _,
+    Result,
+};
+use futures::{
+    future::BoxFuture,
+    FutureExt as _,
+};
+
+/// Minimal seam over the Device Farm Test Grid control plane so the session
+/// logic can be tested without real AWS calls.
+pub(crate) trait TestGridApi: Send + Sync {
+    /// Create a short-lived Selenium Remote WebDriver URL for `project_arn`.
+    fn create_test_grid_url(&self, project_arn: &str, expires_seconds: u64) -> BoxFuture<'_, Result<String>>;
+}
+
+/// Real implementation backed by `aws-sdk-devicefarm`.
+pub(crate) struct AwsTestGrid {
+    client: aws_sdk_devicefarm::Client,
+}
+
+impl AwsTestGrid {
+    pub(crate) async fn new(region: &str) -> Self {
+        let region = aws_sdk_devicefarm::config::Region::new(region.to_owned());
+        let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
+            .region(region)
+            .load()
+            .await;
+        Self {
+            client: aws_sdk_devicefarm::Client::new(&config),
+        }
+    }
+}
+
+impl TestGridApi for AwsTestGrid {
+    fn create_test_grid_url(&self, project_arn: &str, expires_seconds: u64) -> BoxFuture<'_, Result<String>> {
+        let project_arn = project_arn.to_owned();
+        async move {
+            let output = self
+                .client
+                .create_test_grid_url()
+                .project_arn(project_arn)
+                .expires_in_seconds(expires_seconds as i32)
+                .send()
+                .await
+                .context("CreateTestGridUrl failed")?;
+            output
+                .url()
+                .map(str::to_owned)
+                .ok_or_else(|| eyre::eyre!("CreateTestGridUrl returned no url"))
+        }
+        .boxed()
+    }
+}

From e42eb0f215284550e2a6f4e5ff6647666ca18b36 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:50:35 +0200
Subject: [PATCH 13/42] feat(browser): implement DeviceFarmSession lifecycle +
 keep-alive poller

---
 browser/src/participant/device_farm/mod.rs    | 326 ++++++++++++++++++
 .../src/participant/device_farm/test_grid.rs  |   2 +
 2 files changed, 328 insertions(+)

diff --git a/browser/src/participant/device_farm/mod.rs b/browser/src/participant/device_farm/mod.rs
index 496b2d1..5362e05 100644
--- a/browser/src/participant/device_farm/mod.rs
+++ b/browser/src/participant/device_farm/mod.rs
@@ -8,3 +8,329 @@ pub(crate) use test_grid::{
 };
 #[allow(unused_imports)]
 pub(crate) use webdriver_driver::WebDriverDriver;
+
+use crate::{
+    auth::{
+        BorrowedCookie,
+        HyperSessionCookieManger,
+    },
+    participant::{
+        frontend::{
+            FrontendAuth,
+            FrontendAutomation,
+            FrontendContext,
+            FrontendKindBuilder,
+        },
+        shared::{
+            messages::{
+                ParticipantLogMessage,
+                ParticipantMessage,
+            },
+            DriverTermination,
+            ParticipantDriverSession,
+            ParticipantLaunchSpec,
+            ParticipantState,
+        },
+    },
+};
+use client_simulator_config::{
+    media::FakeMedia,
+    DeviceFarmConfig,
+};
+use eyre::{
+    bail,
+    Context as _,
+    ContextCompat as _,
+    Result,
+};
+use futures::{
+    future::BoxFuture,
+    FutureExt as _,
+};
+use std::{
+    sync::Arc,
+    time::Duration,
+};
+use thirtyfour::{
+    CapabilitiesHelper,
+    ChromeCapabilities,
+    ChromiumLikeCapabilities,
+    DesiredCapabilities,
+    WebDriver,
+};
+use tokio::{
+    sync::{
+        mpsc::UnboundedSender,
+        oneshot,
+        watch,
+    },
+    task::JoinHandle,
+    time::MissedTickBehavior,
+};
+
+#[allow(dead_code)]
+#[derive(Debug, Clone, PartialEq)]
+pub(super) struct DeviceFarmLaunchOptions {
+    headless: bool,
+    fake_media: FakeMedia,
+}
+
+impl From<&client_simulator_config::Config> for DeviceFarmLaunchOptions {
+    fn from(config: &client_simulator_config::Config) -> Self {
+        Self {
+            headless: config.headless,
+            fake_media: config.fake_media(),
+        }
+    }
+}
+
+#[allow(dead_code)]
+pub(super) struct DeviceFarmSession {
+    launch_spec: ParticipantLaunchSpec,
+    launch_options: DeviceFarmLaunchOptions,
+    config: DeviceFarmConfig,
+    sender: UnboundedSender<ParticipantLogMessage>,
+    api: Arc<dyn TestGridApi>,
+    auth: Option<FrontendAuth>,
+    automation: Option<Box<dyn FrontendAutomation>>,
+    cached_state: ParticipantState,
+    termination_tx: watch::Sender<Option<DriverTermination>>,
+    termination_rx: watch::Receiver<Option<DriverTermination>>,
+    poller_shutdown_tx: Option<oneshot::Sender<()>>,
+    poller_task: Option<JoinHandle<()>>,
+}
+
+#[allow(dead_code)]
+impl DeviceFarmSession {
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn new(
+        launch_spec: ParticipantLaunchSpec,
+        launch_options: DeviceFarmLaunchOptions,
+        config: DeviceFarmConfig,
+        sender: UnboundedSender<ParticipantLogMessage>,
+        cookie: Option<BorrowedCookie>,
+        cookie_manager: HyperSessionCookieManger,
+        api: Arc<dyn TestGridApi>,
+    ) -> Self {
+        let auth = FrontendAuth::for_kind(launch_spec.frontend_kind, cookie, cookie_manager);
+        let (termination_tx, termination_rx) = watch::channel(None);
+        Self {
+            cached_state: ParticipantState {
+                username: launch_spec.username.clone(),
+                ..Default::default()
+            },
+            launch_spec,
+            launch_options,
+            config,
+            sender,
+            api,
+            auth: Some(auth),
+            automation: None,
+            termination_tx,
+            termination_rx,
+            poller_shutdown_tx: None,
+            poller_task: None,
+        }
+    }
+
+    fn log_message(&self, level: &str, message: impl ToString) {
+        let log_message = ParticipantLogMessage::new(level, &self.launch_spec.username, message);
+        log_message.write();
+        if let Err(err) = self.sender.send(log_message) {
+            trace!(participant = %self.launch_spec.username, "Failed to send device farm log message: {err}");
+        }
+    }
+
+    fn log_backend_limitations(&self) {
+        if matches!(self.launch_options.fake_media, FakeMedia::FileOrUrl(_)) {
+            self.log_message(
+                "warn",
+                "Device Farm backend cannot use a local fake-media file/URL; using the synthetic fake device instead",
+            );
+        }
+    }
+
+    fn build_capabilities(config: &DeviceFarmConfig) -> Result<ChromeCapabilities> {
+        let mut caps = DesiredCapabilities::chrome();
+        // Synthetic fake media only. Device Farm has no access to local fake-media files.
+        caps.add_arg("--use-fake-ui-for-media-stream")?;
+        caps.add_arg("--use-fake-device-for-media-stream")?;
+        caps.insert_base_capability(
+            "aws:maxDurationSecs".to_string(),
+            serde_json::json!((config.session_max_duration_ms / 1000).max(1)),
+        );
+        caps.insert_base_capability(
+            "aws:idleTimeoutSecs".to_string(),
+            serde_json::json!((config.idle_timeout_ms / 1000).max(1)),
+        );
+        Ok(caps)
+    }
+
+    async fn connect(api: Arc<dyn TestGridApi>, config: DeviceFarmConfig) -> Result<WebDriver> {
+        let url = api
+            .create_test_grid_url(&config.project_arn, config.url_expires_seconds)
+            .await?;
+        let caps = Self::build_capabilities(&config)?;
+        // Device Farm can take 60-120s before a requested session becomes usable.
+        WebDriver::new(&url, caps)
+            .await
+            .context("failed to connect to Device Farm Selenium endpoint")
+    }
+
+    async fn start_inner(&mut self) -> Result<()> {
+        if self.automation.is_some() {
+            bail!("Device Farm session already started");
+        }
+        self.log_backend_limitations();
+
+        self.log_message(
+            "info",
+            format!(
+                "Requesting Device Farm test grid URL for project {}",
+                self.config.project_arn
+            ),
+        );
+        let driver = Self::connect(Arc::clone(&self.api), self.config.clone()).await?;
+        let webdriver_driver = WebDriverDriver::new(driver);
+
+        let auth = self.auth.take().context("device farm auth already consumed")?;
+        let context = FrontendContext {
+            launch_spec: self.launch_spec.clone(),
+            driver: Box::new(webdriver_driver),
+            sender: self.sender.clone(),
+        };
+        let mut automation = FrontendKindBuilder::build(context, auth).await?;
+
+        self.start_keep_alive_poller();
+        if let Err(err) = automation.join().await {
+            self.stop_keep_alive_poller().await;
+            return Err(err);
+        }
+
+        self.automation = Some(automation);
+        self.cached_state.running = true;
+        self.log_message("info", "Connected Device Farm browser session");
+        Ok(())
+    }
+
+    fn automation_mut(&mut self) -> Result<&mut (dyn FrontendAutomation + 'static)> {
+        self.automation
+            .as_deref_mut()
+            .context("Device Farm automation not started")
+    }
+
+    fn effective_poll_interval(&self) -> Duration {
+        let configured = self.config.health_poll_interval_ms.max(1);
+        let budget = self.config.idle_timeout_ms.saturating_div(2).max(1);
+        Duration::from_millis(configured.min(budget))
+    }
+
+    fn start_keep_alive_poller(&mut self) {
+        // The WebDriver is owned by frontend automation, so Phase 4 keeps
+        // reclamation implicit: Device Farm reclaims an abandoned session after
+        // aws:idleTimeoutSecs, and hard-stops it at aws:maxDurationSecs.
+        let interval = self.effective_poll_interval();
+        let max_duration = Duration::from_millis(self.config.session_max_duration_ms);
+        let termination_tx = self.termination_tx.clone();
+        let (shutdown_tx, mut shutdown_rx) = oneshot::channel();
+
+        let task = tokio::spawn(async move {
+            let mut ticker = tokio::time::interval(interval);
+            ticker.set_missed_tick_behavior(MissedTickBehavior::Delay);
+            ticker.tick().await;
+            let started = tokio::time::Instant::now();
+            loop {
+                tokio::select! {
+                    _ = &mut shutdown_rx => break,
+                    _ = ticker.tick() => {
+                        if started.elapsed() >= max_duration {
+                            let _ = termination_tx.send(Some(DriverTermination::new(
+                                "warn",
+                                "Device Farm session reached its configured max duration",
+                            )));
+                            break;
+                        }
+                    }
+                }
+            }
+        });
+
+        self.poller_shutdown_tx = Some(shutdown_tx);
+        self.poller_task = Some(task);
+    }
+
+    async fn stop_keep_alive_poller(&mut self) {
+        if let Some(tx) = self.poller_shutdown_tx.take() {
+            let _ = tx.send(());
+        }
+        if let Some(task) = self.poller_task.take() {
+            let _ = task.await;
+        }
+    }
+
+    async fn close_inner(&mut self) -> Result<()> {
+        self.stop_keep_alive_poller().await;
+
+        if let Some(mut automation) = self.automation.take() {
+            let joined = automation.refresh_state().await.map(|state| state.joined).unwrap_or(false);
+            if joined {
+                if let Err(err) = automation.leave().await {
+                    self.log_message("error", format!("Failed leaving space while closing: {err}"));
+                }
+            }
+        }
+
+        self.cached_state.running = false;
+        self.cached_state.joined = false;
+        self.cached_state.screenshare_activated = false;
+        self.log_message("info", "Closed Device Farm browser session");
+        Ok(())
+    }
+
+    async fn wait_for_termination_inner(&mut self) -> DriverTermination {
+        loop {
+            if let Some(termination) = self.termination_rx.borrow().clone() {
+                return termination;
+            }
+            if self.termination_rx.changed().await.is_err() {
+                return DriverTermination::new("warn", "device farm termination channel closed");
+            }
+        }
+    }
+}
+
+impl ParticipantDriverSession for DeviceFarmSession {
+    fn participant_name(&self) -> &str {
+        &self.launch_spec.username
+    }
+
+    fn start(&mut self) -> BoxFuture<'_, Result<()>> {
+        self.start_inner().boxed()
+    }
+
+    fn handle_command(&mut self, message: ParticipantMessage) -> BoxFuture<'_, Result<()>> {
+        async move { self.automation_mut()?.handle_command(message).await }.boxed()
+    }
+
+    fn refresh_state(&mut self) -> BoxFuture<'_, Result<ParticipantState>> {
+        async move {
+            match self.automation.as_mut() {
+                Some(automation) => {
+                    let state = automation.refresh_state().await?;
+                    self.cached_state = state.clone();
+                    Ok(state)
+                }
+                None => Ok(self.cached_state.clone()),
+            }
+        }
+        .boxed()
+    }
+
+    fn close(&mut self) -> BoxFuture<'_, Result<()>> {
+        self.close_inner().boxed()
+    }
+
+    fn wait_for_termination(&mut self) -> BoxFuture<'_, DriverTermination> {
+        self.wait_for_termination_inner().boxed()
+    }
+}
diff --git a/browser/src/participant/device_farm/test_grid.rs b/browser/src/participant/device_farm/test_grid.rs
index 0f01689..49824a2 100644
--- a/browser/src/participant/device_farm/test_grid.rs
+++ b/browser/src/participant/device_farm/test_grid.rs
@@ -15,10 +15,12 @@ pub(crate) trait TestGridApi: Send + Sync {
 }
 
 /// Real implementation backed by `aws-sdk-devicefarm`.
+#[allow(dead_code)]
 pub(crate) struct AwsTestGrid {
     client: aws_sdk_devicefarm::Client,
 }
 
+#[allow(dead_code)]
 impl AwsTestGrid {
     pub(crate) async fn new(region: &str) -> Self {
         let region = aws_sdk_devicefarm::config::Region::new(region.to_owned());

From 922429e60c4b32ff175e6d67989ba051ec499e8a Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 15:55:56 +0200
Subject: [PATCH 14/42] feat(browser): wire AwsDeviceFarm backend into
 Participant::spawn

---
 .../src/participant/device_farm/test_grid.rs  | 32 ++++++++----
 browser/src/participant/mod.rs                | 51 ++++++++++++++++++-
 2 files changed, 71 insertions(+), 12 deletions(-)

diff --git a/browser/src/participant/device_farm/test_grid.rs b/browser/src/participant/device_farm/test_grid.rs
index 49824a2..6567261 100644
--- a/browser/src/participant/device_farm/test_grid.rs
+++ b/browser/src/participant/device_farm/test_grid.rs
@@ -15,23 +15,32 @@ pub(crate) trait TestGridApi: Send + Sync {
 }
 
 /// Real implementation backed by `aws-sdk-devicefarm`.
-#[allow(dead_code)]
 pub(crate) struct AwsTestGrid {
-    client: aws_sdk_devicefarm::Client,
+    region: String,
+    client: tokio::sync::OnceCell<aws_sdk_devicefarm::Client>,
 }
 
-#[allow(dead_code)]
 impl AwsTestGrid {
-    pub(crate) async fn new(region: &str) -> Self {
-        let region = aws_sdk_devicefarm::config::Region::new(region.to_owned());
-        let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
-            .region(region)
-            .load()
-            .await;
+    pub(crate) fn new(region: &str) -> Self {
         Self {
-            client: aws_sdk_devicefarm::Client::new(&config),
+            region: region.to_owned(),
+            client: tokio::sync::OnceCell::new(),
         }
     }
+
+    async fn client(&self) -> &aws_sdk_devicefarm::Client {
+        let region = self.region.clone();
+        self.client
+            .get_or_init(|| async move {
+                let region = aws_sdk_devicefarm::config::Region::new(region);
+                let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
+                    .region(region)
+                    .load()
+                    .await;
+                aws_sdk_devicefarm::Client::new(&config)
+            })
+            .await
+    }
 }
 
 impl TestGridApi for AwsTestGrid {
@@ -39,7 +48,8 @@ impl TestGridApi for AwsTestGrid {
         let project_arn = project_arn.to_owned();
         async move {
             let output = self
-                .client
+                .client()
+                .await
                 .create_test_grid_url()
                 .project_arn(project_arn)
                 .expires_in_seconds(expires_seconds as i32)
diff --git a/browser/src/participant/mod.rs b/browser/src/participant/mod.rs
index ed66f36..7c406fd 100644
--- a/browser/src/participant/mod.rs
+++ b/browser/src/participant/mod.rs
@@ -85,7 +85,7 @@ impl Participant {
             ParticipantBackendKind::Local => Self::spawn_with_app_config(config, cookie_manager),
             ParticipantBackendKind::Cloudflare => Self::spawn_cloudflare(config, cookie_manager),
             ParticipantBackendKind::RemoteStub => Self::spawn_remote_stub(config, cookie_manager),
-            ParticipantBackendKind::AwsDeviceFarm => eyre::bail!("AWS Device Farm backend is not implemented yet"),
+            ParticipantBackendKind::AwsDeviceFarm => Self::spawn_device_farm(config, cookie_manager),
         }
     }
 
@@ -196,6 +196,55 @@ impl Participant {
             sender,
         })
     }
+
+    pub fn spawn_device_farm(config: &Config, cookie_manager: HyperSessionCookieManger) -> Result<Self> {
+        use crate::participant::device_farm::{
+            AwsTestGrid,
+            DeviceFarmLaunchOptions,
+            DeviceFarmSession,
+        };
+
+        let session_url = config.url.clone().ok_or_eyre("No session URL provided in the config")?;
+        let frontend_kind = ResolvedFrontendKind::from_session_url(&session_url);
+        let base_url = session_url.origin().unicode_serialization();
+        let cookie = matches!(frontend_kind, ResolvedFrontendKind::HyperCore)
+            .then(|| cookie_manager.give_cookie(&base_url))
+            .flatten();
+        let name = cookie.as_ref().map(BorrowedCookie::username);
+        let participant_config = ParticipantConfig::new(config, name)?;
+        let launch_spec = ParticipantLaunchSpec::from(participant_config);
+        let name = launch_spec.username.clone();
+
+        let device_farm_config = config.device_farm.clone();
+        let launch_options = DeviceFarmLaunchOptions::from(config);
+
+        let (sender, receiver) = unbounded_channel::<ParticipantMessage>();
+        let (log_sender, _log_receiver) = unbounded_channel::<ParticipantLogMessage>();
+        let api = Arc::new(AwsTestGrid::new(&device_farm_config.region));
+
+        let (state_receiver, task_guard) = spawn_session(
+            name.clone(),
+            receiver,
+            log_sender.clone(),
+            DeviceFarmSession::new(
+                launch_spec,
+                launch_options,
+                device_farm_config,
+                log_sender,
+                cookie,
+                cookie_manager,
+                api,
+            ),
+        );
+
+        Ok(Self {
+            name,
+            created: Utc::now(),
+            state: state_receiver,
+            _participant_task_guard: task_guard,
+            sender,
+        })
+    }
 }
 
 fn spawn_session<S>(

From befd16f7e563fccaf5dc5fbfb9697180ef77a734 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 16:01:12 +0200
Subject: [PATCH 15/42] test(browser): integration test for Device Farm session
 lifecycle

---
 browser/src/lib.rs                            |   5 +
 browser/src/participant/device_farm/mod.rs    |  11 +-
 .../src/participant/device_farm/test_grid.rs  |   2 +-
 browser/src/participant/mod.rs                |  15 +-
 browser/tests/device_farm_driver.rs           | 362 ++++++++++++++++++
 5 files changed, 390 insertions(+), 5 deletions(-)
 create mode 100644 browser/tests/device_farm_driver.rs

diff --git a/browser/src/lib.rs b/browser/src/lib.rs
index cc1def2..dca5811 100644
--- a/browser/src/lib.rs
+++ b/browser/src/lib.rs
@@ -3,3 +3,8 @@ extern crate tracing;
 
 pub mod auth;
 pub mod participant;
+
+#[doc(hidden)]
+pub mod testing {
+    pub use crate::participant::device_farm::TestGridApi;
+}
diff --git a/browser/src/participant/device_farm/mod.rs b/browser/src/participant/device_farm/mod.rs
index 5362e05..10b267b 100644
--- a/browser/src/participant/device_farm/mod.rs
+++ b/browser/src/participant/device_farm/mod.rs
@@ -2,9 +2,9 @@ mod test_grid;
 mod webdriver_driver;
 
 #[allow(unused_imports)]
+pub use test_grid::TestGridApi;
 pub(crate) use test_grid::{
     AwsTestGrid,
-    TestGridApi,
 };
 #[allow(unused_imports)]
 pub(crate) use webdriver_driver::WebDriverDriver;
@@ -93,6 +93,7 @@ pub(super) struct DeviceFarmSession {
     api: Arc<dyn TestGridApi>,
     auth: Option<FrontendAuth>,
     automation: Option<Box<dyn FrontendAutomation>>,
+    webdriver: Option<WebDriver>,
     cached_state: ParticipantState,
     termination_tx: watch::Sender<Option<DriverTermination>>,
     termination_rx: watch::Receiver<Option<DriverTermination>>,
@@ -126,6 +127,7 @@ impl DeviceFarmSession {
             api,
             auth: Some(auth),
             automation: None,
+            webdriver: None,
             termination_tx,
             termination_rx,
             poller_shutdown_tx: None,
@@ -191,6 +193,7 @@ impl DeviceFarmSession {
             ),
         );
         let driver = Self::connect(Arc::clone(&self.api), self.config.clone()).await?;
+        self.webdriver = Some(driver.clone());
         let webdriver_driver = WebDriverDriver::new(driver);
 
         let auth = self.auth.take().context("device farm auth already consumed")?;
@@ -280,6 +283,12 @@ impl DeviceFarmSession {
             }
         }
 
+        if let Some(driver) = self.webdriver.take() {
+            if let Err(err) = driver.quit().await {
+                self.log_message("error", format!("Failed closing WebDriver session: {err}"));
+            }
+        }
+
         self.cached_state.running = false;
         self.cached_state.joined = false;
         self.cached_state.screenshare_activated = false;
diff --git a/browser/src/participant/device_farm/test_grid.rs b/browser/src/participant/device_farm/test_grid.rs
index 6567261..c488116 100644
--- a/browser/src/participant/device_farm/test_grid.rs
+++ b/browser/src/participant/device_farm/test_grid.rs
@@ -9,7 +9,7 @@ use futures::{
 
 /// Minimal seam over the Device Farm Test Grid control plane so the session
 /// logic can be tested without real AWS calls.
-pub(crate) trait TestGridApi: Send + Sync {
+pub trait TestGridApi: Send + Sync {
     /// Create a short-lived Selenium Remote WebDriver URL for `project_arn`.
     fn create_test_grid_url(&self, project_arn: &str, expires_seconds: u64) -> BoxFuture<'_, Result<String>>;
 }
diff --git a/browser/src/participant/mod.rs b/browser/src/participant/mod.rs
index 7c406fd..dd696a5 100644
--- a/browser/src/participant/mod.rs
+++ b/browser/src/participant/mod.rs
@@ -47,7 +47,7 @@ use tokio_util::sync::{
 };
 
 mod cloudflare;
-mod device_farm;
+pub mod device_farm;
 mod frontend;
 mod local;
 mod remote_stub;
@@ -198,8 +198,18 @@ impl Participant {
     }
 
     pub fn spawn_device_farm(config: &Config, cookie_manager: HyperSessionCookieManger) -> Result<Self> {
+        let device_farm_config = config.device_farm.clone();
+        let api = Arc::new(crate::participant::device_farm::AwsTestGrid::new(&device_farm_config.region));
+        Self::spawn_device_farm_with_api(config, cookie_manager, api)
+    }
+
+    #[doc(hidden)]
+    pub fn spawn_device_farm_with_api(
+        config: &Config,
+        cookie_manager: HyperSessionCookieManger,
+        api: Arc<dyn crate::testing::TestGridApi>,
+    ) -> Result<Self> {
         use crate::participant::device_farm::{
-            AwsTestGrid,
             DeviceFarmLaunchOptions,
             DeviceFarmSession,
         };
@@ -220,7 +230,6 @@ impl Participant {
 
         let (sender, receiver) = unbounded_channel::<ParticipantMessage>();
         let (log_sender, _log_receiver) = unbounded_channel::<ParticipantLogMessage>();
-        let api = Arc::new(AwsTestGrid::new(&device_farm_config.region));
 
         let (state_receiver, task_guard) = spawn_session(
             name.clone(),
diff --git a/browser/tests/device_farm_driver.rs b/browser/tests/device_farm_driver.rs
new file mode 100644
index 0000000..4ac763d
--- /dev/null
+++ b/browser/tests/device_farm_driver.rs
@@ -0,0 +1,362 @@
+//! Integration test for the AWS Device Farm backend.
+//!
+//! Uses an in-process TCP server that speaks just enough of the W3C WebDriver
+//! HTTP protocol for thirtyfour to drive a session, plus a stubbed TestGridApi
+//! that points thirtyfour at that server. No real AWS or browser is involved.
+
+use client_simulator_browser::{
+    auth::HyperSessionCookieManger,
+    participant::{
+        Participant,
+        ParticipantState,
+    },
+    testing::TestGridApi,
+};
+use client_simulator_config::{
+    Config,
+    DeviceFarmConfig,
+    ParticipantBackendKind,
+};
+use eyre::Result;
+use futures::{
+    future::BoxFuture,
+    FutureExt as _,
+};
+use serde_json::{
+    json,
+    Value,
+};
+use std::{
+    fs,
+    path::PathBuf,
+    sync::{
+        Arc,
+        Mutex,
+    },
+    time::{
+        Duration,
+        SystemTime,
+        UNIX_EPOCH,
+    },
+};
+use tokio::{
+    io::{
+        AsyncReadExt as _,
+        AsyncWriteExt as _,
+    },
+    net::TcpListener,
+    sync::watch,
+    time::timeout,
+};
+
+#[tokio::test]
+async fn device_farm_session_creates_url_connects_joins_and_closes() {
+    let (base_url, requests, server) = spawn_webdriver_mock().await;
+    let cookie_manager = HyperSessionCookieManger::new(unique_temp_dir().join("cookies.json"));
+    let participant = Participant::spawn_device_farm_with_api(
+        &device_farm_config(),
+        cookie_manager,
+        Arc::new(TestGridStub { url: base_url }),
+    )
+    .expect("device farm participant should spawn");
+    let state = participant.state.clone();
+
+    let joined = wait_for_state(&state, |current| current.running && current.joined).await;
+    assert!(joined.running);
+    assert!(joined.joined);
+
+    participant.close().await;
+    assert!(!state.borrow().running);
+
+    server.abort();
+
+    let requests = requests.lock().unwrap().clone();
+    let paths = requests
+        .iter()
+        .map(|request| (request.method.as_str(), request.path.as_str()))
+        .collect::<Vec<_>>();
+    assert!(paths.contains(&("POST", "/session")));
+    assert!(paths.contains(&("POST", "/session/df-1/url")));
+    assert!(paths.iter().any(|(_, path)| path == &"/session/df-1/element"));
+    assert!(paths.iter().any(|(_, path)| path.ends_with("/click")));
+    assert!(paths.contains(&("DELETE", "/session/df-1")));
+}
+
+#[derive(Debug)]
+struct TestGridStub {
+    url: String,
+}
+
+impl TestGridApi for TestGridStub {
+    fn create_test_grid_url(&self, _project_arn: &str, _expires_seconds: u64) -> BoxFuture<'_, Result<String>> {
+        async move { Ok(self.url.clone()) }.boxed()
+    }
+}
+
+fn device_farm_config() -> Config {
+    let mut config = Config::default();
+    config.url = Some("https://example.com/m/demo".parse().unwrap());
+    config.backend = ParticipantBackendKind::AwsDeviceFarm;
+    config.headless = true;
+    config.device_farm = DeviceFarmConfig {
+        project_arn: "arn:aws:devicefarm:us-west-2:123456789012:testgrid-project:abc".to_string(),
+        region: "us-west-2".to_string(),
+        url_expires_seconds: 300,
+        session_max_duration_ms: 60_000,
+        idle_timeout_ms: 30_000,
+        navigation_timeout_ms: 45_000,
+        selector_timeout_ms: 20_000,
+        health_poll_interval_ms: 30_000,
+        debug: false,
+    };
+    config
+}
+
+async fn wait_for_state<F>(state: &watch::Receiver<ParticipantState>, mut predicate: F) -> ParticipantState
+where
+    F: FnMut(&ParticipantState) -> bool,
+{
+    let mut state = state.clone();
+    timeout(Duration::from_secs(2), async move {
+        state.wait_for(|current| predicate(current)).await.unwrap().clone()
+    })
+    .await
+    .expect("timed out waiting for participant state")
+}
+
+#[derive(Clone, Debug)]
+struct CapturedRequest {
+    method: String,
+    path: String,
+    body: String,
+}
+
+#[derive(Debug, Default)]
+struct WebDriverState {
+    joined: bool,
+}
+
+async fn spawn_webdriver_mock() -> (String, Arc<Mutex<Vec<CapturedRequest>>>, tokio::task::JoinHandle<()>) {
+    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let base_url = format!("http://{}", listener.local_addr().unwrap());
+    let requests = Arc::new(Mutex::new(Vec::new()));
+    let requests_for_task = Arc::clone(&requests);
+    let state = Arc::new(Mutex::new(WebDriverState::default()));
+
+    let task = tokio::spawn(async move {
+        loop {
+            let (mut stream, _) = listener.accept().await.unwrap();
+            let request = read_request(&mut stream).await;
+            let response = webdriver_response(&request, &state);
+            requests_for_task.lock().unwrap().push(request);
+            write_response(&mut stream, response).await;
+        }
+    });
+
+    (base_url, requests, task)
+}
+
+fn webdriver_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriverState>>) -> MockResponse {
+    match (request.method.as_str(), request.path.as_str()) {
+        ("POST", "/session") => MockResponse::json(
+            200,
+            json!({
+                "value": {
+                    "sessionId": "df-1",
+                    "capabilities": {
+                        "browserName": "chrome"
+                    }
+                }
+            }),
+        ),
+        ("POST", "/session/df-1/url") => MockResponse::json(200, json!({ "value": null })),
+        ("GET", "/session/df-1/url") => {
+            MockResponse::json(200, json!({ "value": "https://example.com/m/demo" }))
+        }
+        ("DELETE", "/session/df-1") => MockResponse::json(200, json!({ "value": null })),
+        ("POST", "/session/df-1/element") => element_response(request, state),
+        _ if request.path.starts_with("/session/df-1/element/") => element_command_response(request, state),
+        _ if request.path == "/session/df-1/execute/sync" => MockResponse::json(200, json!({ "value": null })),
+        _ => MockResponse::json(200, json!({ "value": null })),
+    }
+}
+
+fn element_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriverState>>) -> MockResponse {
+    let selector = request_json(request)["value"].as_str().unwrap_or_default().to_string();
+    let joined = state.lock().unwrap().joined;
+
+    if selector.contains("trigger-leave-call") || selector.contains("button[aria-label=\"Leave\"]") {
+        if joined {
+            return element("leave");
+        }
+        return no_such_element();
+    }
+
+    if selector.contains("join-button") {
+        return element("join");
+    }
+    if selector.contains("meeting-lobby-display-name") {
+        return element("name");
+    }
+    if selector.contains("toggle-audio") {
+        return element("audio");
+    }
+    if selector.contains("toggle-video") {
+        return element("video");
+    }
+    if selector.contains("toggle-screen-share") {
+        return element("screen");
+    }
+    if selector.contains("alert-dialog-footer") {
+        return element("confirm");
+    }
+
+    element("generic")
+}
+
+fn element_command_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriverState>>) -> MockResponse {
+    if request.path.ends_with("/click") {
+        if request.path.contains("/element/join/") {
+            state.lock().unwrap().joined = true;
+        } else if request.path.contains("/element/leave/") || request.path.contains("/element/confirm/") {
+            state.lock().unwrap().joined = false;
+        }
+        return MockResponse::json(200, json!({ "value": null }));
+    }
+
+    if let Some(attribute) = request.path.rsplit('/').next().filter(|_| request.path.contains("/attribute/")) {
+        let value = match attribute {
+            "data-test-state" if request.path.contains("/element/audio/") => json!("true"),
+            "data-test-state" if request.path.contains("/element/video/") => json!("true"),
+            "data-test-state" if request.path.contains("/element/screen/") => json!("false"),
+            "aria-pressed" => Value::Null,
+            "aria-label" => Value::Null,
+            _ => Value::Null,
+        };
+        return MockResponse::json(200, json!({ "value": value }));
+    }
+
+    MockResponse::json(200, json!({ "value": null }))
+}
+
+fn element(id: &str) -> MockResponse {
+    MockResponse::json(
+        200,
+        json!({
+            "value": {
+                "element-6066-11e4-a52e-4f735466cecf": id,
+                "ELEMENT": id
+            }
+        }),
+    )
+}
+
+fn no_such_element() -> MockResponse {
+    MockResponse::json(
+        404,
+        json!({
+            "value": {
+                "error": "no such element",
+                "message": "no such element",
+                "stacktrace": ""
+            }
+        }),
+    )
+}
+
+#[derive(Debug)]
+struct MockResponse {
+    status: u16,
+    body: String,
+}
+
+impl MockResponse {
+    fn json(status: u16, body: Value) -> Self {
+        Self {
+            status,
+            body: serde_json::to_string(&body).unwrap(),
+        }
+    }
+}
+
+async fn write_response(stream: &mut tokio::net::TcpStream, response: MockResponse) {
+    let reply = format!(
+        "HTTP/1.1 {} {}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+        response.status,
+        status_text(response.status),
+        response.body.len(),
+        response.body,
+    );
+    stream.write_all(reply.as_bytes()).await.unwrap();
+}
+
+async fn read_request(stream: &mut tokio::net::TcpStream) -> CapturedRequest {
+    let mut buffer = Vec::new();
+    let mut chunk = [0_u8; 4096];
+    let header_end;
+
+    loop {
+        let read = stream.read(&mut chunk).await.unwrap();
+        assert!(read > 0, "unexpected EOF while reading request headers");
+        buffer.extend_from_slice(&chunk[..read]);
+
+        if let Some(end) = find_header_end(&buffer) {
+            header_end = end;
+            break;
+        }
+    }
+
+    let headers_bytes = &buffer[..header_end];
+    let headers_text = String::from_utf8(headers_bytes.to_vec()).unwrap();
+    let mut lines = headers_text.split("\r\n");
+    let request_line = lines.next().unwrap();
+    let mut request_line = request_line.split_whitespace();
+    let method = request_line.next().unwrap().to_owned();
+    let path = request_line.next().unwrap().to_owned();
+
+    let mut content_length = 0_usize;
+    for line in lines.filter(|line| !line.is_empty()) {
+        let (name, value) = line.split_once(':').unwrap();
+        if name.eq_ignore_ascii_case("content-length") {
+            content_length = value.trim().parse().unwrap();
+        }
+    }
+
+    let body_start = header_end + 4;
+    let mut body = buffer[body_start..].to_vec();
+    while body.len() < content_length {
+        let read = stream.read(&mut chunk).await.unwrap();
+        assert!(read > 0, "unexpected EOF while reading request body");
+        body.extend_from_slice(&chunk[..read]);
+    }
+
+    CapturedRequest {
+        method,
+        path,
+        body: String::from_utf8(body).unwrap(),
+    }
+}
+
+fn find_header_end(buffer: &[u8]) -> Option<usize> {
+    buffer.windows(4).position(|window| window == b"\r\n\r\n")
+}
+
+fn request_json(request: &CapturedRequest) -> Value {
+    serde_json::from_str(&request.body).unwrap_or(Value::Null)
+}
+
+fn unique_temp_dir() -> PathBuf {
+    let nonce = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
+    let dir = std::env::temp_dir().join(format!("hyper-browser-simulator-device-farm-it-{nonce}"));
+    fs::create_dir_all(&dir).unwrap();
+    dir
+}
+
+fn status_text(status: u16) -> &'static str {
+    match status {
+        200 => "OK",
+        404 => "Not Found",
+        500 => "Internal Server Error",
+        _ => "OK",
+    }
+}

From 4a4474b4d33d7fcf0a567031807a8d8b0f9e061a Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 29 May 2026 16:11:10 +0200
Subject: [PATCH 16/42] style: cargo fmt

---
 browser/src/participant/device_farm/mod.rs | 19 ++++++++++---------
 browser/src/participant/mod.rs             |  4 +++-
 browser/tests/device_farm_driver.rs        | 11 +++++++----
 3 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/browser/src/participant/device_farm/mod.rs b/browser/src/participant/device_farm/mod.rs
index 10b267b..b339da1 100644
--- a/browser/src/participant/device_farm/mod.rs
+++ b/browser/src/participant/device_farm/mod.rs
@@ -1,14 +1,6 @@
 mod test_grid;
 mod webdriver_driver;
 
-#[allow(unused_imports)]
-pub use test_grid::TestGridApi;
-pub(crate) use test_grid::{
-    AwsTestGrid,
-};
-#[allow(unused_imports)]
-pub(crate) use webdriver_driver::WebDriverDriver;
-
 use crate::{
     auth::{
         BorrowedCookie,
@@ -51,6 +43,9 @@ use std::{
     sync::Arc,
     time::Duration,
 };
+pub(crate) use test_grid::AwsTestGrid;
+#[allow(unused_imports)]
+pub use test_grid::TestGridApi;
 use thirtyfour::{
     CapabilitiesHelper,
     ChromeCapabilities,
@@ -67,6 +62,8 @@ use tokio::{
     task::JoinHandle,
     time::MissedTickBehavior,
 };
+#[allow(unused_imports)]
+pub(crate) use webdriver_driver::WebDriverDriver;
 
 #[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq)]
@@ -275,7 +272,11 @@ impl DeviceFarmSession {
         self.stop_keep_alive_poller().await;
 
         if let Some(mut automation) = self.automation.take() {
-            let joined = automation.refresh_state().await.map(|state| state.joined).unwrap_or(false);
+            let joined = automation
+                .refresh_state()
+                .await
+                .map(|state| state.joined)
+                .unwrap_or(false);
             if joined {
                 if let Err(err) = automation.leave().await {
                     self.log_message("error", format!("Failed leaving space while closing: {err}"));
diff --git a/browser/src/participant/mod.rs b/browser/src/participant/mod.rs
index dd696a5..14f7d86 100644
--- a/browser/src/participant/mod.rs
+++ b/browser/src/participant/mod.rs
@@ -199,7 +199,9 @@ impl Participant {
 
     pub fn spawn_device_farm(config: &Config, cookie_manager: HyperSessionCookieManger) -> Result<Self> {
         let device_farm_config = config.device_farm.clone();
-        let api = Arc::new(crate::participant::device_farm::AwsTestGrid::new(&device_farm_config.region));
+        let api = Arc::new(crate::participant::device_farm::AwsTestGrid::new(
+            &device_farm_config.region,
+        ));
         Self::spawn_device_farm_with_api(config, cookie_manager, api)
     }
 
diff --git a/browser/tests/device_farm_driver.rs b/browser/tests/device_farm_driver.rs
index 4ac763d..323247e 100644
--- a/browser/tests/device_farm_driver.rs
+++ b/browser/tests/device_farm_driver.rs
@@ -170,9 +170,7 @@ fn webdriver_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriverStat
             }),
         ),
         ("POST", "/session/df-1/url") => MockResponse::json(200, json!({ "value": null })),
-        ("GET", "/session/df-1/url") => {
-            MockResponse::json(200, json!({ "value": "https://example.com/m/demo" }))
-        }
+        ("GET", "/session/df-1/url") => MockResponse::json(200, json!({ "value": "https://example.com/m/demo" })),
         ("DELETE", "/session/df-1") => MockResponse::json(200, json!({ "value": null })),
         ("POST", "/session/df-1/element") => element_response(request, state),
         _ if request.path.starts_with("/session/df-1/element/") => element_command_response(request, state),
@@ -224,7 +222,12 @@ fn element_command_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriv
         return MockResponse::json(200, json!({ "value": null }));
     }
 
-    if let Some(attribute) = request.path.rsplit('/').next().filter(|_| request.path.contains("/attribute/")) {
+    if let Some(attribute) = request
+        .path
+        .rsplit('/')
+        .next()
+        .filter(|_| request.path.contains("/attribute/"))
+    {
         let value = match attribute {
             "data-test-state" if request.path.contains("/element/audio/") => json!("true"),
             "data-test-state" if request.path.contains("/element/video/") => json!("true"),

From 3f776d6fc2cdcb242a681ba0fa0ca556dd1eb646 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Tue, 2 Jun 2026 10:08:33 +0200
Subject: [PATCH 17/42] plan 1

---
 2026-06-01-no-tui-mode.md | 874 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 874 insertions(+)
 create mode 100644 2026-06-01-no-tui-mode.md

diff --git a/2026-06-01-no-tui-mode.md b/2026-06-01-no-tui-mode.md
new file mode 100644
index 0000000..a29ec47
--- /dev/null
+++ b/2026-06-01-no-tui-mode.md
@@ -0,0 +1,874 @@
+# Headless Command Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add `hyper-client-simulator headless` so simulator participants can be started directly from CLI arguments without entering the TUI or writing runtime options back to the app config.
+
+**Architecture:** Keep the TUI path unchanged. Add a headless runner in the root binary that loads persisted config plus global defaults, overlays command-line settings, overlays each `--participant` JSON object on top of that, spawns participants through `ParticipantStore`, streams tracing output to standard streams, and coordinates graceful/forced shutdown.
+
+**Tech Stack:** Rust 2021, `clap`, `serde`, `serde_json`, `config`, `tokio`, `tracing-subscriber`, existing `client-simulator-config` and `client-simulator-browser` crates.
+
+---
+
+## Design Decisions
+
+- `headless` means "no TUI". It should not implicitly persist settings. It should respect the existing browser `headless` config value unless `--headless true|false` or a participant JSON `{"headless": true}` overrides it.
+- If no `--participant` argument is supplied, start one participant using the global effective config. If one or more `--participant` values are supplied, start exactly one participant per JSON object.
+- Participant JSON supports the same launch-time fields exposed as global headless CLI overrides: `url`, `backend`, `headless`, `audio_enabled`, `video_enabled`, `screenshare_enabled`, `auto_gain_control`, `noise_suppression`, `transport`, `resolution`, `blur`, plus nested `cloudflare` and `device_farm`.
+- Unknown participant JSON fields fail fast. This prevents silent typos such as `audio_enable`.
+- The first `Ctrl-C` calls `ParticipantStore::shutdown_all().await`. A second `Ctrl-C` returns a forced-exit result to `main`, which exits with code `130`.
+- Logging uses a normal `tracing_subscriber` fmt subscriber, not `tui_logger`. Warnings and errors go to stderr; info/debug/trace go to stdout.
+
+## File Structure
+
+- Modify `Cargo.toml`: add root-crate dependency on `serde` because the binary will derive `Deserialize` for participant JSON.
+- Modify `config/src/args.rs`: add `HeadlessConfigArgs`, a `config::Source` implementation, and tests for override collection.
+- Modify `config/src/lib.rs`: re-export `HeadlessConfigArgs`, factor config loading into a generic helper, and add `Config::new_headless`.
+- Create `src/headless.rs`: own headless CLI args, participant JSON parsing, config layering, logging initialization, participant spawning, and shutdown orchestration.
+- Modify `src/main.rs`: add the `headless` subcommand and route it to `headless::run`.
+
+---
+
+### Task 1: Add Headless Config Overrides
+
+**Files:**
+- Modify: `config/src/args.rs`
+- Modify: `config/src/lib.rs`
+
+- [ ] **Step 1: Write config argument tests**
+
+Add these tests to `config/src/args.rs` under the existing module content:
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::HeadlessConfigArgs;
+    use config::Source as _;
+
+    #[test]
+    fn headless_args_collect_only_present_values() {
+        let args = HeadlessConfigArgs {
+            debug: 2,
+            url: Some("https://example.com/space/demo".to_string()),
+            backend: Some("cloudflare".to_string()),
+            audio_enabled: Some(false),
+            video_enabled: None,
+            screenshare_enabled: Some(true),
+            auto_gain_control: None,
+            noise_suppression: Some("rnnoise".to_string()),
+            transport: Some("webrtc".to_string()),
+            resolution: Some("p720".to_string()),
+            blur: Some(true),
+            headless: Some(true),
+        };
+
+        let values = args.collect().expect("collect headless args");
+
+        assert_eq!(values.get("debug").unwrap().clone().into_int().unwrap(), 2);
+        assert_eq!(values.get("url").unwrap().clone().into_string().unwrap(), "https://example.com/space/demo");
+        assert_eq!(values.get("backend").unwrap().clone().into_string().unwrap(), "cloudflare");
+        assert!(!values.get("audio_enabled").unwrap().clone().into_bool().unwrap());
+        assert!(values.get("screenshare_enabled").unwrap().clone().into_bool().unwrap());
+        assert_eq!(values.get("noise_suppression").unwrap().clone().into_string().unwrap(), "rnnoise");
+        assert_eq!(values.get("transport").unwrap().clone().into_string().unwrap(), "webrtc");
+        assert_eq!(values.get("resolution").unwrap().clone().into_string().unwrap(), "p720");
+        assert!(values.get("blur").unwrap().clone().into_bool().unwrap());
+        assert!(values.get("headless").unwrap().clone().into_bool().unwrap());
+        assert!(!values.contains_key("video_enabled"));
+        assert!(!values.contains_key("auto_gain_control"));
+    }
+}
+```
+
+- [ ] **Step 2: Run the targeted config test and verify it fails**
+
+Run:
+
+```bash
+cargo test -p client-simulator-config headless_args_collect_only_present_values
+```
+
+Expected: compile failure because `HeadlessConfigArgs` does not exist.
+
+- [ ] **Step 3: Implement `HeadlessConfigArgs`**
+
+Add this to `config/src/args.rs` after `TuiArgs`:
+
+```rust
+/// Non-TUI participant launch options.
+#[derive(clap::Args, Default, Debug, Clone)]
+pub struct HeadlessConfigArgs {
+    /// Verbosity level, set from the parent command.
+    #[clap(skip)]
+    pub debug: u8,
+
+    /// URL of the hyper.video session.
+    #[clap(long, value_name = "URL")]
+    pub url: Option<String>,
+
+    /// Participant backend: local, cloudflare, remote-stub, or aws-device-farm.
+    #[clap(long, value_name = "BACKEND")]
+    pub backend: Option<String>,
+
+    /// Enable or disable browser headless mode.
+    #[clap(long = "headless", action)]
+    pub headless: Option<bool>,
+
+    /// Enable or disable participant audio.
+    #[clap(long = "audio-enabled", action)]
+    pub audio_enabled: Option<bool>,
+
+    /// Enable or disable participant video.
+    #[clap(long = "video-enabled", action)]
+    pub video_enabled: Option<bool>,
+
+    /// Enable or disable participant screenshare.
+    #[clap(long = "screenshare-enabled", action)]
+    pub screenshare_enabled: Option<bool>,
+
+    /// Enable or disable browser auto gain control.
+    #[clap(long = "auto-gain-control", action)]
+    pub auto_gain_control: Option<bool>,
+
+    /// Noise suppression model.
+    #[clap(long = "noise-suppression", value_name = "MODEL")]
+    pub noise_suppression: Option<String>,
+
+    /// Transport mode: webtransport or webrtc.
+    #[clap(long, value_name = "MODE")]
+    pub transport: Option<String>,
+
+    /// Webcam resolution, such as auto, p720, or p1080.
+    #[clap(long, value_name = "RESOLUTION")]
+    pub resolution: Option<String>,
+
+    /// Enable or disable background blur.
+    #[clap(long, action)]
+    pub blur: Option<bool>,
+}
+```
+
+Then add a `config::Source` implementation parallel to `TuiArgs`, inserting only `Some` values and inserting `debug` only when it is greater than zero.
+
+- [ ] **Step 4: Re-export and add a non-TUI config constructor**
+
+In `config/src/lib.rs`, change:
+
+```rust
+pub use args::TuiArgs;
+```
+
+to:
+
+```rust
+pub use args::{
+    HeadlessConfigArgs,
+    TuiArgs,
+};
+```
+
+Refactor `Config::new` so both TUI and headless loading share the same source order:
+
+```rust
+impl Config {
+    pub fn new(args: TuiArgs) -> Result<Self, config::ConfigError> {
+        Self::load_with_overrides(args)
+    }
+
+    pub fn new_headless(args: HeadlessConfigArgs) -> Result<Self, config::ConfigError> {
+        Self::load_with_overrides(args)
+    }
+
+    fn load_with_overrides<S>(overrides: S) -> Result<Self, config::ConfigError>
+    where
+        S: config::Source + Send + Sync + 'static,
+    {
+        let data_dir = get_data_dir();
+        let config_dir = get_config_dir();
+        let mut builder = config::Config::builder()
+            .set_default("data_dir", data_dir.to_str().unwrap())?
+            .set_default("config_dir", config_dir.to_str().unwrap())?;
+
+        builder = builder.add_source(Config::default());
+
+        let config_files = [("config.yaml", config::FileFormat::Yaml)];
+
+        for (file, format) in &config_files {
+            let source = config::File::from(config_dir.join(file))
+                .format(*format)
+                .required(false);
+            builder = builder.add_source(source);
+        }
+
+        builder = builder.add_source(overrides);
+
+        builder.build()?.try_deserialize()
+    }
+}
+```
+
+- [ ] **Step 5: Run config tests**
+
+Run:
+
+```bash
+cargo test -p client-simulator-config
+```
+
+Expected: all config crate tests pass.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add config/src/args.rs config/src/lib.rs
+git commit -m "feat: add headless config overrides"
+```
+
+---
+
+### Task 2: Add Participant JSON Overlay Logic
+
+**Files:**
+- Modify: `Cargo.toml`
+- Create: `src/headless.rs`
+
+- [ ] **Step 1: Add serde to the root crate**
+
+In the root `Cargo.toml`, add:
+
+```toml
+serde.workspace = true
+```
+
+- [ ] **Step 2: Write participant overlay tests**
+
+Create `src/headless.rs` with the test module first:
+
+```rust
+use client_simulator_config::{
+    CloudflareConfig,
+    Config,
+    DeviceFarmConfig,
+    HeadlessConfigArgs,
+    NoiseSuppression,
+    ParticipantBackendKind,
+    TransportMode,
+    WebcamResolution,
+};
+use eyre::{
+    Context as _,
+    Result,
+};
+use serde::Deserialize;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use url::Url;
+
+    #[test]
+    fn participant_json_overrides_global_config() {
+        let global = Config {
+            url: Some(Url::parse("https://example.com/global").unwrap()),
+            backend: ParticipantBackendKind::Local,
+            audio_enabled: true,
+            video_enabled: true,
+            transport: TransportMode::WebTransport,
+            ..Default::default()
+        };
+
+        let participant = parse_participant_override(
+            r#"{
+                "url": "https://example.com/participant",
+                "backend": "cloudflare",
+                "audio_enabled": false,
+                "transport": "webrtc",
+                "resolution": "p720",
+                "blur": true
+            }"#,
+        )
+        .expect("valid participant json");
+
+        let effective = participant.apply_to(global);
+
+        assert_eq!(effective.url.unwrap().as_str(), "https://example.com/participant");
+        assert_eq!(effective.backend, ParticipantBackendKind::Cloudflare);
+        assert!(!effective.audio_enabled);
+        assert!(effective.video_enabled);
+        assert_eq!(effective.transport, TransportMode::WebRTC);
+        assert_eq!(effective.resolution, WebcamResolution::P720);
+        assert!(effective.blur);
+    }
+
+    #[test]
+    fn empty_participant_list_starts_one_default_participant() {
+        let global = Config {
+            url: Some(Url::parse("https://example.com/global").unwrap()),
+            audio_enabled: true,
+            ..Default::default()
+        };
+
+        let configs = participant_configs(global, &[]).expect("participant configs");
+
+        assert_eq!(configs.len(), 1);
+        assert_eq!(configs[0].url.as_ref().unwrap().as_str(), "https://example.com/global");
+        assert!(configs[0].audio_enabled);
+    }
+
+    #[test]
+    fn unknown_participant_json_field_is_rejected() {
+        let err = parse_participant_override(r#"{"audio_enable": false}"#).unwrap_err();
+
+        assert!(format!("{err:?}").contains("audio_enable"));
+    }
+}
+```
+
+- [ ] **Step 3: Run the overlay tests and verify they fail**
+
+Run:
+
+```bash
+cargo test participant_json_overrides_global_config empty_participant_list_starts_one_default_participant unknown_participant_json_field_is_rejected
+```
+
+Expected: compile failure because the tested functions and types do not exist.
+
+- [ ] **Step 4: Implement participant overlay types**
+
+Add this implementation above the tests in `src/headless.rs`:
+
+```rust
+#[derive(clap::Args, Debug, Clone, Default)]
+pub struct HeadlessArgs {
+    #[command(flatten)]
+    pub config: HeadlessConfigArgs,
+
+    /// Participant-specific JSON overrides. Repeat this flag to start multiple participants.
+    #[clap(long = "participant", value_name = "JSON")]
+    pub participants: Vec<String>,
+}
+
+#[derive(Debug, Clone, Default, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+struct ParticipantOverride {
+    url: Option<url::Url>,
+    backend: Option<ParticipantBackendKind>,
+    cloudflare: Option<CloudflareConfig>,
+    device_farm: Option<DeviceFarmConfig>,
+    headless: Option<bool>,
+    audio_enabled: Option<bool>,
+    video_enabled: Option<bool>,
+    screenshare_enabled: Option<bool>,
+    auto_gain_control: Option<bool>,
+    noise_suppression: Option<NoiseSuppression>,
+    transport: Option<TransportMode>,
+    resolution: Option<WebcamResolution>,
+    blur: Option<bool>,
+}
+
+impl ParticipantOverride {
+    fn apply_to(&self, mut config: Config) -> Config {
+        if let Some(url) = &self.url {
+            config.url = Some(url.clone());
+        }
+        if let Some(backend) = self.backend {
+            config.backend = backend;
+        }
+        if let Some(cloudflare) = &self.cloudflare {
+            config.cloudflare = cloudflare.clone();
+        }
+        if let Some(device_farm) = &self.device_farm {
+            config.device_farm = device_farm.clone();
+        }
+        if let Some(headless) = self.headless {
+            config.headless = headless;
+        }
+        if let Some(audio_enabled) = self.audio_enabled {
+            config.audio_enabled = audio_enabled;
+        }
+        if let Some(video_enabled) = self.video_enabled {
+            config.video_enabled = video_enabled;
+        }
+        if let Some(screenshare_enabled) = self.screenshare_enabled {
+            config.screenshare_enabled = screenshare_enabled;
+        }
+        if let Some(auto_gain_control) = self.auto_gain_control {
+            config.auto_gain_control = auto_gain_control;
+        }
+        if let Some(noise_suppression) = self.noise_suppression {
+            config.noise_suppression = noise_suppression;
+        }
+        if let Some(transport) = self.transport {
+            config.transport = transport;
+        }
+        if let Some(resolution) = self.resolution {
+            config.resolution = resolution;
+        }
+        if let Some(blur) = self.blur {
+            config.blur = blur;
+        }
+        config
+    }
+}
+
+fn parse_participant_override(json: &str) -> Result<ParticipantOverride> {
+    serde_json::from_str(json).wrap_err_with(|| format!("Failed to parse --participant JSON: {json}"))
+}
+
+fn participant_configs(global_config: Config, participant_json: &[String]) -> Result<Vec<Config>> {
+    if participant_json.is_empty() {
+        return Ok(vec![global_config]);
+    }
+
+    participant_json
+        .iter()
+        .map(|json| parse_participant_override(json).map(|participant| participant.apply_to(global_config.clone())))
+        .collect()
+}
+```
+
+- [ ] **Step 5: Run the overlay tests**
+
+Run:
+
+```bash
+cargo test participant_json_overrides_global_config empty_participant_list_starts_one_default_participant unknown_participant_json_field_is_rejected
+```
+
+Expected: all three tests pass.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add Cargo.toml src/headless.rs
+git commit -m "feat: parse headless participant overrides"
+```
+
+---
+
+### Task 3: Implement Headless Runtime and Shutdown Semantics
+
+**Files:**
+- Modify: `src/headless.rs`
+
+- [ ] **Step 1: Write shutdown behavior tests**
+
+Add these tests to the existing test module in `src/headless.rs`:
+
+```rust
+use client_simulator_browser::participant::ParticipantStore;
+use std::{
+    fs,
+    path::PathBuf,
+    time::{
+        SystemTime,
+        UNIX_EPOCH,
+    },
+};
+use tokio::sync::oneshot;
+
+#[tokio::test]
+async fn shutdown_wait_returns_clean_when_participants_stop() {
+    let store = ParticipantStore::new(unique_test_data_dir());
+    let config = Config {
+        url: Some(Url::parse("https://example.com/lite/demo").unwrap()),
+        backend: ParticipantBackendKind::RemoteStub,
+        ..Default::default()
+    };
+    store.spawn(&config).expect("spawn participant");
+
+    let (first_tx, first_rx) = oneshot::channel::<()>();
+    let (_second_tx, second_rx) = oneshot::channel::<()>();
+    let store_for_shutdown = store.clone();
+
+    tokio::spawn(async move {
+        first_tx.send(()).expect("send first shutdown signal");
+    });
+
+    let result = wait_for_headless_exit(
+        store_for_shutdown,
+        async move {
+            let _ = first_rx.await;
+        },
+        || async move {
+            let _ = second_rx.await;
+        },
+    )
+    .await;
+
+    assert_eq!(result, HeadlessExit::Clean);
+    assert!(store.is_empty());
+}
+
+#[tokio::test]
+async fn second_shutdown_signal_returns_forced() {
+    let store = ParticipantStore::new(unique_test_data_dir());
+    let config = Config {
+        url: Some(Url::parse("https://example.com/lite/demo").unwrap()),
+        backend: ParticipantBackendKind::RemoteStub,
+        ..Default::default()
+    };
+    store.spawn(&config).expect("spawn participant");
+
+    let (first_tx, first_rx) = oneshot::channel::<()>();
+    let (second_tx, second_rx) = oneshot::channel::<()>();
+
+    tokio::spawn(async move {
+        first_tx.send(()).expect("send first shutdown signal");
+        second_tx.send(()).expect("send second shutdown signal");
+    });
+
+    let result = wait_for_headless_exit(
+        store,
+        async move {
+            let _ = first_rx.await;
+        },
+        || async move {
+            let _ = second_rx.await;
+        },
+    )
+    .await;
+
+    assert_eq!(result, HeadlessExit::Forced);
+}
+
+fn unique_test_data_dir() -> PathBuf {
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("current time")
+        .as_nanos();
+    let path = std::env::temp_dir().join(format!("hyper-browser-simulator-headless-test-{timestamp}"));
+    fs::create_dir_all(&path).expect("create test data dir");
+    path
+}
+```
+
+- [ ] **Step 2: Run the shutdown tests and verify they fail**
+
+Run:
+
+```bash
+cargo test shutdown_wait_returns_clean_when_participants_stop second_shutdown_signal_returns_forced
+```
+
+Expected: compile failure because `HeadlessExit` and `wait_for_headless_exit` do not exist.
+
+- [ ] **Step 3: Implement runtime entry points**
+
+Add this to `src/headless.rs`:
+
+```rust
+use client_simulator_browser::participant::ParticipantStore;
+use std::{
+    future::Future,
+};
+use tracing_subscriber::{
+    fmt::{
+        self,
+        writer::MakeWriterExt as _,
+    },
+    prelude::*,
+    registry,
+    EnvFilter,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum HeadlessExit {
+    Clean,
+    Forced,
+}
+
+pub async fn run(mut args: HeadlessArgs, debug: u8) -> Result<i32> {
+    args.config.debug = debug;
+    init_headless_logging(debug)?;
+
+    let global_config = Config::new_headless(args.config).context("Failed to create headless config")?;
+    let participant_configs = participant_configs(global_config.clone(), &args.participants)?;
+    let store = ParticipantStore::new(global_config.data_dir());
+
+    for config in &participant_configs {
+        store
+            .spawn(config)
+            .wrap_err_with(|| format!("Failed to spawn participant with backend {}", config.backend))?;
+    }
+
+    let exit = wait_for_headless_exit(store, wait_for_ctrl_c(), wait_for_ctrl_c).await;
+
+    Ok(match exit {
+        HeadlessExit::Clean => 0,
+        HeadlessExit::Forced => 130,
+    })
+}
+
+fn init_headless_logging(debug: u8) -> Result<()> {
+    let filter = match debug {
+        0 => "info",
+        1 => "debug",
+        _ => "trace",
+    };
+    let env_filter = EnvFilter::builder().parse_lossy(filter);
+    let writer = std::io::stderr.with_min_level(tracing::Level::WARN).or_else(std::io::stdout);
+
+    registry()
+        .with(tracing_error::ErrorLayer::default())
+        .with(fmt::layer().with_writer(writer).with_filter(env_filter))
+        .try_init()
+        .context("Failed to initialize headless logging")
+}
+
+async fn wait_for_ctrl_c() {
+    if let Err(err) = tokio::signal::ctrl_c().await {
+        tracing::error!("Failed to listen for Ctrl-C: {err}");
+    }
+}
+
+async fn wait_for_headless_exit<F1, F2, SecondShutdown>(
+    store: ParticipantStore,
+    first_shutdown: F1,
+    second_shutdown: SecondShutdown,
+) -> HeadlessExit
+where
+    F1: Future<Output = ()>,
+    SecondShutdown: FnOnce() -> F2,
+    F2: Future<Output = ()>,
+{
+    tokio::pin!(first_shutdown);
+
+    let mut state_receivers = store
+        .values()
+        .into_iter()
+        .map(|participant| participant.state.clone())
+        .collect::<Vec<_>>();
+
+    let all_stopped = async move {
+        for state in &mut state_receivers {
+            let _ = state.wait_for(|current| !current.running).await;
+        }
+    };
+    tokio::pin!(all_stopped);
+
+    tokio::select! {
+        _ = &mut all_stopped => HeadlessExit::Clean,
+        _ = &mut first_shutdown => {
+            let shutdown = store.shutdown_all();
+            let second_shutdown = second_shutdown();
+            tokio::pin!(shutdown);
+            tokio::pin!(second_shutdown);
+            tokio::select! {
+                _ = &mut shutdown => HeadlessExit::Clean,
+                _ = &mut second_shutdown => HeadlessExit::Forced,
+            }
+        }
+    }
+}
+```
+
+- [ ] **Step 4: Run the shutdown tests**
+
+Run:
+
+```bash
+cargo test shutdown_wait_returns_clean_when_participants_stop second_shutdown_signal_returns_forced
+```
+
+Expected: both tests pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/headless.rs
+git commit -m "feat: add headless runner shutdown handling"
+```
+
+---
+
+### Task 4: Wire the CLI Command
+
+**Files:**
+- Modify: `src/main.rs`
+- Modify: `src/headless.rs`
+
+- [ ] **Step 1: Write CLI parsing tests**
+
+Add this test module to `src/main.rs`:
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::{
+        CliArgs,
+        Command,
+    };
+    use clap::Parser as _;
+
+    #[test]
+    fn parses_headless_command_with_repeated_participants() {
+        let args = CliArgs::parse_from([
+            "hyper-client-simulator",
+            "--debug",
+            "headless",
+            "--url",
+            "https://latest.dev.hyper.video/F27-T5F-DXY",
+            "--participant",
+            r#"{"audio_enabled": false, "backend": "local"}"#,
+            "--participant",
+            r#"{"audio_enabled": true, "backend": "cloudflare"}"#,
+        ]);
+
+        match args.command {
+            Some(Command::Headless(headless)) => {
+                assert_eq!(args.debug, 1);
+                assert_eq!(headless.config.url.as_deref(), Some("https://latest.dev.hyper.video/F27-T5F-DXY"));
+                assert_eq!(headless.participants.len(), 2);
+            }
+            other => panic!("expected headless command, got {other:?}"),
+        }
+    }
+}
+```
+
+- [ ] **Step 2: Run the CLI parsing test and verify it fails**
+
+Run:
+
+```bash
+cargo test parses_headless_command_with_repeated_participants
+```
+
+Expected: compile failure because `headless` is not a module and `Command::Headless` does not exist.
+
+- [ ] **Step 3: Wire `headless` into `main.rs`**
+
+At the top of `src/main.rs`, add:
+
+```rust
+mod headless;
+```
+
+Extend `Command`:
+
+```rust
+#[derive(Subcommand, Debug)]
+enum Command {
+    /// Start the TUI application
+    Tui(TuiArgs),
+    /// Start simulator participants without the TUI
+    Headless(headless::HeadlessArgs),
+    /// Connect to the hyper server to get a hyper session cookie
+    Cookie(CookieArgs),
+}
+```
+
+Derive `Debug` for `CliArgs` if the test needs it:
+
+```rust
+#[derive(Parser, Debug)]
+```
+
+Route the command in `main`:
+
+```rust
+        Some(Command::Headless(args)) => {
+            let code = headless::run(args, debug).await?;
+            std::process::exit(code);
+        }
+```
+
+- [ ] **Step 4: Run the CLI parsing test**
+
+Run:
+
+```bash
+cargo test parses_headless_command_with_repeated_participants
+```
+
+Expected: the test passes.
+
+- [ ] **Step 5: Run a smoke test with the remote stub backend**
+
+Run:
+
+```bash
+cargo run -- headless \
+  --url "https://example.com/lite/demo" \
+  --participant '{"backend": "remote-stub", "audio_enabled": false}'
+```
+
+Expected: the process starts, logs appear in the terminal, pressing `Ctrl-C` once shuts down the participant and exits. Run it a second time, press `Ctrl-C` twice quickly, and verify the process exits with code `130`.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/main.rs src/headless.rs
+git commit -m "feat: add headless cli command"
+```
+
+---
+
+### Task 5: Full Verification
+
+**Files:**
+- No new files.
+
+- [ ] **Step 1: Format**
+
+Run:
+
+```bash
+just fmt
+```
+
+Expected: formatting completes without errors.
+
+- [ ] **Step 2: Lint**
+
+Run:
+
+```bash
+just clippy
+```
+
+Expected: clippy completes with no warnings.
+
+- [ ] **Step 3: Test**
+
+Run:
+
+```bash
+just test
+```
+
+Expected: all tests pass.
+
+- [ ] **Step 4: Manual command check**
+
+Run:
+
+```bash
+cargo run -- headless \
+  --url "https://latest.dev.hyper.video/F27-T5F-DXY" \
+  --participant '{"audio_enabled": false, "backend": "local"}' \
+  --participant '{"audio_enabled": true, "backend": "cloudflare"}'
+```
+
+Expected: two participants are created, logs stream to the terminal, the app does not enter TUI mode, no config file is written as a result of the command-line overrides, one `Ctrl-C` starts clean shutdown, and a second `Ctrl-C` exits immediately with code `130`.
+
+- [ ] **Step 5: Commit verification fixes if any were needed**
+
+If formatting, linting, or tests required changes:
+
+```bash
+git add Cargo.toml config/src/args.rs config/src/lib.rs src/headless.rs src/main.rs
+git commit -m "fix: verify headless command"
+```
+
+Skip this commit if no files changed during verification.
+
+---
+
+## Self-Review
+
+- Spec coverage: The plan covers the new `headless` command, no config persistence, config/default loading, global CLI overrides, per-participant JSON overrides with highest priority, stdout/stderr tracing, graceful shutdown on first `Ctrl-C`, and forced exit on second `Ctrl-C`.
+- Placeholder scan: No incomplete implementation steps remain; tests, commands, expected results, file paths, and concrete code shapes are provided.
+- Type consistency: `HeadlessConfigArgs`, `HeadlessArgs`, `ParticipantOverride`, `HeadlessExit`, and `wait_for_headless_exit` are introduced before they are used by later tasks.

From 2b486c70690d8bc31574598c0ff4246031e5312c Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Tue, 2 Jun 2026 11:30:20 +0200
Subject: [PATCH 18/42] plan 2

---
 2026-06-01-no-tui-mode.md | 934 +++++++++++---------------------------
 1 file changed, 260 insertions(+), 674 deletions(-)

diff --git a/2026-06-01-no-tui-mode.md b/2026-06-01-no-tui-mode.md
index a29ec47..4729f99 100644
--- a/2026-06-01-no-tui-mode.md
+++ b/2026-06-01-no-tui-mode.md
@@ -1,620 +1,309 @@
 # Headless Command Implementation Plan
 
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development or superpowers:executing-plans to implement this plan task-by-task.
 
-**Goal:** Add `hyper-client-simulator headless` so simulator participants can be started directly from CLI arguments without entering the TUI or writing runtime options back to the app config.
+**Goal:** Add `hyper-client-simulator headless` so simulator participants can be started from CLI arguments without entering the TUI or saving runtime options back to the app config.
 
-**Architecture:** Keep the TUI path unchanged. Add a headless runner in the root binary that loads persisted config plus global defaults, overlays command-line settings, overlays each `--participant` JSON object on top of that, spawns participants through `ParticipantStore`, streams tracing output to standard streams, and coordinates graceful/forced shutdown.
+**Architecture:** Keep headless behavior local to the root binary. Load the existing `Config` once through the current config path, apply typed CLI overrides in memory, clone that config per participant, apply each participant JSON override in memory, spawn participants through `ParticipantStore`, and handle shutdown with a small `tokio::select!` loop.
 
-**Tech Stack:** Rust 2021, `clap`, `serde`, `serde_json`, `config`, `tokio`, `tracing-subscriber`, existing `client-simulator-config` and `client-simulator-browser` crates.
+**Tech Stack:** Rust 2021, `clap`, `serde`, `serde_json`, `tokio`, `tracing-subscriber`, existing `client-simulator-config` and `client-simulator-browser` crates.
 
 ---
 
-## Design Decisions
+## Scope
 
-- `headless` means "no TUI". It should not implicitly persist settings. It should respect the existing browser `headless` config value unless `--headless true|false` or a participant JSON `{"headless": true}` overrides it.
-- If no `--participant` argument is supplied, start one participant using the global effective config. If one or more `--participant` values are supplied, start exactly one participant per JSON object.
-- Participant JSON supports the same launch-time fields exposed as global headless CLI overrides: `url`, `backend`, `headless`, `audio_enabled`, `video_enabled`, `screenshare_enabled`, `auto_gain_control`, `noise_suppression`, `transport`, `resolution`, `blur`, plus nested `cloudflare` and `device_farm`.
-- Unknown participant JSON fields fail fast. This prevents silent typos such as `audio_enable`.
-- The first `Ctrl-C` calls `ParticipantStore::shutdown_all().await`. A second `Ctrl-C` returns a forced-exit result to `main`, which exits with code `130`.
-- Logging uses a normal `tracing_subscriber` fmt subscriber, not `tui_logger`. Warnings and errors go to stderr; info/debug/trace go to stdout.
+Initial participant JSON supports stable launch fields:
 
-## File Structure
+- `url`
+- `backend`
+- `headless`
+- `audio_enabled`
+- `video_enabled`
+- `screenshare_enabled`
+- `auto_gain_control`
+- `noise_suppression`
+- `transport`
+- `resolution`
+- `blur`
 
-- Modify `Cargo.toml`: add root-crate dependency on `serde` because the binary will derive `Deserialize` for participant JSON.
-- Modify `config/src/args.rs`: add `HeadlessConfigArgs`, a `config::Source` implementation, and tests for override collection.
-- Modify `config/src/lib.rs`: re-export `HeadlessConfigArgs`, factor config loading into a generic helper, and add `Config::new_headless`.
-- Create `src/headless.rs`: own headless CLI args, participant JSON parsing, config layering, logging initialization, participant spawning, and shutdown orchestration.
-- Modify `src/main.rs`: add the `headless` subcommand and route it to `headless::run`.
+Nested backend service configs such as `cloudflare` and `device_farm` stay out of the initial implementation. Existing app config/global defaults still provide those values. Add nested per-participant backend overrides later only if a concrete workflow needs them.
+
+If no `--participant` is supplied, start one participant using the global effective config. If one or more `--participant` values are supplied, start exactly one participant per JSON object.
 
 ---
 
-### Task 1: Add Headless Config Overrides
+### Task 1: Add Headless CLI Types and Override Logic
 
 **Files:**
-- Modify: `config/src/args.rs`
-- Modify: `config/src/lib.rs`
-
-- [ ] **Step 1: Write config argument tests**
-
-Add these tests to `config/src/args.rs` under the existing module content:
-
-```rust
-#[cfg(test)]
-mod tests {
-    use super::HeadlessConfigArgs;
-    use config::Source as _;
-
-    #[test]
-    fn headless_args_collect_only_present_values() {
-        let args = HeadlessConfigArgs {
-            debug: 2,
-            url: Some("https://example.com/space/demo".to_string()),
-            backend: Some("cloudflare".to_string()),
-            audio_enabled: Some(false),
-            video_enabled: None,
-            screenshare_enabled: Some(true),
-            auto_gain_control: None,
-            noise_suppression: Some("rnnoise".to_string()),
-            transport: Some("webrtc".to_string()),
-            resolution: Some("p720".to_string()),
-            blur: Some(true),
-            headless: Some(true),
-        };
-
-        let values = args.collect().expect("collect headless args");
-
-        assert_eq!(values.get("debug").unwrap().clone().into_int().unwrap(), 2);
-        assert_eq!(values.get("url").unwrap().clone().into_string().unwrap(), "https://example.com/space/demo");
-        assert_eq!(values.get("backend").unwrap().clone().into_string().unwrap(), "cloudflare");
-        assert!(!values.get("audio_enabled").unwrap().clone().into_bool().unwrap());
-        assert!(values.get("screenshare_enabled").unwrap().clone().into_bool().unwrap());
-        assert_eq!(values.get("noise_suppression").unwrap().clone().into_string().unwrap(), "rnnoise");
-        assert_eq!(values.get("transport").unwrap().clone().into_string().unwrap(), "webrtc");
-        assert_eq!(values.get("resolution").unwrap().clone().into_string().unwrap(), "p720");
-        assert!(values.get("blur").unwrap().clone().into_bool().unwrap());
-        assert!(values.get("headless").unwrap().clone().into_bool().unwrap());
-        assert!(!values.contains_key("video_enabled"));
-        assert!(!values.contains_key("auto_gain_control"));
-    }
-}
-```
-
-- [ ] **Step 2: Run the targeted config test and verify it fails**
+- Modify: `Cargo.toml`
+- Create: `src/headless.rs`
 
-Run:
+1. Add root-crate dependencies if missing:
 
-```bash
-cargo test -p client-simulator-config headless_args_collect_only_present_values
+```toml
+serde.workspace = true
 ```
 
-Expected: compile failure because `HeadlessConfigArgs` does not exist.
+2. Create `src/headless.rs` with headless args, participant JSON overrides, and direct apply helpers.
 
-- [ ] **Step 3: Implement `HeadlessConfigArgs`**
-
-Add this to `config/src/args.rs` after `TuiArgs`:
+Use typed fields. Prefer clap parsers that accept the intended UX:
 
 ```rust
-/// Non-TUI participant launch options.
-#[derive(clap::Args, Default, Debug, Clone)]
-pub struct HeadlessConfigArgs {
-    /// Verbosity level, set from the parent command.
-    #[clap(skip)]
-    pub debug: u8,
-
-    /// URL of the hyper.video session.
+#[derive(clap::Args, Debug, Clone, Default)]
+pub struct HeadlessArgs {
     #[clap(long, value_name = "URL")]
-    pub url: Option<String>,
+    pub url: Option<url::Url>,
 
-    /// Participant backend: local, cloudflare, remote-stub, or aws-device-farm.
     #[clap(long, value_name = "BACKEND")]
-    pub backend: Option<String>,
+    pub backend: Option<client_simulator_config::ParticipantBackendKind>,
 
-    /// Enable or disable browser headless mode.
-    #[clap(long = "headless", action)]
+    #[clap(long = "headless", value_parser = clap::builder::BoolishValueParser::new())]
     pub headless: Option<bool>,
 
-    /// Enable or disable participant audio.
-    #[clap(long = "audio-enabled", action)]
+    #[clap(long = "audio-enabled", value_parser = clap::builder::BoolishValueParser::new())]
     pub audio_enabled: Option<bool>,
 
-    /// Enable or disable participant video.
-    #[clap(long = "video-enabled", action)]
+    #[clap(long = "video-enabled", value_parser = clap::builder::BoolishValueParser::new())]
     pub video_enabled: Option<bool>,
 
-    /// Enable or disable participant screenshare.
-    #[clap(long = "screenshare-enabled", action)]
+    #[clap(long = "screenshare-enabled", value_parser = clap::builder::BoolishValueParser::new())]
     pub screenshare_enabled: Option<bool>,
 
-    /// Enable or disable browser auto gain control.
-    #[clap(long = "auto-gain-control", action)]
+    #[clap(long = "auto-gain-control", value_parser = clap::builder::BoolishValueParser::new())]
     pub auto_gain_control: Option<bool>,
 
-    /// Noise suppression model.
     #[clap(long = "noise-suppression", value_name = "MODEL")]
-    pub noise_suppression: Option<String>,
+    pub noise_suppression: Option<client_simulator_config::NoiseSuppression>,
 
-    /// Transport mode: webtransport or webrtc.
     #[clap(long, value_name = "MODE")]
-    pub transport: Option<String>,
+    pub transport: Option<client_simulator_config::TransportMode>,
 
-    /// Webcam resolution, such as auto, p720, or p1080.
     #[clap(long, value_name = "RESOLUTION")]
-    pub resolution: Option<String>,
+    pub resolution: Option<client_simulator_config::WebcamResolution>,
 
-    /// Enable or disable background blur.
-    #[clap(long, action)]
+    #[clap(long, value_parser = clap::builder::BoolishValueParser::new())]
     pub blur: Option<bool>,
+
+    #[clap(long = "participant", value_name = "JSON")]
+    pub participants: Vec<String>,
 }
 ```
 
-Then add a `config::Source` implementation parallel to `TuiArgs`, inserting only `Some` values and inserting `debug` only when it is greater than zero.
-
-- [ ] **Step 4: Re-export and add a non-TUI config constructor**
-
-In `config/src/lib.rs`, change:
-
-```rust
-pub use args::TuiArgs;
-```
+If one of the config enums does not satisfy clap's `FromStr` bounds cleanly, keep that field as `Option<String>` and parse it with the enum's existing `FromStr` implementation inside `apply_cli_overrides`, returning an `eyre` error with the flag name.
 
-to:
+3. Add the participant override type:
 
 ```rust
-pub use args::{
-    HeadlessConfigArgs,
-    TuiArgs,
-};
+#[derive(Debug, Clone, Default, serde::Deserialize)]
+#[serde(default, deny_unknown_fields)]
+struct ParticipantOverride {
+    url: Option<url::Url>,
+    backend: Option<client_simulator_config::ParticipantBackendKind>,
+    headless: Option<bool>,
+    audio_enabled: Option<bool>,
+    video_enabled: Option<bool>,
+    screenshare_enabled: Option<bool>,
+    auto_gain_control: Option<bool>,
+    noise_suppression: Option<client_simulator_config::NoiseSuppression>,
+    transport: Option<client_simulator_config::TransportMode>,
+    resolution: Option<client_simulator_config::WebcamResolution>,
+    blur: Option<bool>,
+}
 ```
 
-Refactor `Config::new` so both TUI and headless loading share the same source order:
+4. Add direct override helpers:
 
 ```rust
-impl Config {
-    pub fn new(args: TuiArgs) -> Result<Self, config::ConfigError> {
-        Self::load_with_overrides(args)
+fn apply_cli_overrides(config: &mut client_simulator_config::Config, args: &HeadlessArgs) {
+    if let Some(url) = &args.url {
+        config.url = Some(url.clone());
     }
-
-    pub fn new_headless(args: HeadlessConfigArgs) -> Result<Self, config::ConfigError> {
-        Self::load_with_overrides(args)
+    if let Some(backend) = args.backend {
+        config.backend = backend;
     }
+    if let Some(headless) = args.headless {
+        config.headless = headless;
+    }
+    if let Some(audio_enabled) = args.audio_enabled {
+        config.audio_enabled = audio_enabled;
+    }
+    if let Some(video_enabled) = args.video_enabled {
+        config.video_enabled = video_enabled;
+    }
+    if let Some(screenshare_enabled) = args.screenshare_enabled {
+        config.screenshare_enabled = screenshare_enabled;
+    }
+    if let Some(auto_gain_control) = args.auto_gain_control {
+        config.auto_gain_control = auto_gain_control;
+    }
+    if let Some(noise_suppression) = args.noise_suppression {
+        config.noise_suppression = noise_suppression;
+    }
+    if let Some(transport) = args.transport {
+        config.transport = transport;
+    }
+    if let Some(resolution) = args.resolution {
+        config.resolution = resolution;
+    }
+    if let Some(blur) = args.blur {
+        config.blur = blur;
+    }
+}
 
-    fn load_with_overrides<S>(overrides: S) -> Result<Self, config::ConfigError>
-    where
-        S: config::Source + Send + Sync + 'static,
-    {
-        let data_dir = get_data_dir();
-        let config_dir = get_config_dir();
-        let mut builder = config::Config::builder()
-            .set_default("data_dir", data_dir.to_str().unwrap())?
-            .set_default("config_dir", config_dir.to_str().unwrap())?;
-
-        builder = builder.add_source(Config::default());
-
-        let config_files = [("config.yaml", config::FileFormat::Yaml)];
-
-        for (file, format) in &config_files {
-            let source = config::File::from(config_dir.join(file))
-                .format(*format)
-                .required(false);
-            builder = builder.add_source(source);
-        }
-
-        builder = builder.add_source(overrides);
-
-        builder.build()?.try_deserialize()
+fn apply_participant_override(
+    mut config: client_simulator_config::Config,
+    override_: ParticipantOverride,
+) -> client_simulator_config::Config {
+    if let Some(url) = override_.url {
+        config.url = Some(url);
+    }
+    if let Some(backend) = override_.backend {
+        config.backend = backend;
+    }
+    if let Some(headless) = override_.headless {
+        config.headless = headless;
+    }
+    if let Some(audio_enabled) = override_.audio_enabled {
+        config.audio_enabled = audio_enabled;
+    }
+    if let Some(video_enabled) = override_.video_enabled {
+        config.video_enabled = video_enabled;
+    }
+    if let Some(screenshare_enabled) = override_.screenshare_enabled {
+        config.screenshare_enabled = screenshare_enabled;
+    }
+    if let Some(auto_gain_control) = override_.auto_gain_control {
+        config.auto_gain_control = auto_gain_control;
+    }
+    if let Some(noise_suppression) = override_.noise_suppression {
+        config.noise_suppression = noise_suppression;
     }
+    if let Some(transport) = override_.transport {
+        config.transport = transport;
+    }
+    if let Some(resolution) = override_.resolution {
+        config.resolution = resolution;
+    }
+    if let Some(blur) = override_.blur {
+        config.blur = blur;
+    }
+    config
 }
 ```
 
-- [ ] **Step 5: Run config tests**
-
-Run:
-
-```bash
-cargo test -p client-simulator-config
-```
+5. Add focused tests in `src/headless.rs`:
 
-Expected: all config crate tests pass.
+- CLI parsing accepts the user-shaped command with repeated `--participant`.
+- CLI bool options accept explicit values, for example `--headless false`.
+- participant JSON overrides global config.
+- unknown participant JSON field returns an error.
+- empty participant list returns one effective config.
 
-- [ ] **Step 6: Commit**
+Run:
 
 ```bash
-git add config/src/args.rs config/src/lib.rs
-git commit -m "feat: add headless config overrides"
+cargo test -p hyper-client-simulator headless
 ```
 
 ---
 
-### Task 2: Add Participant JSON Overlay Logic
+### Task 2: Implement the Headless Runner
 
 **Files:**
-- Modify: `Cargo.toml`
-- Create: `src/headless.rs`
-
-- [ ] **Step 1: Add serde to the root crate**
-
-In the root `Cargo.toml`, add:
-
-```toml
-serde.workspace = true
-```
+- Modify: `src/headless.rs`
 
-- [ ] **Step 2: Write participant overlay tests**
+1. Add `run(args, debug) -> eyre::Result<i32>`.
 
-Create `src/headless.rs` with the test module first:
+Implementation shape:
 
 ```rust
-use client_simulator_config::{
-    CloudflareConfig,
-    Config,
-    DeviceFarmConfig,
-    HeadlessConfigArgs,
-    NoiseSuppression,
-    ParticipantBackendKind,
-    TransportMode,
-    WebcamResolution,
-};
-use eyre::{
-    Context as _,
-    Result,
-};
-use serde::Deserialize;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use url::Url;
-
-    #[test]
-    fn participant_json_overrides_global_config() {
-        let global = Config {
-            url: Some(Url::parse("https://example.com/global").unwrap()),
-            backend: ParticipantBackendKind::Local,
-            audio_enabled: true,
-            video_enabled: true,
-            transport: TransportMode::WebTransport,
-            ..Default::default()
-        };
-
-        let participant = parse_participant_override(
-            r#"{
-                "url": "https://example.com/participant",
-                "backend": "cloudflare",
-                "audio_enabled": false,
-                "transport": "webrtc",
-                "resolution": "p720",
-                "blur": true
-            }"#,
-        )
-        .expect("valid participant json");
-
-        let effective = participant.apply_to(global);
-
-        assert_eq!(effective.url.unwrap().as_str(), "https://example.com/participant");
-        assert_eq!(effective.backend, ParticipantBackendKind::Cloudflare);
-        assert!(!effective.audio_enabled);
-        assert!(effective.video_enabled);
-        assert_eq!(effective.transport, TransportMode::WebRTC);
-        assert_eq!(effective.resolution, WebcamResolution::P720);
-        assert!(effective.blur);
-    }
+pub async fn run(args: HeadlessArgs, debug: u8) -> eyre::Result<i32> {
+    init_logging(debug)?;
 
-    #[test]
-    fn empty_participant_list_starts_one_default_participant() {
-        let global = Config {
-            url: Some(Url::parse("https://example.com/global").unwrap()),
-            audio_enabled: true,
-            ..Default::default()
-        };
+    let mut global_config = client_simulator_config::Config::new(client_simulator_config::TuiArgs::default())?;
+    apply_cli_overrides(&mut global_config, &args);
 
-        let configs = participant_configs(global, &[]).expect("participant configs");
+    let participant_configs = build_participant_configs(global_config.clone(), &args.participants)?;
+    let store = client_simulator_browser::participant::ParticipantStore::new(global_config.data_dir());
 
-        assert_eq!(configs.len(), 1);
-        assert_eq!(configs[0].url.as_ref().unwrap().as_str(), "https://example.com/global");
-        assert!(configs[0].audio_enabled);
+    for config in &participant_configs {
+        store.spawn(config)?;
     }
 
-    #[test]
-    fn unknown_participant_json_field_is_rejected() {
-        let err = parse_participant_override(r#"{"audio_enable": false}"#).unwrap_err();
-
-        assert!(format!("{err:?}").contains("audio_enable"));
-    }
+    Ok(wait_for_exit(store).await)
 }
 ```
 
-- [ ] **Step 3: Run the overlay tests and verify they fail**
+This uses the existing config/default loading path but never calls `Config::save()` or `Config::update_from_args()`.
 
-Run:
-
-```bash
-cargo test participant_json_overrides_global_config empty_participant_list_starts_one_default_participant unknown_participant_json_field_is_rejected
-```
-
-Expected: compile failure because the tested functions and types do not exist.
-
-- [ ] **Step 4: Implement participant overlay types**
-
-Add this implementation above the tests in `src/headless.rs`:
+2. Add `build_participant_configs`:
 
 ```rust
-#[derive(clap::Args, Debug, Clone, Default)]
-pub struct HeadlessArgs {
-    #[command(flatten)]
-    pub config: HeadlessConfigArgs,
-
-    /// Participant-specific JSON overrides. Repeat this flag to start multiple participants.
-    #[clap(long = "participant", value_name = "JSON")]
-    pub participants: Vec<String>,
-}
-
-#[derive(Debug, Clone, Default, Deserialize)]
-#[serde(default, deny_unknown_fields)]
-struct ParticipantOverride {
-    url: Option<url::Url>,
-    backend: Option<ParticipantBackendKind>,
-    cloudflare: Option<CloudflareConfig>,
-    device_farm: Option<DeviceFarmConfig>,
-    headless: Option<bool>,
-    audio_enabled: Option<bool>,
-    video_enabled: Option<bool>,
-    screenshare_enabled: Option<bool>,
-    auto_gain_control: Option<bool>,
-    noise_suppression: Option<NoiseSuppression>,
-    transport: Option<TransportMode>,
-    resolution: Option<WebcamResolution>,
-    blur: Option<bool>,
-}
-
-impl ParticipantOverride {
-    fn apply_to(&self, mut config: Config) -> Config {
-        if let Some(url) = &self.url {
-            config.url = Some(url.clone());
-        }
-        if let Some(backend) = self.backend {
-            config.backend = backend;
-        }
-        if let Some(cloudflare) = &self.cloudflare {
-            config.cloudflare = cloudflare.clone();
-        }
-        if let Some(device_farm) = &self.device_farm {
-            config.device_farm = device_farm.clone();
-        }
-        if let Some(headless) = self.headless {
-            config.headless = headless;
-        }
-        if let Some(audio_enabled) = self.audio_enabled {
-            config.audio_enabled = audio_enabled;
-        }
-        if let Some(video_enabled) = self.video_enabled {
-            config.video_enabled = video_enabled;
-        }
-        if let Some(screenshare_enabled) = self.screenshare_enabled {
-            config.screenshare_enabled = screenshare_enabled;
-        }
-        if let Some(auto_gain_control) = self.auto_gain_control {
-            config.auto_gain_control = auto_gain_control;
-        }
-        if let Some(noise_suppression) = self.noise_suppression {
-            config.noise_suppression = noise_suppression;
-        }
-        if let Some(transport) = self.transport {
-            config.transport = transport;
-        }
-        if let Some(resolution) = self.resolution {
-            config.resolution = resolution;
-        }
-        if let Some(blur) = self.blur {
-            config.blur = blur;
-        }
-        config
-    }
-}
-
-fn parse_participant_override(json: &str) -> Result<ParticipantOverride> {
-    serde_json::from_str(json).wrap_err_with(|| format!("Failed to parse --participant JSON: {json}"))
-}
-
-fn participant_configs(global_config: Config, participant_json: &[String]) -> Result<Vec<Config>> {
-    if participant_json.is_empty() {
+fn build_participant_configs(
+    global_config: client_simulator_config::Config,
+    participants: &[String],
+) -> eyre::Result<Vec<client_simulator_config::Config>> {
+    if participants.is_empty() {
         return Ok(vec![global_config]);
     }
 
-    participant_json
+    participants
         .iter()
-        .map(|json| parse_participant_override(json).map(|participant| participant.apply_to(global_config.clone())))
+        .map(|json| {
+            let override_: ParticipantOverride = serde_json::from_str(json)?;
+            Ok(apply_participant_override(global_config.clone(), override_))
+        })
         .collect()
 }
 ```
 
-- [ ] **Step 5: Run the overlay tests**
+Wrap JSON errors with context containing `--participant` so invalid input is easy to diagnose.
 
-Run:
-
-```bash
-cargo test participant_json_overrides_global_config empty_participant_list_starts_one_default_participant unknown_participant_json_field_is_rejected
-```
-
-Expected: all three tests pass.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add Cargo.toml src/headless.rs
-git commit -m "feat: parse headless participant overrides"
-```
-
----
-
-### Task 3: Implement Headless Runtime and Shutdown Semantics
-
-**Files:**
-- Modify: `src/headless.rs`
-
-- [ ] **Step 1: Write shutdown behavior tests**
-
-Add these tests to the existing test module in `src/headless.rs`:
+3. Add logging with normal `tracing_subscriber`, not `tui_logger`:
 
 ```rust
-use client_simulator_browser::participant::ParticipantStore;
-use std::{
-    fs,
-    path::PathBuf,
-    time::{
-        SystemTime,
-        UNIX_EPOCH,
-    },
-};
-use tokio::sync::oneshot;
-
-#[tokio::test]
-async fn shutdown_wait_returns_clean_when_participants_stop() {
-    let store = ParticipantStore::new(unique_test_data_dir());
-    let config = Config {
-        url: Some(Url::parse("https://example.com/lite/demo").unwrap()),
-        backend: ParticipantBackendKind::RemoteStub,
-        ..Default::default()
-    };
-    store.spawn(&config).expect("spawn participant");
-
-    let (first_tx, first_rx) = oneshot::channel::<()>();
-    let (_second_tx, second_rx) = oneshot::channel::<()>();
-    let store_for_shutdown = store.clone();
-
-    tokio::spawn(async move {
-        first_tx.send(()).expect("send first shutdown signal");
-    });
-
-    let result = wait_for_headless_exit(
-        store_for_shutdown,
-        async move {
-            let _ = first_rx.await;
+fn init_logging(debug: u8) -> eyre::Result<()> {
+    use tracing_subscriber::{
+        fmt::{
+            self,
+            writer::MakeWriterExt as _,
         },
-        || async move {
-            let _ = second_rx.await;
-        },
-    )
-    .await;
-
-    assert_eq!(result, HeadlessExit::Clean);
-    assert!(store.is_empty());
-}
-
-#[tokio::test]
-async fn second_shutdown_signal_returns_forced() {
-    let store = ParticipantStore::new(unique_test_data_dir());
-    let config = Config {
-        url: Some(Url::parse("https://example.com/lite/demo").unwrap()),
-        backend: ParticipantBackendKind::RemoteStub,
-        ..Default::default()
+        prelude::*,
+        EnvFilter,
     };
-    store.spawn(&config).expect("spawn participant");
 
-    let (first_tx, first_rx) = oneshot::channel::<()>();
-    let (second_tx, second_rx) = oneshot::channel::<()>();
-
-    tokio::spawn(async move {
-        first_tx.send(()).expect("send first shutdown signal");
-        second_tx.send(()).expect("send second shutdown signal");
-    });
-
-    let result = wait_for_headless_exit(
-        store,
-        async move {
-            let _ = first_rx.await;
-        },
-        || async move {
-            let _ = second_rx.await;
-        },
-    )
-    .await;
+    let filter = match debug {
+        0 => "info",
+        1 => "debug",
+        _ => "trace",
+    };
+    let writer = std::io::stderr
+        .with_min_level(tracing::Level::WARN)
+        .or_else(std::io::stdout);
 
-    assert_eq!(result, HeadlessExit::Forced);
-}
+    tracing_subscriber::registry()
+        .with(tracing_error::ErrorLayer::default())
+        .with(fmt::layer().with_writer(writer).with_filter(EnvFilter::builder().parse_lossy(filter)))
+        .try_init()?;
 
-fn unique_test_data_dir() -> PathBuf {
-    let timestamp = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .expect("current time")
-        .as_nanos();
-    let path = std::env::temp_dir().join(format!("hyper-browser-simulator-headless-test-{timestamp}"));
-    fs::create_dir_all(&path).expect("create test data dir");
-    path
+    Ok(())
 }
 ```
 
-- [ ] **Step 2: Run the shutdown tests and verify they fail**
-
-Run:
-
-```bash
-cargo test shutdown_wait_returns_clean_when_participants_stop second_shutdown_signal_returns_forced
-```
-
-Expected: compile failure because `HeadlessExit` and `wait_for_headless_exit` do not exist.
-
-- [ ] **Step 3: Implement runtime entry points**
-
-Add this to `src/headless.rs`:
+4. Add shutdown behavior:
 
 ```rust
-use client_simulator_browser::participant::ParticipantStore;
-use std::{
-    future::Future,
-};
-use tracing_subscriber::{
-    fmt::{
-        self,
-        writer::MakeWriterExt as _,
-    },
-    prelude::*,
-    registry,
-    EnvFilter,
-};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum HeadlessExit {
-    Clean,
-    Forced,
-}
-
-pub async fn run(mut args: HeadlessArgs, debug: u8) -> Result<i32> {
-    args.config.debug = debug;
-    init_headless_logging(debug)?;
-
-    let global_config = Config::new_headless(args.config).context("Failed to create headless config")?;
-    let participant_configs = participant_configs(global_config.clone(), &args.participants)?;
-    let store = ParticipantStore::new(global_config.data_dir());
-
-    for config in &participant_configs {
-        store
-            .spawn(config)
-            .wrap_err_with(|| format!("Failed to spawn participant with backend {}", config.backend))?;
+async fn wait_for_exit(store: client_simulator_browser::participant::ParticipantStore) -> i32 {
+    tokio::select! {
+        _ = wait_for_all_stopped(&store) => 0,
+        _ = wait_for_ctrl_c() => {
+            tracing::info!("Shutting down participants. Press Ctrl-C again to force exit.");
+            tokio::select! {
+                _ = store.shutdown_all() => 0,
+                _ = wait_for_ctrl_c() => 130,
+            }
+        }
     }
-
-    let exit = wait_for_headless_exit(store, wait_for_ctrl_c(), wait_for_ctrl_c).await;
-
-    Ok(match exit {
-        HeadlessExit::Clean => 0,
-        HeadlessExit::Forced => 130,
-    })
-}
-
-fn init_headless_logging(debug: u8) -> Result<()> {
-    let filter = match debug {
-        0 => "info",
-        1 => "debug",
-        _ => "trace",
-    };
-    let env_filter = EnvFilter::builder().parse_lossy(filter);
-    let writer = std::io::stderr.with_min_level(tracing::Level::WARN).or_else(std::io::stdout);
-
-    registry()
-        .with(tracing_error::ErrorLayer::default())
-        .with(fmt::layer().with_writer(writer).with_filter(env_filter))
-        .try_init()
-        .context("Failed to initialize headless logging")
 }
 
 async fn wait_for_ctrl_c() {
@@ -623,130 +312,41 @@ async fn wait_for_ctrl_c() {
     }
 }
 
-async fn wait_for_headless_exit<F1, F2, SecondShutdown>(
-    store: ParticipantStore,
-    first_shutdown: F1,
-    second_shutdown: SecondShutdown,
-) -> HeadlessExit
-where
-    F1: Future<Output = ()>,
-    SecondShutdown: FnOnce() -> F2,
-    F2: Future<Output = ()>,
-{
-    tokio::pin!(first_shutdown);
-
-    let mut state_receivers = store
+async fn wait_for_all_stopped(store: &client_simulator_browser::participant::ParticipantStore) {
+    let mut states = store
         .values()
         .into_iter()
         .map(|participant| participant.state.clone())
         .collect::<Vec<_>>();
 
-    let all_stopped = async move {
-        for state in &mut state_receivers {
-            let _ = state.wait_for(|current| !current.running).await;
-        }
-    };
-    tokio::pin!(all_stopped);
-
-    tokio::select! {
-        _ = &mut all_stopped => HeadlessExit::Clean,
-        _ = &mut first_shutdown => {
-            let shutdown = store.shutdown_all();
-            let second_shutdown = second_shutdown();
-            tokio::pin!(shutdown);
-            tokio::pin!(second_shutdown);
-            tokio::select! {
-                _ = &mut shutdown => HeadlessExit::Clean,
-                _ = &mut second_shutdown => HeadlessExit::Forced,
-            }
-        }
+    for state in &mut states {
+        let _ = state.wait_for(|current| !current.running).await;
     }
 }
 ```
 
-- [ ] **Step 4: Run the shutdown tests**
+5. Add a small pure shutdown-coordination test if desired. Do not spawn local Chromium in unit tests. Use injected futures or channels to verify "first signal starts shutdown" and "second signal returns 130".
 
 Run:
 
 ```bash
-cargo test shutdown_wait_returns_clean_when_participants_stop second_shutdown_signal_returns_forced
-```
-
-Expected: both tests pass.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add src/headless.rs
-git commit -m "feat: add headless runner shutdown handling"
+cargo test -p hyper-client-simulator headless
 ```
 
 ---
 
-### Task 4: Wire the CLI Command
+### Task 3: Wire the Command in `main`
 
 **Files:**
 - Modify: `src/main.rs`
-- Modify: `src/headless.rs`
-
-- [ ] **Step 1: Write CLI parsing tests**
-
-Add this test module to `src/main.rs`:
-
-```rust
-#[cfg(test)]
-mod tests {
-    use super::{
-        CliArgs,
-        Command,
-    };
-    use clap::Parser as _;
-
-    #[test]
-    fn parses_headless_command_with_repeated_participants() {
-        let args = CliArgs::parse_from([
-            "hyper-client-simulator",
-            "--debug",
-            "headless",
-            "--url",
-            "https://latest.dev.hyper.video/F27-T5F-DXY",
-            "--participant",
-            r#"{"audio_enabled": false, "backend": "local"}"#,
-            "--participant",
-            r#"{"audio_enabled": true, "backend": "cloudflare"}"#,
-        ]);
-
-        match args.command {
-            Some(Command::Headless(headless)) => {
-                assert_eq!(args.debug, 1);
-                assert_eq!(headless.config.url.as_deref(), Some("https://latest.dev.hyper.video/F27-T5F-DXY"));
-                assert_eq!(headless.participants.len(), 2);
-            }
-            other => panic!("expected headless command, got {other:?}"),
-        }
-    }
-}
-```
-
-- [ ] **Step 2: Run the CLI parsing test and verify it fails**
-
-Run:
-
-```bash
-cargo test parses_headless_command_with_repeated_participants
-```
 
-Expected: compile failure because `headless` is not a module and `Command::Headless` does not exist.
-
-- [ ] **Step 3: Wire `headless` into `main.rs`**
-
-At the top of `src/main.rs`, add:
+1. Add the module:
 
 ```rust
 mod headless;
 ```
 
-Extend `Command`:
+2. Add the subcommand:
 
 ```rust
 #[derive(Subcommand, Debug)]
@@ -760,90 +360,80 @@ enum Command {
 }
 ```
 
-Derive `Debug` for `CliArgs` if the test needs it:
+3. Route the command:
 
 ```rust
-#[derive(Parser, Debug)]
+Some(Command::Headless(args)) => {
+    let code = headless::run(args, debug).await?;
+    std::process::exit(code);
+}
 ```
 
-Route the command in `main`:
+4. Add or keep a CLI parsing test proving the example shape works:
 
 ```rust
-        Some(Command::Headless(args)) => {
-            let code = headless::run(args, debug).await?;
-            std::process::exit(code);
+#[test]
+fn parses_headless_command_with_repeated_participants() {
+    let args = CliArgs::parse_from([
+        "hyper-client-simulator",
+        "--debug",
+        "headless",
+        "--url",
+        "https://latest.dev.hyper.video/F27-T5F-DXY",
+        "--participant",
+        r#"{"audio_enabled": false, "backend": "local"}"#,
+        "--participant",
+        r#"{"audio_enabled": true, "backend": "cloudflare"}"#,
+    ]);
+
+    match args.command {
+        Some(Command::Headless(headless)) => {
+            assert_eq!(args.debug, 1);
+            assert_eq!(headless.url.as_ref().map(url::Url::as_str), Some("https://latest.dev.hyper.video/F27-T5F-DXY"));
+            assert_eq!(headless.participants.len(), 2);
         }
+        other => panic!("expected headless command, got {other:?}"),
+    }
+}
 ```
 
-- [ ] **Step 4: Run the CLI parsing test**
-
-Run:
-
-```bash
-cargo test parses_headless_command_with_repeated_participants
-```
-
-Expected: the test passes.
-
-- [ ] **Step 5: Run a smoke test with the remote stub backend**
-
 Run:
 
 ```bash
-cargo run -- headless \
-  --url "https://example.com/lite/demo" \
-  --participant '{"backend": "remote-stub", "audio_enabled": false}'
-```
-
-Expected: the process starts, logs appear in the terminal, pressing `Ctrl-C` once shuts down the participant and exits. Run it a second time, press `Ctrl-C` twice quickly, and verify the process exits with code `130`.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/main.rs src/headless.rs
-git commit -m "feat: add headless cli command"
+cargo test -p hyper-client-simulator parses_headless_command_with_repeated_participants
 ```
 
 ---
 
-### Task 5: Full Verification
+### Task 4: Verify End to End
 
 **Files:**
 - No new files.
 
-- [ ] **Step 1: Format**
-
-Run:
+Run formatting, linting, and tests:
 
 ```bash
 just fmt
-```
-
-Expected: formatting completes without errors.
-
-- [ ] **Step 2: Lint**
-
-Run:
-
-```bash
 just clippy
+just test
 ```
 
-Expected: clippy completes with no warnings.
-
-- [ ] **Step 3: Test**
-
-Run:
+Manual smoke test with a backend that does not require Chromium:
 
 ```bash
-just test
+cargo run -- headless \
+  --url "https://example.com/lite/demo" \
+  --participant '{"backend": "remote-stub", "audio_enabled": false}'
 ```
 
-Expected: all tests pass.
+Expected:
 
-- [ ] **Step 4: Manual command check**
+- logs print in the terminal without entering TUI mode
+- no config file is written from CLI overrides
+- first `Ctrl-C` starts participant shutdown and exits cleanly
+- second `Ctrl-C` exits with code `130`
 
-Run:
+Manual example matching the requested command shape:
 
 ```bash
 cargo run -- headless \
@@ -852,23 +442,19 @@ cargo run -- headless \
   --participant '{"audio_enabled": true, "backend": "cloudflare"}'
 ```
 
-Expected: two participants are created, logs stream to the terminal, the app does not enter TUI mode, no config file is written as a result of the command-line overrides, one `Ctrl-C` starts clean shutdown, and a second `Ctrl-C` exits immediately with code `130`.
-
-- [ ] **Step 5: Commit verification fixes if any were needed**
-
-If formatting, linting, or tests required changes:
-
-```bash
-git add Cargo.toml config/src/args.rs config/src/lib.rs src/headless.rs src/main.rs
-git commit -m "fix: verify headless command"
-```
+Expected:
 
-Skip this commit if no files changed during verification.
+- two participants start
+- each participant receives the global URL
+- each participant JSON overrides its own audio/backend settings
+- logs stream to stdout/stderr through tracing
 
 ---
 
-## Self-Review
+## Non-Goals
 
-- Spec coverage: The plan covers the new `headless` command, no config persistence, config/default loading, global CLI overrides, per-participant JSON overrides with highest priority, stdout/stderr tracing, graceful shutdown on first `Ctrl-C`, and forced exit on second `Ctrl-C`.
-- Placeholder scan: No incomplete implementation steps remain; tests, commands, expected results, file paths, and concrete code shapes are provided.
-- Type consistency: `HeadlessConfigArgs`, `HeadlessArgs`, `ParticipantOverride`, `HeadlessExit`, and `wait_for_headless_exit` are introduced before they are used by later tasks.
+- No TUI changes.
+- No config crate changes unless implementation proves a small `Config::load()` helper is necessary.
+- No config persistence from `headless`.
+- No nested per-participant `cloudflare` or `device_farm` overrides in the first version.
+- No broad refactor of participant spawning or logging.

From 682eb922aa040b8e5968d6104adf37b0d10f0f02 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Tue, 2 Jun 2026 11:30:35 +0200
Subject: [PATCH 19/42] headless mode

---
 Cargo.lock      |   1 +
 Cargo.toml      |   1 +
 src/headless.rs | 466 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/main.rs     |  41 ++++-
 4 files changed, 508 insertions(+), 1 deletion(-)
 create mode 100644 src/headless.rs

diff --git a/Cargo.lock b/Cargo.lock
index 32e8055..208152b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1939,6 +1939,7 @@ dependencies = [
  "eyre",
  "human-panic",
  "libc",
+ "serde",
  "serde_json",
  "strip-ansi-escapes",
  "tokio",
diff --git a/Cargo.toml b/Cargo.toml
index 87345c9..30cba67 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -90,6 +90,7 @@ eyre.workspace = true
 human-panic.workspace = true
 libc.workspace = true
 serde_json.workspace = true
+serde.workspace = true
 strip-ansi-escapes.workspace = true
 tokio.workspace = true
 tracing.workspace = true
diff --git a/src/headless.rs b/src/headless.rs
new file mode 100644
index 0000000..6bef39d
--- /dev/null
+++ b/src/headless.rs
@@ -0,0 +1,466 @@
+use clap::Args;
+use client_simulator_config::{
+    Config,
+    NoiseSuppression,
+    ParticipantBackendKind,
+    TransportMode,
+    TuiArgs,
+    WebcamResolution,
+};
+use eyre::{
+    Context as _,
+    Result,
+};
+use std::future::Future;
+use tokio::sync::watch;
+use tracing_subscriber::{
+    fmt::{
+        self,
+        writer::MakeWriterExt as _,
+    },
+    prelude::*,
+    EnvFilter,
+};
+
+#[derive(Args, Debug, Clone, Default)]
+pub struct HeadlessArgs {
+    #[clap(long, value_name = "URL")]
+    pub url: Option<url::Url>,
+
+    #[clap(long, value_name = "BACKEND")]
+    pub backend: Option<ParticipantBackendKind>,
+
+    #[clap(long = "headless", value_parser = clap::builder::BoolishValueParser::new())]
+    pub headless: Option<bool>,
+
+    #[clap(long = "audio-enabled", value_parser = clap::builder::BoolishValueParser::new())]
+    pub audio_enabled: Option<bool>,
+
+    #[clap(long = "video-enabled", value_parser = clap::builder::BoolishValueParser::new())]
+    pub video_enabled: Option<bool>,
+
+    #[clap(long = "screenshare-enabled", value_parser = clap::builder::BoolishValueParser::new())]
+    pub screenshare_enabled: Option<bool>,
+
+    #[clap(long = "auto-gain-control", value_parser = clap::builder::BoolishValueParser::new())]
+    pub auto_gain_control: Option<bool>,
+
+    #[clap(long = "noise-suppression", value_name = "MODEL")]
+    pub noise_suppression: Option<NoiseSuppression>,
+
+    #[clap(long, value_name = "MODE")]
+    pub transport: Option<TransportMode>,
+
+    #[clap(long, value_name = "RESOLUTION")]
+    pub resolution: Option<WebcamResolution>,
+
+    #[clap(long, value_parser = clap::builder::BoolishValueParser::new())]
+    pub blur: Option<bool>,
+
+    #[clap(long = "participant", value_name = "JSON")]
+    pub participants: Vec<String>,
+}
+
+#[derive(Debug, Clone, Default, serde::Deserialize)]
+#[serde(default, deny_unknown_fields)]
+struct ParticipantOverride {
+    url: Option<url::Url>,
+    backend: Option<ParticipantBackendKind>,
+    headless: Option<bool>,
+    audio_enabled: Option<bool>,
+    video_enabled: Option<bool>,
+    screenshare_enabled: Option<bool>,
+    auto_gain_control: Option<bool>,
+    noise_suppression: Option<NoiseSuppression>,
+    transport: Option<TransportMode>,
+    resolution: Option<WebcamResolution>,
+    blur: Option<bool>,
+}
+
+pub async fn run(args: HeadlessArgs, debug: u8) -> Result<i32> {
+    init_logging(debug)?;
+
+    let mut global_config = Config::new(TuiArgs::default()).context("Failed to create config")?;
+    apply_cli_overrides(&mut global_config, &args);
+
+    let participant_configs = build_participant_configs(global_config.clone(), &args.participants)?;
+    let store = client_simulator_browser::participant::ParticipantStore::new(global_config.data_dir());
+
+    for config in &participant_configs {
+        store.spawn(config).context("Failed to spawn participant")?;
+    }
+
+    Ok(wait_for_exit(store).await)
+}
+
+fn apply_cli_overrides(config: &mut Config, args: &HeadlessArgs) {
+    if let Some(url) = &args.url {
+        config.url = Some(url.clone());
+    }
+    if let Some(backend) = args.backend {
+        config.backend = backend;
+    }
+    if let Some(headless) = args.headless {
+        config.headless = headless;
+    }
+    if let Some(audio_enabled) = args.audio_enabled {
+        config.audio_enabled = audio_enabled;
+    }
+    if let Some(video_enabled) = args.video_enabled {
+        config.video_enabled = video_enabled;
+    }
+    if let Some(screenshare_enabled) = args.screenshare_enabled {
+        config.screenshare_enabled = screenshare_enabled;
+    }
+    if let Some(auto_gain_control) = args.auto_gain_control {
+        config.auto_gain_control = auto_gain_control;
+    }
+    if let Some(noise_suppression) = args.noise_suppression {
+        config.noise_suppression = noise_suppression;
+    }
+    if let Some(transport) = args.transport {
+        config.transport = transport;
+    }
+    if let Some(resolution) = args.resolution {
+        config.resolution = resolution;
+    }
+    if let Some(blur) = args.blur {
+        config.blur = blur;
+    }
+}
+
+fn apply_participant_override(mut config: Config, override_: ParticipantOverride) -> Config {
+    if let Some(url) = override_.url {
+        config.url = Some(url);
+    }
+    if let Some(backend) = override_.backend {
+        config.backend = backend;
+    }
+    if let Some(headless) = override_.headless {
+        config.headless = headless;
+    }
+    if let Some(audio_enabled) = override_.audio_enabled {
+        config.audio_enabled = audio_enabled;
+    }
+    if let Some(video_enabled) = override_.video_enabled {
+        config.video_enabled = video_enabled;
+    }
+    if let Some(screenshare_enabled) = override_.screenshare_enabled {
+        config.screenshare_enabled = screenshare_enabled;
+    }
+    if let Some(auto_gain_control) = override_.auto_gain_control {
+        config.auto_gain_control = auto_gain_control;
+    }
+    if let Some(noise_suppression) = override_.noise_suppression {
+        config.noise_suppression = noise_suppression;
+    }
+    if let Some(transport) = override_.transport {
+        config.transport = transport;
+    }
+    if let Some(resolution) = override_.resolution {
+        config.resolution = resolution;
+    }
+    if let Some(blur) = override_.blur {
+        config.blur = blur;
+    }
+    config
+}
+
+fn build_participant_configs(global_config: Config, participants: &[String]) -> Result<Vec<Config>> {
+    if participants.is_empty() {
+        return Ok(vec![global_config]);
+    }
+
+    participants
+        .iter()
+        .map(|json| {
+            let override_: ParticipantOverride =
+                serde_json::from_str(json).wrap_err_with(|| format!("Invalid --participant JSON: {json}"))?;
+            Ok(apply_participant_override(global_config.clone(), override_))
+        })
+        .collect()
+}
+
+fn init_logging(debug: u8) -> Result<()> {
+    let filter = match debug {
+        0 => "info",
+        1 => "debug",
+        _ => "trace",
+    };
+    let writer = std::io::stderr
+        .with_min_level(tracing::Level::WARN)
+        .or_else(std::io::stdout);
+
+    tracing_subscriber::registry()
+        .with(tracing_error::ErrorLayer::default())
+        .with(
+            fmt::layer()
+                .with_writer(writer)
+                .with_filter(EnvFilter::builder().parse_lossy(filter)),
+        )
+        .try_init()?;
+
+    Ok(())
+}
+
+async fn wait_for_exit(store: client_simulator_browser::participant::ParticipantStore) -> i32 {
+    wait_for_exit_with(
+        wait_for_all_stopped(&store),
+        wait_for_ctrl_c(),
+        || store.shutdown_all(),
+        wait_for_ctrl_c,
+    )
+    .await
+}
+
+async fn wait_for_exit_with<AllStopped, FirstSignal, ShutdownFn, Shutdown, SecondSignalFn, SecondSignal>(
+    all_stopped: AllStopped,
+    first_signal: FirstSignal,
+    shutdown: ShutdownFn,
+    second_signal: SecondSignalFn,
+) -> i32
+where
+    AllStopped: Future<Output = ()>,
+    FirstSignal: Future<Output = ()>,
+    ShutdownFn: FnOnce() -> Shutdown,
+    Shutdown: Future<Output = ()>,
+    SecondSignalFn: FnOnce() -> SecondSignal,
+    SecondSignal: Future<Output = ()>,
+{
+    tokio::select! {
+        () = all_stopped => 0,
+        () = first_signal => {
+            tracing::info!("Shutting down participants. Press Ctrl-C again to force exit.");
+            tokio::select! {
+                () = shutdown() => 0,
+                () = second_signal() => 130,
+            }
+        }
+    }
+}
+
+async fn wait_for_ctrl_c() {
+    if let Err(err) = tokio::signal::ctrl_c().await {
+        tracing::error!("Failed to listen for Ctrl-C: {err}");
+    }
+}
+
+async fn wait_for_all_stopped(store: &client_simulator_browser::participant::ParticipantStore) {
+    let states = store
+        .values()
+        .into_iter()
+        .map(|participant| participant.state.clone())
+        .collect::<Vec<_>>();
+
+    wait_for_states_stopped(states).await;
+}
+
+async fn wait_for_states_stopped(
+    states: Vec<watch::Receiver<client_simulator_browser::participant::ParticipantState>>,
+) {
+    for state in states {
+        wait_for_state_stopped_after_start(state).await;
+    }
+}
+
+async fn wait_for_state_stopped_after_start(
+    mut state: watch::Receiver<client_simulator_browser::participant::ParticipantState>,
+) {
+    let mut saw_running = false;
+
+    loop {
+        let running = state.borrow().running;
+        if running {
+            saw_running = true;
+        } else if saw_running {
+            return;
+        }
+
+        if state.changed().await.is_err() {
+            return;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::Parser;
+    use client_simulator_browser::participant::ParticipantState;
+    use client_simulator_config::{
+        Config,
+        ParticipantBackendKind,
+    };
+    use std::{
+        fs,
+        future::{
+            pending,
+            ready,
+        },
+        path::PathBuf,
+        time::{
+            SystemTime,
+            UNIX_EPOCH,
+        },
+    };
+    use url::Url;
+
+    #[derive(Parser)]
+    struct TestHeadlessCli {
+        #[command(flatten)]
+        args: HeadlessArgs,
+    }
+
+    #[test]
+    fn cli_parsing_accepts_repeated_participants() {
+        let cli = TestHeadlessCli::parse_from([
+            "headless",
+            "--url",
+            "https://latest.dev.hyper.video/F27-T5F-DXY",
+            "--participant",
+            r#"{"audio_enabled": false, "backend": "local"}"#,
+            "--participant",
+            r#"{"audio_enabled": true, "backend": "cloudflare"}"#,
+        ]);
+        let args = cli.args;
+
+        assert_eq!(
+            args.url.as_ref().map(Url::as_str),
+            Some("https://latest.dev.hyper.video/F27-T5F-DXY")
+        );
+        assert_eq!(args.participants.len(), 2);
+    }
+
+    #[test]
+    fn cli_bool_options_accept_explicit_false() {
+        let cli = TestHeadlessCli::parse_from(["headless", "--headless", "false", "--audio-enabled", "false"]);
+        let args = cli.args;
+
+        assert_eq!(args.headless, Some(false));
+        assert_eq!(args.audio_enabled, Some(false));
+    }
+
+    #[test]
+    fn participant_json_overrides_global_config() {
+        let global_config = Config {
+            url: Some(Url::parse("https://example.com/lite/global").expect("valid url")),
+            backend: ParticipantBackendKind::Local,
+            audio_enabled: true,
+            ..Default::default()
+        };
+
+        let configs = build_participant_configs(
+            global_config,
+            &[
+                r#"{"url":"https://example.com/lite/participant","backend":"cloudflare","audio_enabled":false}"#
+                    .to_string(),
+            ],
+        )
+        .expect("participant configs");
+
+        assert_eq!(configs.len(), 1);
+        assert_eq!(
+            configs[0].url.as_ref().map(Url::as_str),
+            Some("https://example.com/lite/participant")
+        );
+        assert_eq!(configs[0].backend, ParticipantBackendKind::Cloudflare);
+        assert!(!configs[0].audio_enabled);
+    }
+
+    #[test]
+    fn unknown_participant_json_field_returns_error() {
+        let error = build_participant_configs(Config::default(), &[r#"{"audio_enable":false}"#.to_string()])
+            .expect_err("unknown field should fail");
+
+        assert!(error.to_string().contains("--participant"));
+    }
+
+    #[test]
+    fn empty_participant_list_returns_one_effective_config() {
+        let global_config = Config {
+            backend: ParticipantBackendKind::RemoteStub,
+            ..Default::default()
+        };
+
+        let configs = build_participant_configs(global_config, &[]).expect("participant configs");
+
+        assert_eq!(configs.len(), 1);
+        assert_eq!(configs[0].backend, ParticipantBackendKind::RemoteStub);
+    }
+
+    #[tokio::test]
+    async fn wait_for_all_stopped_waits_until_running_participant_stops() {
+        let data_dir = unique_test_data_dir();
+        fs::create_dir_all(&data_dir).expect("create temp data dir");
+        let store = client_simulator_browser::participant::ParticipantStore::new(&data_dir);
+        let config = Config {
+            url: Some(Url::parse("https://example.com/lite/demo").expect("valid url")),
+            ..Default::default()
+        };
+
+        store.spawn_remote_stub(&config).expect("spawn remote stub");
+
+        let wait_task = tokio::spawn({
+            let store = store.clone();
+            async move { wait_for_all_stopped(&store).await }
+        });
+
+        tokio::task::yield_now().await;
+        tokio::task::yield_now().await;
+        let finished_before_shutdown = wait_task.is_finished();
+
+        store.shutdown_all().await;
+        if !wait_task.is_finished() {
+            wait_task.await.expect("wait task should finish after shutdown");
+        }
+
+        assert!(
+            !finished_before_shutdown,
+            "wait_for_all_stopped returned before shutdown"
+        );
+    }
+
+    #[tokio::test]
+    async fn wait_for_states_stopped_ignores_initial_not_running_state() {
+        let (state_sender, state_receiver) = tokio::sync::watch::channel(ParticipantState::default());
+        let wait_task = tokio::spawn(async move {
+            wait_for_states_stopped(vec![state_receiver]).await;
+        });
+
+        tokio::task::yield_now().await;
+        assert!(
+            !wait_task.is_finished(),
+            "initial not-running state should not finish the wait"
+        );
+
+        state_sender.send_modify(|state| state.running = true);
+        tokio::task::yield_now().await;
+        assert!(state_sender.borrow().running);
+        assert!(!wait_task.is_finished(), "running state should not finish the wait");
+
+        state_sender.send_modify(|state| state.running = false);
+        wait_task.await.expect("wait task should finish after stopped state");
+    }
+
+    #[tokio::test]
+    async fn wait_for_exit_returns_zero_when_shutdown_completes_after_signal() {
+        let code = wait_for_exit_with(pending(), ready(()), || ready(()), pending).await;
+
+        assert_eq!(code, 0);
+    }
+
+    #[tokio::test]
+    async fn wait_for_exit_returns_130_when_second_signal_arrives_before_shutdown() {
+        let code = wait_for_exit_with(pending(), ready(()), pending, || ready(())).await;
+
+        assert_eq!(code, 130);
+    }
+
+    fn unique_test_data_dir() -> PathBuf {
+        let timestamp = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("current time")
+            .as_nanos();
+        std::env::temp_dir().join(format!("hyper-client-simulator-headless-test-{timestamp}"))
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 1fc5e3a..119edc7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,5 @@
 mod errors;
+mod headless;
 
 use clap::{
     Parser,
@@ -27,14 +28,48 @@ pub struct CliArgs {
     command: Option<Command>,
 }
 
-#[derive(Subcommand)]
+#[derive(Subcommand, Debug)]
 enum Command {
     /// Start the TUI application
     Tui(TuiArgs),
+    /// Start simulator participants without the TUI
+    Headless(headless::HeadlessArgs),
     /// Connect to the hyper server to get a hyper session cookie
     Cookie(CookieArgs),
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_headless_command_with_repeated_participants() {
+        let args = CliArgs::parse_from([
+            "hyper-client-simulator",
+            "--debug",
+            "headless",
+            "--url",
+            "https://latest.dev.hyper.video/F27-T5F-DXY",
+            "--participant",
+            r#"{"audio_enabled": false, "backend": "local"}"#,
+            "--participant",
+            r#"{"audio_enabled": true, "backend": "cloudflare"}"#,
+        ]);
+
+        match args.command {
+            Some(Command::Headless(headless)) => {
+                assert_eq!(args.debug, 1);
+                assert_eq!(
+                    headless.url.as_ref().map(url::Url::as_str),
+                    Some("https://latest.dev.hyper.video/F27-T5F-DXY")
+                );
+                assert_eq!(headless.participants.len(), 2);
+            }
+            other => panic!("expected headless command, got {other:?}"),
+        }
+    }
+}
+
 #[derive(clap::Args, Debug, Clone)]
 pub struct CookieArgs {
     /// Base URL of the hyper server
@@ -64,6 +99,10 @@ async fn main() -> eyre::Result<()> {
             args.debug = debug;
             start_tui(args).await
         }
+        Some(Command::Headless(args)) => {
+            let code = headless::run(args, debug).await?;
+            std::process::exit(code);
+        }
         Some(Command::Cookie(args)) => run_cookie(args, debug).await,
     }
 }

From 0a107325477c0efcc4f118e5751a655fb90fc72c Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Tue, 2 Jun 2026 20:15:38 +0200
Subject: [PATCH 20/42] 2026-06-02-new-video-constraints-support.org v1

---
 2026-06-02-new-video-constraints-support.org | 1338 ++++++++++++++++++
 1 file changed, 1338 insertions(+)
 create mode 100644 2026-06-02-new-video-constraints-support.org

diff --git a/2026-06-02-new-video-constraints-support.org b/2026-06-02-new-video-constraints-support.org
new file mode 100644
index 0000000..d5d5423
--- /dev/null
+++ b/2026-06-02-new-video-constraints-support.org
@@ -0,0 +1,1338 @@
+#+TITLE: New Video Constraints Support Implementation Plan
+#+DATE: [2026-06-02 Tue]
+#+FILETAGS: :implementation_plan:video_constraints:
+
+#+BEGIN_QUOTE
+For agentic workers: REQUIRED SUB-SKILL: Use =superpowers:subagent-driven-development= (recommended) or =superpowers:executing-plans= to implement this plan task-by-task. Steps use checkbox syntax for tracking.
+#+END_QUOTE
+
+* Goal
+
+Replace simulator support for the removed Hyper Core webcam encoder resolution setting with the current media settings:
+
+- =videoConstraintPublishWebcam=: outgoing webcam max-resolution option.
+- =videoConstraintSubscribe=: incoming max-resolution option.
+- =videoMaxConcurrentTracks=: max number of outgoing video tracks per local video stream, or =null= for unlimited.
+
+* Architecture
+
+Treat the new controls as media settings, not video codec settings. The active local-browser JavaScript API should read and write =window.hyper.settings.media= through =setVideoConstraintPublishWebcam=, =setVideoConstraintSubscribe=, and =setVideoMaxConcurrentTracks=.
+
+Replace the simulator's old single =resolution= setting throughout the active config, participant launch settings, participant state, headless CLI, remote-stub backend, and TUI surfaces. Keep the Cloudflare backend in sync by updating the bundled worker OpenAPI schema and browser-side mapping tests so remote participants receive the same three setting values.
+
+* Tech Stack
+
+Rust 2021, =serde=, =strum=, =clap=, =tokio=, =chromiumoxide=, =thirtyfour=, generated =cloudflare-worker-client= types from =progenitor=, and the existing =just= recipes.
+
+* Source Context
+
+The linked Hyper design note is [[file:/Users/robert/projects/shuttle/hyper.video-3/2026-06-02_manual-simulcast-video-stream-control.org][2026-06-02_manual-simulcast-video-stream-control.org]].
+
+The current Hyper SDK settings are defined in [[file:/Users/robert/projects/shuttle/hyper.video-3/frontend/web/sdk/src/remote-config/media-settings.ts][media-settings.ts]]:
+
+#+BEGIN_SRC typescript
+export type VideoConstraint = keyof typeof VIDEO_CONSTRAINT_NONE | keyof typeof VIDEO_CONSTRAINT_OPTIONS;
+
+export const VIDEO_CONSTRAINT_NONE = {
+    none: { label: "None" },
+};
+export const VIDEO_CONSTRAINT_OPTIONS = {
+    "90p": { label: "90p", width: 160, height: 90 },
+    "144p": { label: "144p", width: 256, height: 144 },
+    "240p": { label: "240p", width: 426, height: 240 },
+    "360p": { label: "360p", width: 640, height: 360 },
+    "480p": { label: "480p", width: 854, height: 480 },
+    "720p": { label: "720p", width: 1280, height: 720 },
+    "1080p": { label: "1080p", width: 1920, height: 1080 },
+    "1440p": { label: "1440p", width: 2560, height: 1440 },
+    "2160p": { label: "2160p", width: 3840, height: 2160 },
+} as const;
+#+END_SRC
+
+The active runtime actions are in [[file:/Users/robert/projects/shuttle/hyper.video-3/frontend/web/sdk/src/media/state/media-settings.tsx][media-settings.tsx]]:
+
+#+BEGIN_SRC typescript
+setVideoConstraintPublishWebcam: (constraint) => {
+    updateBase({ videoConstraintPublishWebcam: constraint });
+},
+setVideoConstraintSubscribe: (constraint) => {
+    updateBase({ videoConstraintSubscribe: constraint });
+},
+setVideoMaxConcurrentTracks: (maxConcurrentTracks) => {
+    updateBase({ videoMaxConcurrentTracks: maxConcurrentTracks });
+},
+#+END_SRC
+
+The simulator currently calls the removed API in [[file:browser/src/participant/frontend/commands.rs][browser/src/participant/frontend/commands.rs]]:
+
+#+BEGIN_SRC rust
+const CAMERA_RES_GET: &str = "return hyper.settings.videoCodec.videoResolutionForWebcamEncoder.name;";
+const CAMERA_RES_SET: &str = "hyper.settings.videoCodec.actions.setVideoResolutionForWebcamEncoder(arguments[0]);";
+#+END_SRC
+
+* File Map
+
+- Modify [[file:config/src/client_config.rs][config/src/client_config.rs]]: add =VideoConstraint= and a CLI/TUI-friendly =VideoMaxConcurrentTracksPreset= helper; stop using =WebcamResolution= for active Hyper Core media settings.
+- Modify [[file:config/src/lib.rs][config/src/lib.rs]]: replace =Config.resolution= with =video_constraint_publish_webcam=, =video_constraint_subscribe=, and =video_max_concurrent_tracks=.
+- Modify [[file:config/src/default-config.yaml][config/src/default-config.yaml]]: default both constraints to =none= and =video_max_concurrent_tracks= to =null= or omitted.
+- Modify [[file:browser/src/participant/frontend/commands.rs][browser/src/participant/frontend/commands.rs]]: replace camera resolution commands with media setting commands and unit tests over a fake =BrowserDriver=.
+- Modify [[file:browser/src/participant/frontend/core.rs][browser/src/participant/frontend/core.rs]]: apply and refresh the three new settings.
+- Modify [[file:browser/src/participant/shared/spec.rs][browser/src/participant/shared/spec.rs]], [[file:browser/src/participant/shared/state.rs][state.rs]], [[file:browser/src/participant/shared/messages.rs][messages.rs]], [[file:browser/src/participant/remote_stub.rs][remote_stub.rs]], and [[file:browser/src/participant/mod.rs][mod.rs]]: thread the new setting names through participant state and commands.
+- Modify [[file:src/headless.rs][src/headless.rs]]: replace =--resolution= and participant JSON =resolution= with the three new fields.
+- Modify [[file:tui/src/tui/components/browser_start.rs][tui/src/tui/components/browser_start.rs]] and [[file:tui/src/tui/components/participants.rs][participants.rs]]: replace the camera resolution selector/table cell with outgoing constraint, incoming constraint, and track-limit controls.
+- Modify [[file:cloudflare-worker-client/openapi/cloudflare-browser-simulator.json][cloudflare-worker-client/openapi/cloudflare-browser-simulator.json]], [[file:cloudflare-worker-client/src/client.rs][client.rs]], and [[file:browser/src/participant/cloudflare/mod.rs][browser/src/participant/cloudflare/mod.rs]]: replace worker schema and mappings for legacy resolution.
+
+* Task 1: Add Config Types and Replace Active Config Fields
+
+** Files
+
+- Modify: [[file:config/src/client_config.rs][config/src/client_config.rs]]
+- Modify: [[file:config/src/lib.rs][config/src/lib.rs]]
+- Modify: [[file:config/src/default-config.yaml][config/src/default-config.yaml]]
+
+** Steps
+
+- [ ] Step 1: Write failing config type tests.
+
+Add these tests in =config/src/client_config.rs=.
+
+#+BEGIN_SRC rust
+#[cfg(test)]
+mod tests {
+    use super::{
+        ParticipantBackendKind,
+        VideoConstraint,
+        VideoMaxConcurrentTracksPreset,
+    };
+    use std::str::FromStr as _;
+
+    #[test]
+    fn video_constraint_round_trips_hyper_media_setting_names() {
+        let values = [
+            ("none", VideoConstraint::None),
+            ("90p", VideoConstraint::P90),
+            ("144p", VideoConstraint::P144),
+            ("240p", VideoConstraint::P240),
+            ("360p", VideoConstraint::P360),
+            ("480p", VideoConstraint::P480),
+            ("720p", VideoConstraint::P720),
+            ("1080p", VideoConstraint::P1080),
+            ("1440p", VideoConstraint::P1440),
+            ("2160p", VideoConstraint::P2160),
+        ];
+
+        for (raw, expected) in values {
+            assert_eq!(VideoConstraint::from_str(raw).unwrap(), expected);
+            assert_eq!(expected.to_string(), raw);
+            assert_eq!(serde_json::to_value(expected).unwrap(), raw);
+            assert_eq!(serde_json::from_value::<VideoConstraint>(raw.into()).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn video_track_limit_presets_convert_to_nullable_track_counts() {
+        assert_eq!(VideoMaxConcurrentTracksPreset::Unlimited.to_option(), None);
+        assert_eq!(VideoMaxConcurrentTracksPreset::One.to_option(), Some(1));
+        assert_eq!(VideoMaxConcurrentTracksPreset::Two.to_option(), Some(2));
+        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(None), VideoMaxConcurrentTracksPreset::Unlimited);
+        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(1)), VideoMaxConcurrentTracksPreset::One);
+        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(2)), VideoMaxConcurrentTracksPreset::Two);
+        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(8)), VideoMaxConcurrentTracksPreset::Custom);
+    }
+
+    #[test]
+    fn aws_device_farm_round_trips_kebab_case() {
+        let kind = ParticipantBackendKind::from_str("aws-device-farm").unwrap();
+        assert_eq!(kind, ParticipantBackendKind::AwsDeviceFarm);
+        assert_eq!(kind.to_string(), "aws-device-farm");
+        assert!(!kind.is_local());
+    }
+}
+#+END_SRC
+
+Replace the existing =tests= module instead of creating a duplicate module.
+
+- [ ] Step 2: Run the failing config type tests.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo test -p client-simulator-config video_constraint_round_trips_hyper_media_setting_names video_track_limit_presets_convert_to_nullable_track_counts
+#+END_SRC
+
+Expected: the command fails because =VideoConstraint= and =VideoMaxConcurrentTracksPreset= do not exist.
+
+- [ ] Step 3: Add the new config enums.
+
+Add this near =WebcamResolution= in =config/src/client_config.rs=. Keep =WebcamResolution= only if Cloudflare compatibility tests still need it during the transition; do not use it for active Hyper Core media settings after Task 3.
+
+#+BEGIN_SRC rust
+#[derive(Debug, Default, Clone, Copy, Display, EnumIter, EnumString, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+pub enum VideoConstraint {
+    #[default]
+    #[strum(to_string = "none")]
+    #[serde(rename = "none")]
+    None,
+    #[strum(to_string = "90p")]
+    #[serde(rename = "90p")]
+    P90,
+    #[strum(to_string = "144p")]
+    #[serde(rename = "144p")]
+    P144,
+    #[strum(to_string = "240p")]
+    #[serde(rename = "240p")]
+    P240,
+    #[strum(to_string = "360p")]
+    #[serde(rename = "360p")]
+    P360,
+    #[strum(to_string = "480p")]
+    #[serde(rename = "480p")]
+    P480,
+    #[strum(to_string = "720p")]
+    #[serde(rename = "720p")]
+    P720,
+    #[strum(to_string = "1080p")]
+    #[serde(rename = "1080p")]
+    P1080,
+    #[strum(to_string = "1440p")]
+    #[serde(rename = "1440p")]
+    P1440,
+    #[strum(to_string = "2160p")]
+    #[serde(rename = "2160p")]
+    P2160,
+}
+
+#[derive(Debug, Default, Clone, Copy, Display, EnumIter, EnumString, PartialEq, Eq)]
+pub enum VideoMaxConcurrentTracksPreset {
+    #[default]
+    #[strum(to_string = "unlimited")]
+    Unlimited,
+    #[strum(to_string = "1")]
+    One,
+    #[strum(to_string = "2")]
+    Two,
+    #[strum(to_string = "custom")]
+    Custom,
+}
+
+impl VideoMaxConcurrentTracksPreset {
+    pub const fn to_option(self) -> Option<usize> {
+        match self {
+            Self::Unlimited => None,
+            Self::One => Some(1),
+            Self::Two => Some(2),
+            Self::Custom => None,
+        }
+    }
+
+    pub const fn from_option(value: Option<usize>) -> Self {
+        match value {
+            None => Self::Unlimited,
+            Some(1) => Self::One,
+            Some(2) => Self::Two,
+            Some(_) => Self::Custom,
+        }
+    }
+}
+#+END_SRC
+
+- [ ] Step 4: Export the new types.
+
+Modify the =pub use client_config= block in =config/src/lib.rs=.
+
+#+BEGIN_SRC rust
+pub use client_config::{
+    NoiseSuppression,
+    NoiseSuppressionIter,
+    ParticipantBackendKind,
+    TransportMode,
+    TransportModeIter,
+    VideoConstraint,
+    VideoConstraintIter,
+    VideoMaxConcurrentTracksPreset,
+    VideoMaxConcurrentTracksPresetIter,
+};
+#+END_SRC
+
+- [ ] Step 5: Replace the active config fields.
+
+In =config/src/lib.rs=, replace:
+
+#+BEGIN_SRC rust
+#[serde(default)]
+pub resolution: WebcamResolution,
+#+END_SRC
+
+with:
+
+#+BEGIN_SRC rust
+#[serde(default)]
+pub video_constraint_publish_webcam: VideoConstraint,
+#[serde(default)]
+pub video_constraint_subscribe: VideoConstraint,
+#[serde(default, skip_serializing_if = "Option::is_none")]
+pub video_max_concurrent_tracks: Option<usize>,
+#+END_SRC
+
+Update =impl config::Source for Config= so the collected source emits only the new fields:
+
+#+BEGIN_SRC rust
+cache.insert(
+    "video_constraint_publish_webcam".to_string(),
+    self.video_constraint_publish_webcam.to_string().into(),
+);
+cache.insert(
+    "video_constraint_subscribe".to_string(),
+    self.video_constraint_subscribe.to_string().into(),
+);
+if let Some(value) = self.video_max_concurrent_tracks {
+    cache.insert("video_max_concurrent_tracks".to_string(), (value as i64).into());
+}
+#+END_SRC
+
+Remove the old =resolution= insert from this method.
+
+- [ ] Step 6: Update default YAML.
+
+In =config/src/default-config.yaml=, replace:
+
+#+BEGIN_SRC yaml
+resolution: auto
+#+END_SRC
+
+with:
+
+#+BEGIN_SRC yaml
+video_constraint_publish_webcam: none
+video_constraint_subscribe: none
+video_max_concurrent_tracks:
+#+END_SRC
+
+- [ ] Step 7: Add config deserialization tests.
+
+Add these tests in =config/src/lib.rs=.
+
+#+BEGIN_SRC rust
+#[test]
+fn parses_new_video_constraint_settings() {
+    let config: Config = config::Config::builder()
+        .add_source(Config::default())
+        .add_source(config::File::from_str(
+            r#"
+video_constraint_publish_webcam: 480p
+video_constraint_subscribe: 720p
+video_max_concurrent_tracks: 2
+"#,
+            config::FileFormat::Yaml,
+        ))
+        .build()
+        .expect("failed to build config")
+        .try_deserialize()
+        .expect("failed to deserialize config");
+
+    assert_eq!(config.video_constraint_publish_webcam, VideoConstraint::P480);
+    assert_eq!(config.video_constraint_subscribe, VideoConstraint::P720);
+    assert_eq!(config.video_max_concurrent_tracks, Some(2));
+}
+
+#[test]
+fn default_video_max_concurrent_tracks_is_unlimited() {
+    let config = Config::default();
+
+    assert_eq!(config.video_constraint_publish_webcam, VideoConstraint::None);
+    assert_eq!(config.video_constraint_subscribe, VideoConstraint::None);
+    assert_eq!(config.video_max_concurrent_tracks, None);
+}
+#+END_SRC
+
+- [ ] Step 8: Run config tests.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo test -p client-simulator-config
+#+END_SRC
+
+Expected: all =client-simulator-config= tests pass.
+
+* Task 2: Replace Local Browser JavaScript Commands
+
+** Files
+
+- Modify: [[file:browser/src/participant/frontend/commands.rs][browser/src/participant/frontend/commands.rs]]
+
+** Steps
+
+- [ ] Step 1: Write failing command tests with a fake driver.
+
+Add a =#[cfg(test)]= module in =browser/src/participant/frontend/commands.rs=. Use a recording driver so the tests prove exact JavaScript bodies and serialized arguments.
+
+#+BEGIN_SRC rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use eyre::Result;
+    use futures::{
+        future::BoxFuture,
+        FutureExt as _,
+    };
+    use serde_json::json;
+    use std::{
+        sync::Mutex,
+        time::Duration,
+    };
+
+    #[derive(Default)]
+    struct RecordingDriver {
+        calls: Mutex<Vec<(String, Option<serde_json::Value>)>>,
+        next_result: Mutex<serde_json::Value>,
+    }
+
+    impl RecordingDriver {
+        fn with_result(value: serde_json::Value) -> Self {
+            Self {
+                calls: Mutex::new(Vec::new()),
+                next_result: Mutex::new(value),
+            }
+        }
+
+        fn calls(&self) -> Vec<(String, Option<serde_json::Value>)> {
+            self.calls.lock().unwrap().clone()
+        }
+    }
+
+    impl BrowserDriver for RecordingDriver {
+        fn goto(&self, _url: &str) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+
+        fn exists(&self, _selector: &str) -> BoxFuture<'_, Result<bool>> {
+            async { Ok(false) }.boxed()
+        }
+
+        fn wait_for(&self, _selector: &str, _timeout: Duration) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+
+        fn click(&self, _selector: &str) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+
+        fn fill(&self, _selector: &str, _text: &str) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+
+        fn attribute(&self, _selector: &str, _name: &str) -> BoxFuture<'_, Result<Option<String>>> {
+            async { Ok(None) }.boxed()
+        }
+
+        fn eval(&self, js_body: &str, arg: Option<serde_json::Value>) -> BoxFuture<'_, Result<serde_json::Value>> {
+            self.calls.lock().unwrap().push((js_body.to_string(), arg));
+            let value = self.next_result.lock().unwrap().clone();
+            async move { Ok(value) }.boxed()
+        }
+
+        fn set_cookie(&self, _domain: &str, _name: &str, _value: &str) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+    }
+
+    #[tokio::test]
+    async fn sets_video_constraints_through_media_settings_api() {
+        let driver = RecordingDriver::default();
+
+        set_video_constraint_publish_webcam(&driver, VideoConstraint::P480).await.unwrap();
+        set_video_constraint_subscribe(&driver, VideoConstraint::P720).await.unwrap();
+        set_video_max_concurrent_tracks(&driver, Some(2)).await.unwrap();
+        set_video_max_concurrent_tracks(&driver, None).await.unwrap();
+
+        assert_eq!(
+            driver.calls(),
+            vec![
+                (
+                    "hyper.settings.media.actions.setVideoConstraintPublishWebcam(arguments[0]);".to_string(),
+                    Some(json!("480p")),
+                ),
+                (
+                    "hyper.settings.media.actions.setVideoConstraintSubscribe(arguments[0]);".to_string(),
+                    Some(json!("720p")),
+                ),
+                (
+                    "hyper.settings.media.actions.setVideoMaxConcurrentTracks(arguments[0]);".to_string(),
+                    Some(json!(2)),
+                ),
+                (
+                    "hyper.settings.media.actions.setVideoMaxConcurrentTracks(arguments[0]);".to_string(),
+                    Some(serde_json::Value::Null),
+                ),
+            ],
+        );
+    }
+
+    #[tokio::test]
+    async fn gets_video_constraints_from_media_settings_api() {
+        let driver = RecordingDriver::with_result(json!("360p"));
+
+        let value = get_video_constraint_publish_webcam(&driver).await.unwrap();
+
+        assert_eq!(value, VideoConstraint::P360);
+        assert_eq!(
+            driver.calls(),
+            vec![(
+                "return hyper.settings.media.videoConstraintPublishWebcam;".to_string(),
+                None,
+            )],
+        );
+    }
+
+    #[tokio::test]
+    async fn gets_nullable_video_max_concurrent_tracks() {
+        let driver = RecordingDriver::with_result(serde_json::Value::Null);
+
+        let value = get_video_max_concurrent_tracks(&driver).await.unwrap();
+
+        assert_eq!(value, None);
+        assert_eq!(
+            driver.calls(),
+            vec![(
+                "return hyper.settings.media.videoMaxConcurrentTracks;".to_string(),
+                None,
+            )],
+        );
+    }
+}
+#+END_SRC
+
+- [ ] Step 2: Run the failing browser command tests.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo test -p client-simulator-browser video_constraints_through_media_settings_api gets_video_constraints_from_media_settings_api gets_nullable_video_max_concurrent_tracks
+#+END_SRC
+
+Expected: the command fails because the new functions and imported types do not exist.
+
+- [ ] Step 3: Replace the command constants and functions.
+
+In =browser/src/participant/frontend/commands.rs=, import =VideoConstraint= instead of =WebcamResolution= for video constraints:
+
+#+BEGIN_SRC rust
+use client_simulator_config::{
+    NoiseSuppression,
+    VideoConstraint,
+};
+#+END_SRC
+
+Remove =CAMERA_RES_GET= and =CAMERA_RES_SET=. Add:
+
+#+BEGIN_SRC rust
+const VIDEO_CONSTRAINT_PUBLISH_GET: &str = "return hyper.settings.media.videoConstraintPublishWebcam;";
+const VIDEO_CONSTRAINT_PUBLISH_SET: &str =
+    "hyper.settings.media.actions.setVideoConstraintPublishWebcam(arguments[0]);";
+const VIDEO_CONSTRAINT_SUBSCRIBE_GET: &str = "return hyper.settings.media.videoConstraintSubscribe;";
+const VIDEO_CONSTRAINT_SUBSCRIBE_SET: &str =
+    "hyper.settings.media.actions.setVideoConstraintSubscribe(arguments[0]);";
+const VIDEO_MAX_CONCURRENT_TRACKS_GET: &str = "return hyper.settings.media.videoMaxConcurrentTracks;";
+const VIDEO_MAX_CONCURRENT_TRACKS_SET: &str =
+    "hyper.settings.media.actions.setVideoMaxConcurrentTracks(arguments[0]);";
+#+END_SRC
+
+Replace =get_outgoing_camera_resolution= and =set_outgoing_camera_resolution= with:
+
+#+BEGIN_SRC rust
+pub(super) async fn get_video_constraint_publish_webcam(driver: &dyn BrowserDriver) -> Result<VideoConstraint> {
+    get_string(driver, VIDEO_CONSTRAINT_PUBLISH_GET)
+        .await?
+        .parse::<VideoConstraint>()
+        .context("failed to parse videoConstraintPublishWebcam from string")
+}
+
+pub(super) async fn set_video_constraint_publish_webcam(
+    driver: &dyn BrowserDriver,
+    value: VideoConstraint,
+) -> Result<()> {
+    set_value(driver, VIDEO_CONSTRAINT_PUBLISH_SET, value.to_string()).await
+}
+
+pub(super) async fn get_video_constraint_subscribe(driver: &dyn BrowserDriver) -> Result<VideoConstraint> {
+    get_string(driver, VIDEO_CONSTRAINT_SUBSCRIBE_GET)
+        .await?
+        .parse::<VideoConstraint>()
+        .context("failed to parse videoConstraintSubscribe from string")
+}
+
+pub(super) async fn set_video_constraint_subscribe(driver: &dyn BrowserDriver, value: VideoConstraint) -> Result<()> {
+    set_value(driver, VIDEO_CONSTRAINT_SUBSCRIBE_SET, value.to_string()).await
+}
+
+pub(super) async fn get_video_max_concurrent_tracks(driver: &dyn BrowserDriver) -> Result<Option<usize>> {
+    let value = driver.eval(VIDEO_MAX_CONCURRENT_TRACKS_GET, None).await?;
+    serde_json::from_value(value).context("failed to read videoMaxConcurrentTracks from eval result")
+}
+
+pub(super) async fn set_video_max_concurrent_tracks(
+    driver: &dyn BrowserDriver,
+    value: Option<usize>,
+) -> Result<()> {
+    set_value(driver, VIDEO_MAX_CONCURRENT_TRACKS_SET, value).await
+}
+#+END_SRC
+
+- [ ] Step 4: Run browser command tests.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo test -p client-simulator-browser video_constraints
+#+END_SRC
+
+Expected: command tests pass and no remaining test references call =videoResolutionForWebcamEncoder=.
+
+* Task 3: Thread New Settings Through Participant Runtime
+
+** Files
+
+- Modify: [[file:browser/src/participant/shared/spec.rs][browser/src/participant/shared/spec.rs]]
+- Modify: [[file:browser/src/participant/shared/state.rs][browser/src/participant/shared/state.rs]]
+- Modify: [[file:browser/src/participant/shared/messages.rs][browser/src/participant/shared/messages.rs]]
+- Modify: [[file:browser/src/participant/frontend/core.rs][browser/src/participant/frontend/core.rs]]
+- Modify: [[file:browser/src/participant/remote_stub.rs][browser/src/participant/remote_stub.rs]]
+- Modify: [[file:browser/src/participant/mod.rs][browser/src/participant/mod.rs]]
+- Modify: [[file:browser/src/participant/frontend/lite.rs][browser/src/participant/frontend/lite.rs]]
+
+** Steps
+
+- [ ] Step 1: Write failing launch-spec and state tests.
+
+Update =browser/src/participant/shared/spec.rs= test =converts_participant_config_to_launch_spec= so its config and assertions use all three new fields:
+
+#+BEGIN_SRC rust
+let participant_config = ParticipantConfig {
+    username: "robert".to_string(),
+    session_url: Url::parse("https://example.com/m/demo").unwrap(),
+    app_config: Config {
+        audio_enabled: true,
+        video_enabled: false,
+        screenshare_enabled: true,
+        auto_gain_control: true,
+        noise_suppression: NoiseSuppression::RNNoise,
+        transport: TransportMode::WebRTC,
+        video_constraint_publish_webcam: VideoConstraint::P480,
+        video_constraint_subscribe: VideoConstraint::P720,
+        video_max_concurrent_tracks: Some(2),
+        blur: true,
+        ..Default::default()
+    },
+};
+
+let spec = ParticipantLaunchSpec::from(participant_config);
+
+assert_eq!(spec.settings.video_constraint_publish_webcam, VideoConstraint::P480);
+assert_eq!(spec.settings.video_constraint_subscribe, VideoConstraint::P720);
+assert_eq!(spec.settings.video_max_concurrent_tracks, Some(2));
+#+END_SRC
+
+- [ ] Step 2: Run the failing launch-spec test.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo test -p client-simulator-browser converts_participant_config_to_launch_spec
+#+END_SRC
+
+Expected: the test fails because =ParticipantSettings= still has =resolution=.
+
+- [ ] Step 3: Replace participant setting and state fields.
+
+In =browser/src/participant/shared/spec.rs=, replace:
+
+#+BEGIN_SRC rust
+pub(in crate::participant) resolution: WebcamResolution,
+#+END_SRC
+
+with:
+
+#+BEGIN_SRC rust
+pub(in crate::participant) video_constraint_publish_webcam: VideoConstraint,
+pub(in crate::participant) video_constraint_subscribe: VideoConstraint,
+pub(in crate::participant) video_max_concurrent_tracks: Option<usize>,
+#+END_SRC
+
+In =ParticipantSettings::from=, assign the new fields from =app_config=.
+
+In =browser/src/participant/shared/state.rs=, replace:
+
+#+BEGIN_SRC rust
+pub webcam_resolution: WebcamResolution,
+#+END_SRC
+
+with:
+
+#+BEGIN_SRC rust
+pub video_constraint_publish_webcam: VideoConstraint,
+pub video_constraint_subscribe: VideoConstraint,
+pub video_max_concurrent_tracks: Option<usize>,
+#+END_SRC
+
+- [ ] Step 4: Replace participant commands.
+
+In =browser/src/participant/shared/messages.rs=, replace:
+
+#+BEGIN_SRC rust
+SetWebcamResolutions(WebcamResolution),
+#+END_SRC
+
+with:
+
+#+BEGIN_SRC rust
+SetVideoConstraintPublishWebcam(VideoConstraint),
+SetVideoConstraintSubscribe(VideoConstraint),
+SetVideoMaxConcurrentTracks(Option<usize>),
+#+END_SRC
+
+In =browser/src/participant/mod.rs=, replace =set_webcam_resolutions= and =set_webcam_resolution= with:
+
+#+BEGIN_SRC rust
+pub fn set_video_constraint_publish_webcam(&self, value: client_simulator_config::VideoConstraint) {
+    self.send_message(ParticipantMessage::SetVideoConstraintPublishWebcam(value));
+}
+
+pub fn set_video_constraint_subscribe(&self, value: client_simulator_config::VideoConstraint) {
+    self.send_message(ParticipantMessage::SetVideoConstraintSubscribe(value));
+}
+
+pub fn set_video_max_concurrent_tracks(&self, value: Option<usize>) {
+    self.send_message(ParticipantMessage::SetVideoMaxConcurrentTracks(value));
+}
+#+END_SRC
+
+- [ ] Step 5: Apply new settings in Hyper Core frontend automation.
+
+Update imports in =browser/src/participant/frontend/core.rs= to use the new command functions from Task 2. In =apply_all_settings=, replace the old outgoing resolution setter with:
+
+#+BEGIN_SRC rust
+set_video_constraint_publish_webcam(driver, settings.video_constraint_publish_webcam)
+    .await
+    .context("failed to set outgoing webcam video constraint")?;
+set_video_constraint_subscribe(driver, settings.video_constraint_subscribe)
+    .await
+    .context("failed to set incoming video constraint")?;
+set_video_max_concurrent_tracks(driver, settings.video_max_concurrent_tracks)
+    .await
+    .context("failed to set max concurrent video tracks")?;
+#+END_SRC
+
+Replace =set_webcam_resolutions_inner= with three focused setters:
+
+#+BEGIN_SRC rust
+async fn set_video_constraint_publish_webcam_inner(&self, value: VideoConstraint) -> Result<()> {
+    info!(participant = %self.participant_name(), "Changing outgoing webcam video constraint to {value}");
+    set_video_constraint_publish_webcam(self.context.driver.as_ref(), value)
+        .await
+        .context("Failed to set outgoing webcam video constraint")
+}
+
+async fn set_video_constraint_subscribe_inner(&self, value: VideoConstraint) -> Result<()> {
+    info!(participant = %self.participant_name(), "Changing incoming video constraint to {value}");
+    set_video_constraint_subscribe(self.context.driver.as_ref(), value)
+        .await
+        .context("Failed to set incoming video constraint")
+}
+
+async fn set_video_max_concurrent_tracks_inner(&self, value: Option<usize>) -> Result<()> {
+    info!(participant = %self.participant_name(), ?value, "Changing max concurrent video tracks");
+    set_video_max_concurrent_tracks(self.context.driver.as_ref(), value)
+        .await
+        .context("Failed to set max concurrent video tracks")
+}
+#+END_SRC
+
+In =refresh_state_inner=, populate the new state fields:
+
+#+BEGIN_SRC rust
+if let Ok(value) = get_video_constraint_publish_webcam(driver).await {
+    state.video_constraint_publish_webcam = value;
+}
+
+if let Ok(value) = get_video_constraint_subscribe(driver).await {
+    state.video_constraint_subscribe = value;
+}
+
+if let Ok(value) = get_video_max_concurrent_tracks(driver).await {
+    state.video_max_concurrent_tracks = value;
+}
+#+END_SRC
+
+Update =handle_command= to dispatch the three new =ParticipantMessage= variants.
+
+- [ ] Step 6: Update Hyper Lite and remote stub behavior.
+
+In =browser/src/participant/frontend/lite.rs=, make the three new commands return a clear unsupported message matching the old lite behavior:
+
+#+BEGIN_SRC rust
+warn!(
+    participant = %self.participant_name(),
+    "Video constraint changes not supported in lite frontend"
+);
+#+END_SRC
+
+In =browser/src/participant/remote_stub.rs=, initialize and mutate the three new fields:
+
+#+BEGIN_SRC rust
+video_constraint_publish_webcam: self.launch_spec.settings.video_constraint_publish_webcam,
+video_constraint_subscribe: self.launch_spec.settings.video_constraint_subscribe,
+video_max_concurrent_tracks: self.launch_spec.settings.video_max_concurrent_tracks,
+#+END_SRC
+
+and in command handling:
+
+#+BEGIN_SRC rust
+ParticipantMessage::SetVideoConstraintPublishWebcam(value) => {
+    self.state.video_constraint_publish_webcam = value;
+    self.log_message("debug", format!("remote stub set outgoing webcam video constraint to {value}"));
+}
+ParticipantMessage::SetVideoConstraintSubscribe(value) => {
+    self.state.video_constraint_subscribe = value;
+    self.log_message("debug", format!("remote stub set incoming video constraint to {value}"));
+}
+ParticipantMessage::SetVideoMaxConcurrentTracks(value) => {
+    self.state.video_max_concurrent_tracks = value;
+    self.log_message("debug", format!("remote stub set max concurrent video tracks to {value:?}"));
+}
+#+END_SRC
+
+- [ ] Step 7: Run browser runtime tests.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo test -p client-simulator-browser converts_participant_config_to_launch_spec remote_stub
+#+END_SRC
+
+Expected: tests pass or expose remaining direct references to =WebcamResolution= that need replacement.
+
+* Task 4: Replace Headless CLI and Participant JSON Fields
+
+** Files
+
+- Modify: [[file:src/headless.rs][src/headless.rs]]
+
+** Steps
+
+- [ ] Step 1: Write failing headless parsing and override tests.
+
+Update =src/headless.rs= tests so command-line and participant JSON use the new names:
+
+#+BEGIN_SRC rust
+#[test]
+fn cli_parsing_accepts_video_constraint_options() {
+    let cli = TestHeadlessCli::parse_from([
+        "headless",
+        "--video-constraint-publish-webcam",
+        "480p",
+        "--video-constraint-subscribe",
+        "720p",
+        "--video-max-concurrent-tracks",
+        "2",
+        "--participant",
+        r#"{"video_constraint_publish_webcam":"360p","video_constraint_subscribe":"none","video_max_concurrent_tracks":null}"#,
+    ]);
+    let args = cli.args;
+
+    assert_eq!(args.video_constraint_publish_webcam, Some(VideoConstraint::P480));
+    assert_eq!(args.video_constraint_subscribe, Some(VideoConstraint::P720));
+    assert_eq!(args.video_max_concurrent_tracks, Some(Some(2)));
+    assert_eq!(args.participants.len(), 1);
+}
+
+#[test]
+fn participant_json_can_override_video_constraints_to_unlimited() {
+    let global_config = Config {
+        video_constraint_publish_webcam: VideoConstraint::P720,
+        video_constraint_subscribe: VideoConstraint::P720,
+        video_max_concurrent_tracks: Some(2),
+        ..Default::default()
+    };
+
+    let configs = build_participant_configs(
+        global_config,
+        &[r#"{"video_constraint_publish_webcam":"360p","video_constraint_subscribe":"480p","video_max_concurrent_tracks":null}"#.to_string()],
+    )
+    .expect("participant configs");
+
+    assert_eq!(configs[0].video_constraint_publish_webcam, VideoConstraint::P360);
+    assert_eq!(configs[0].video_constraint_subscribe, VideoConstraint::P480);
+    assert_eq!(configs[0].video_max_concurrent_tracks, None);
+}
+#+END_SRC
+
+- [ ] Step 2: Run the failing headless tests.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo test -p hyper-client-simulator headless::tests::cli_parsing_accepts_video_constraint_options headless::tests::participant_json_can_override_video_constraints_to_unlimited
+#+END_SRC
+
+Expected: the command fails because =HeadlessArgs= and =ParticipantOverride= still use =resolution=.
+
+- [ ] Step 3: Replace =HeadlessArgs= fields.
+
+In =src/headless.rs=, replace:
+
+#+BEGIN_SRC rust
+#[clap(long, value_name = "RESOLUTION")]
+pub resolution: Option<WebcamResolution>,
+#+END_SRC
+
+with:
+
+#+BEGIN_SRC rust
+#[clap(long = "video-constraint-publish-webcam", value_name = "CONSTRAINT")]
+pub video_constraint_publish_webcam: Option<VideoConstraint>,
+
+#[clap(long = "video-constraint-subscribe", value_name = "CONSTRAINT")]
+pub video_constraint_subscribe: Option<VideoConstraint>,
+
+#[clap(long = "video-max-concurrent-tracks", value_name = "TRACKS", value_parser = parse_video_max_concurrent_tracks)]
+pub video_max_concurrent_tracks: Option<Option<usize>>,
+#+END_SRC
+
+Add this parser in =src/headless.rs=:
+
+#+BEGIN_SRC rust
+fn parse_video_max_concurrent_tracks(raw: &str) -> Result<Option<usize>, String> {
+    match raw {
+        "none" | "null" | "unlimited" => Ok(None),
+        _ => raw
+            .parse::<usize>()
+            .map(Some)
+            .map_err(|err| format!("expected unlimited/null/none or a non-negative integer: {err}")),
+    }
+}
+#+END_SRC
+
+- [ ] Step 4: Replace participant JSON override fields.
+
+In =ParticipantOverride=, replace =resolution= with:
+
+#+BEGIN_SRC rust
+video_constraint_publish_webcam: Option<VideoConstraint>,
+video_constraint_subscribe: Option<VideoConstraint>,
+video_max_concurrent_tracks: Option<Option<usize>>,
+#+END_SRC
+
+In =apply_cli_overrides= and =apply_participant_override=, set the three =Config= fields. Because =video_max_concurrent_tracks= is nullable, assign when the outer option is present:
+
+#+BEGIN_SRC rust
+if let Some(value) = args.video_max_concurrent_tracks {
+    config.video_max_concurrent_tracks = value;
+}
+
+if let Some(value) = override_.video_max_concurrent_tracks {
+    config.video_max_concurrent_tracks = value;
+}
+#+END_SRC
+
+- [ ] Step 5: Remove old =resolution= headless support.
+
+Delete =resolution= from:
+
+- =HeadlessArgs=
+- =ParticipantOverride=
+- =apply_cli_overrides=
+- =apply_participant_override=
+- headless tests
+
+Then run:
+
+#+BEGIN_SRC bash
+rg -n "\bresolution\b|WebcamResolution" src/headless.rs
+#+END_SRC
+
+Expected: no matches in =src/headless.rs=.
+
+- [ ] Step 6: Run headless tests.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo test -p hyper-client-simulator headless
+#+END_SRC
+
+Expected: all headless tests pass.
+
+* Task 5: Replace TUI Surfaces
+
+** Files
+
+- Modify: [[file:tui/src/tui/components/browser_start.rs][tui/src/tui/components/browser_start.rs]]
+- Modify: [[file:tui/src/tui/components/participants.rs][tui/src/tui/components/participants.rs]]
+
+** Steps
+
+- [ ] Step 1: Replace imports and component fields.
+
+In both files, replace =WebcamResolution= imports and =resolution_list= fields with:
+
+#+BEGIN_SRC rust
+use client_simulator_config::{
+    Config,
+    NoiseSuppression,
+    VideoConstraint,
+    VideoConstraintIter,
+    VideoMaxConcurrentTracksPreset,
+    VideoMaxConcurrentTracksPresetIter,
+};
+#+END_SRC
+
+Use these component fields:
+
+#+BEGIN_SRC rust
+video_constraint_publish_webcam_list: Option<EnumListInput<VideoConstraint>>,
+video_constraint_subscribe_list: Option<EnumListInput<VideoConstraint>>,
+video_max_concurrent_tracks_list: Option<EnumListInput<VideoMaxConcurrentTracksPreset>>,
+#+END_SRC
+
+- [ ] Step 2: Update start-screen labels and selection handlers.
+
+In =browser_start.rs=, replace camera resolution text with:
+
+#+BEGIN_SRC rust
+SelectedField::VideoConstraintPublishWebcam => " Select outgoing webcam max resolution. <enter> to select. ",
+SelectedField::VideoConstraintSubscribe => " Select incoming max resolution. <enter> to select. ",
+SelectedField::VideoMaxConcurrentTracks => " Select max concurrent webcam tracks. <enter> to select. ",
+#+END_SRC
+
+When a preset is selected, assign:
+
+#+BEGIN_SRC rust
+self.config.video_max_concurrent_tracks = value.to_option();
+#+END_SRC
+
+For the current value, derive the preset with:
+
+#+BEGIN_SRC rust
+VideoMaxConcurrentTracksPreset::from_option(self.config.video_max_concurrent_tracks)
+#+END_SRC
+
+- [ ] Step 3: Update participant table columns and live commands.
+
+In =participants.rs=, replace the single camera resolution list with three selection paths:
+
+#+BEGIN_SRC rust
+participant.set_video_constraint_publish_webcam(value);
+participant.set_video_constraint_subscribe(value);
+participant.set_video_max_concurrent_tracks(value.to_option());
+#+END_SRC
+
+Display the state values with:
+
+#+BEGIN_SRC rust
+let publish_constraint = state.video_constraint_publish_webcam.to_string();
+let subscribe_constraint = state.video_constraint_subscribe.to_string();
+let max_tracks = state
+    .video_max_concurrent_tracks
+    .map(|value| value.to_string())
+    .unwrap_or_else(|| "unlimited".to_string());
+#+END_SRC
+
+- [ ] Step 4: Run TUI tests.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo test -p client-simulator-tui
+#+END_SRC
+
+Expected: TUI tests pass and compile errors identify any remaining old field names.
+
+* Task 6: Update Cloudflare Worker Client Contract and Mappings
+
+** Files
+
+- Modify: [[file:cloudflare-worker-client/openapi/cloudflare-browser-simulator.json][cloudflare-worker-client/openapi/cloudflare-browser-simulator.json]]
+- Modify: [[file:cloudflare-worker-client/src/client.rs][cloudflare-worker-client/src/client.rs]]
+- Modify: [[file:browser/src/participant/cloudflare/mod.rs][browser/src/participant/cloudflare/mod.rs]]
+- Modify: [[file:browser/tests/cloudflare_driver.rs][browser/tests/cloudflare_driver.rs]]
+
+** Steps
+
+- [ ] Step 1: Update the OpenAPI schema.
+
+In =ParticipantSettings=, replace the =resolution= property with:
+
+#+BEGIN_SRC json
+"videoConstraintPublishWebcam": {
+  "type": "string",
+  "enum": ["none", "90p", "144p", "240p", "360p", "480p", "720p", "1080p", "1440p", "2160p"]
+},
+"videoConstraintSubscribe": {
+  "type": "string",
+  "enum": ["none", "90p", "144p", "240p", "360p", "480p", "720p", "1080p", "1440p", "2160p"]
+},
+"videoMaxConcurrentTracks": {
+  "type": ["number", "null"],
+  "minimum": 0
+}
+#+END_SRC
+
+Replace =resolution= in =required= with the three new property names.
+
+In =SessionCommandRequest=, replace the =set-webcam-resolution= variant with these three variants:
+
+#+BEGIN_SRC json
+{
+  "type": "object",
+  "properties": {
+    "type": { "type": "string", "enum": ["set-video-constraint-publish-webcam"] },
+    "videoConstraintPublishWebcam": {
+      "type": "string",
+      "enum": ["none", "90p", "144p", "240p", "360p", "480p", "720p", "1080p", "1440p", "2160p"]
+    }
+  },
+  "required": ["type", "videoConstraintPublishWebcam"]
+},
+{
+  "type": "object",
+  "properties": {
+    "type": { "type": "string", "enum": ["set-video-constraint-subscribe"] },
+    "videoConstraintSubscribe": {
+      "type": "string",
+      "enum": ["none", "90p", "144p", "240p", "360p", "480p", "720p", "1080p", "1440p", "2160p"]
+    }
+  },
+  "required": ["type", "videoConstraintSubscribe"]
+},
+{
+  "type": "object",
+  "properties": {
+    "type": { "type": "string", "enum": ["set-video-max-concurrent-tracks"] },
+    "videoMaxConcurrentTracks": {
+      "type": ["number", "null"],
+      "minimum": 0
+    }
+  },
+  "required": ["type", "videoMaxConcurrentTracks"]
+}
+#+END_SRC
+
+If the deployed worker uses different command names, update these strings to match the worker source before running tests. Do not keep =set-webcam-resolution= in the new simulator contract.
+
+- [ ] Step 2: Regenerate and compile the worker client.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo check -p cloudflare-worker-client
+#+END_SRC
+
+Expected: generated types include =ParticipantSettingsVideoConstraintPublishWebcam=, =ParticipantSettingsVideoConstraintSubscribe=, and command variants for all three settings. Compile errors in tests still reference =ParticipantSettingsResolution=.
+
+- [ ] Step 3: Update cloudflare-worker-client tests.
+
+In =cloudflare-worker-client/src/client.rs=, replace imports:
+
+#+BEGIN_SRC rust
+ParticipantSettingsResolution,
+#+END_SRC
+
+with the generated video constraint enum names from the compile output, then update =create_session_request=:
+
+#+BEGIN_SRC rust
+settings: ParticipantSettings {
+    audio_enabled: true,
+    auto_gain_control: true,
+    blur: false,
+    noise_suppression: ParticipantSettingsNoiseSuppression::None,
+    screenshare_enabled: false,
+    transport: ParticipantSettingsTransport::Webrtc,
+    video_constraint_publish_webcam: ParticipantSettingsVideoConstraintPublishWebcam::None,
+    video_constraint_subscribe: ParticipantSettingsVideoConstraintSubscribe::None,
+    video_max_concurrent_tracks: None,
+    video_enabled: true,
+},
+#+END_SRC
+
+Update schema-mismatch fixture JSON to contain the three new state fields if =ParticipantState= is changed in the worker schema.
+
+- [ ] Step 4: Update browser Cloudflare mappings.
+
+In =browser/src/participant/cloudflare/mod.rs=, replace =map_command_webcam_resolution= with:
+
+#+BEGIN_SRC rust
+fn map_video_constraint(value: client_simulator_config::VideoConstraint) -> types::ParticipantSettingsVideoConstraintPublishWebcam {
+    match value {
+        client_simulator_config::VideoConstraint::None => types::ParticipantSettingsVideoConstraintPublishWebcam::None,
+        client_simulator_config::VideoConstraint::P90 => types::ParticipantSettingsVideoConstraintPublishWebcam::P90,
+        client_simulator_config::VideoConstraint::P144 => types::ParticipantSettingsVideoConstraintPublishWebcam::P144,
+        client_simulator_config::VideoConstraint::P240 => types::ParticipantSettingsVideoConstraintPublishWebcam::P240,
+        client_simulator_config::VideoConstraint::P360 => types::ParticipantSettingsVideoConstraintPublishWebcam::P360,
+        client_simulator_config::VideoConstraint::P480 => types::ParticipantSettingsVideoConstraintPublishWebcam::P480,
+        client_simulator_config::VideoConstraint::P720 => types::ParticipantSettingsVideoConstraintPublishWebcam::P720,
+        client_simulator_config::VideoConstraint::P1080 => types::ParticipantSettingsVideoConstraintPublishWebcam::P1080,
+        client_simulator_config::VideoConstraint::P1440 => types::ParticipantSettingsVideoConstraintPublishWebcam::P1440,
+        client_simulator_config::VideoConstraint::P2160 => types::ParticipantSettingsVideoConstraintPublishWebcam::P2160,
+    }
+}
+#+END_SRC
+
+If =progenitor= generates separate enum types for publish and subscribe settings, use two mapping functions with identical match arms:
+
+- =map_video_constraint_publish_webcam= returns =types::ParticipantSettingsVideoConstraintPublishWebcam=.
+- =map_video_constraint_subscribe= returns =types::ParticipantSettingsVideoConstraintSubscribe=.
+
+Update =map_settings=:
+
+#+BEGIN_SRC rust
+video_constraint_publish_webcam: map_video_constraint_publish_webcam(settings.video_constraint_publish_webcam),
+video_constraint_subscribe: map_video_constraint_subscribe(settings.video_constraint_subscribe),
+video_max_concurrent_tracks: settings.video_max_concurrent_tracks.map(|value| value as f64),
+#+END_SRC
+
+Update =command_request= for the three new message variants. Use the generated variant names from =cargo check=, for example:
+
+#+BEGIN_SRC rust
+ParticipantMessage::SetVideoConstraintPublishWebcam(value) => {
+    types::SessionCommandRequest::SetVideoConstraintPublishWebcam {
+        video_constraint_publish_webcam: map_command_video_constraint_publish_webcam(value),
+    }
+}
+ParticipantMessage::SetVideoConstraintSubscribe(value) => {
+    types::SessionCommandRequest::SetVideoConstraintSubscribe {
+        video_constraint_subscribe: map_command_video_constraint_subscribe(value),
+    }
+}
+ParticipantMessage::SetVideoMaxConcurrentTracks(value) => {
+    types::SessionCommandRequest::SetVideoMaxConcurrentTracks {
+        video_max_concurrent_tracks: value.map(|value| value as f64),
+    }
+}
+#+END_SRC
+
+- [ ] Step 5: Update Cloudflare tests and fixtures.
+
+Replace expected JSON:
+
+#+BEGIN_SRC json
+{ "type": "set-webcam-resolution", "webcamResolution": "p1080" }
+#+END_SRC
+
+with three separate command expectations:
+
+#+BEGIN_SRC rust
+json!({ "type": "set-video-constraint-publish-webcam", "videoConstraintPublishWebcam": "1080p" })
+json!({ "type": "set-video-constraint-subscribe", "videoConstraintSubscribe": "720p" })
+json!({ "type": "set-video-max-concurrent-tracks", "videoMaxConcurrentTracks": 2 })
+#+END_SRC
+
+Update worker state fixtures that currently use =webcamResolution= so they use:
+
+#+BEGIN_SRC json
+"videoConstraintPublishWebcam": "720p",
+"videoConstraintSubscribe": "none",
+"videoMaxConcurrentTracks": null
+#+END_SRC
+
+- [ ] Step 6: Run Cloudflare tests.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo test -p cloudflare-worker-client
+cargo test -p client-simulator-browser cloudflare
+#+END_SRC
+
+Expected: both commands pass.
+
+* Task 7: Remove Legacy Resolution References and Run Full Verification
+
+** Files
+
+- Modify any file reported by the search commands in this task.
+
+** Steps
+
+- [ ] Step 1: Search for legacy runtime API references.
+
+Run:
+
+#+BEGIN_SRC bash
+rg -n "videoResolutionForWebcamEncoder|setVideoResolutionForWebcamEncoder|videoResolutionWebcamMedia|setVideoResolutionWebcamMedia" .
+#+END_SRC
+
+Expected: no matches in simulator source. Matches in documentation are acceptable only if they explicitly describe removed legacy behavior.
+
+- [ ] Step 2: Search for old simulator setting names.
+
+Run:
+
+#+BEGIN_SRC bash
+rg -n "\bresolution\b|WebcamResolution|webcam_resolution|SetWebcamResolutions|set_webcam_resolution|webcamResolution|set-webcam-resolution" config/src browser/src tui/src src cloudflare-worker-client browser/tests
+#+END_SRC
+
+Expected: no active simulator code uses old webcam resolution names. Remaining matches must be deliberate comments in this plan or compatibility notes outside active code.
+
+- [ ] Step 3: Run formatting and linting.
+
+Run:
+
+#+BEGIN_SRC bash
+just fmt
+just clippy
+#+END_SRC
+
+Expected: both commands exit 0.
+
+- [ ] Step 4: Run the full test suite.
+
+Run:
+
+#+BEGIN_SRC bash
+just test
+#+END_SRC
+
+Expected: all tests pass.
+
+- [ ] Step 5: Run a live local-backend smoke test against latest.dev.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo run -- headless \
+  --url https://latest.dev.hyper.video/0Y6-6FZ-20J \
+  --participant '{"backend":"local","video_constraint_publish_webcam":"480p","video_constraint_subscribe":"720p","video_max_concurrent_tracks":1}'
+#+END_SRC
+
+Expected:
+
+- Logs do not contain =Failed to apply settings before joining=.
+- Logs do not contain =videoResolutionForWebcamEncoder=.
+- Participant reaches =Joined the space=.
+- The process stays running until Ctrl-C.
+
+- [ ] Step 6: Run a nullable track-limit smoke test.
+
+Run:
+
+#+BEGIN_SRC bash
+cargo run -- headless \
+  --url https://latest.dev.hyper.video/0Y6-6FZ-20J \
+  --participant '{"backend":"local","video_constraint_publish_webcam":"360p","video_constraint_subscribe":"none","video_max_concurrent_tracks":null}'
+#+END_SRC
+
+Expected:
+
+- Logs do not contain =Failed to apply settings before joining=.
+- Live page has =window.hyper.settings.media.videoMaxConcurrentTracks === null=.
+- Ctrl-C performs graceful shutdown.
+
+* Self-Review Checklist
+
+- [ ] Every active simulator path that used =resolution= now has publish constraint, subscribe constraint, and max-track setting coverage.
+- [ ] Local Hyper Core browser automation uses =hyper.settings.media=, not =hyper.settings.videoCodec=, for these settings.
+- [ ] Headless CLI and participant JSON can set =video_max_concurrent_tracks= to both a number and =null=.
+- [ ] TUI can inspect and change the three new values for running participants.
+- [ ] Cloudflare worker schema and mappings no longer serialize =webcamResolution= or =set-webcam-resolution=.
+- [ ] Full verification ran with =just fmt=, =just clippy=, =just test=, and at least one live latest.dev smoke test.

From 61b3e7f1f9bd66b818c9e4278db44fdf12cda402 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Tue, 2 Jun 2026 20:28:14 +0200
Subject: [PATCH 21/42] 2026-06-02-new-video-constraints-support.org v2

---
 2026-06-02-new-video-constraints-support.org | 675 +++++++++++--------
 1 file changed, 383 insertions(+), 292 deletions(-)

diff --git a/2026-06-02-new-video-constraints-support.org b/2026-06-02-new-video-constraints-support.org
index d5d5423..361db74 100644
--- a/2026-06-02-new-video-constraints-support.org
+++ b/2026-06-02-new-video-constraints-support.org
@@ -14,15 +14,32 @@ Replace simulator support for the removed Hyper Core webcam encoder resolution s
 - =videoConstraintSubscribe=: incoming max-resolution option.
 - =videoMaxConcurrentTracks=: max number of outgoing video tracks per local video stream, or =null= for unlimited.
 
+This spans TWO repositories:
+
+1. The simulator: [[file:/Users/robert/projects/shuttle/simulator/hyper-browser-simulator][hyper-browser-simulator]] (this repo).
+2. The Cloudflare worker: [[file:/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator][cloudflare-browser-simulator]] (sibling repo) — the remote backend the simulator's =cloudflare= participant type talks to. The worker is currently broken against the live Hyper SDK anyway: it still calls the removed =hyper.settings.videoCodec.actions.setVideoResolutionForWebcamEncoder= API, so it must be updated regardless.
+
+* Decisions (resolved during planning)
+
+- *Worker:* update the worker repo too, for full parity. The simulator's bundled OpenAPI is generated output, vendored from the worker.
+- *OpenAPI sync:* worker-first. Change worker Zod + controls, run =just export-openapi= (chanfana), then *full re-vendor* of the regenerated JSON into the simulator. The simulator's vendored copy is already stale (=0.3.0= vs worker =0.4.1=), so re-vendoring moves it to the current version and may surface unrelated drift that needs simulator-side fixups.
+- *Deploy:* all worker + simulator code changes and regenerated artifacts land in this work. The outward-facing =just deploy-worker= and the live =cloudflare=-backend smoke test are a MANUAL step the maintainer runs/approves — do not deploy automatically.
+- *Wire casing:* standardize on =1080p= (digits-then-=p=) everywhere — worker Zod, OpenAPI, browser commands. This is the literal string the page's =setVideoConstraintPublishWebcam= expects. Drop the old =p1080= (=p=-then-digits) casing.
+- *Default:* =none= / =none= / =null= (unconstrained), matching the SDK. Closest equivalent to the old =auto=.
+- *Nullable semantics:* =null= = absent = "no override". Fields are plain =Option<usize>= (NOT double-option). Consequence: a participant cannot force a numeric global back to unlimited via CLI/JSON; to get unlimited, omit the field / rely on the default.
+- *Max-tracks presets (TUI):* drop the unreachable =Custom=. Presets are =Unlimited / 1 / 2 / 3 / 4=. Off-list live values (e.g. =8= from config) fall back to =Unlimited= for the selector's preselection only; the table still displays the true number.
+- *Participants table:* replace the single =Resolution= column with ONE combined column (12 columns total, not 14). Format =out:480p in:720p t:2=; unlimited shows =t:∞=. Header "Video constraints".
+- *TUI per-participant edit:* the single =r= key opens a small chooser sub-menu (Outgoing / Incoming / Track limit), then opens the value list for the chosen setting.
+
 * Architecture
 
 Treat the new controls as media settings, not video codec settings. The active local-browser JavaScript API should read and write =window.hyper.settings.media= through =setVideoConstraintPublishWebcam=, =setVideoConstraintSubscribe=, and =setVideoMaxConcurrentTracks=.
 
-Replace the simulator's old single =resolution= setting throughout the active config, participant launch settings, participant state, headless CLI, remote-stub backend, and TUI surfaces. Keep the Cloudflare backend in sync by updating the bundled worker OpenAPI schema and browser-side mapping tests so remote participants receive the same three setting values.
+Replace the simulator's old single =resolution= setting throughout the active config, participant launch settings, participant state, headless CLI, remote-stub backend, and TUI surfaces. Keep the Cloudflare backend in sync by updating the worker's Zod schemas + controls, regenerating the OpenAPI, and re-vendoring it into the simulator so the progenitor-generated client carries the same three setting values.
 
 * Tech Stack
 
-Rust 2021, =serde=, =strum=, =clap=, =tokio=, =chromiumoxide=, =thirtyfour=, generated =cloudflare-worker-client= types from =progenitor=, and the existing =just= recipes.
+Rust 2021, =serde=, =strum=, =clap=, =tokio=, =chromiumoxide=, =thirtyfour=, generated =cloudflare-worker-client= types from =progenitor= (built by =build.rs= over the vendored OpenAPI), and the existing =just= recipes. Worker repo: TypeScript, =zod=, =chanfana= (Zod→OpenAPI), =wrangler=.
 
 * Source Context
 
@@ -49,6 +66,8 @@ export const VIDEO_CONSTRAINT_OPTIONS = {
 } as const;
 #+END_SRC
 
+Note vs the old =WebcamResolution=: the new =VideoConstraint= *adds* =90p=, *drops* =4320p= (8K), and replaces =auto= with =none=. Match the SDK exactly.
+
 The active runtime actions are in [[file:/Users/robert/projects/shuttle/hyper.video-3/frontend/web/sdk/src/media/state/media-settings.tsx][media-settings.tsx]]:
 
 #+BEGIN_SRC typescript
@@ -70,17 +89,30 @@ const CAMERA_RES_GET: &str = "return hyper.settings.videoCodec.videoResolutionFo
 const CAMERA_RES_SET: &str = "hyper.settings.videoCodec.actions.setVideoResolutionForWebcamEncoder(arguments[0]);";
 #+END_SRC
 
+*Precondition for the live smoke tests:* =latest.dev.hyper.video= must run a Hyper build that exposes =hyper.settings.media.actions.setVideoConstraintPublishWebcam= (and the subscribe / max-tracks actions). If the deployed SDK is behind, the live runs in Task 7 will fail even with correct code — confirm the deployed SDK version first.
+
 * File Map
 
-- Modify [[file:config/src/client_config.rs][config/src/client_config.rs]]: add =VideoConstraint= and a CLI/TUI-friendly =VideoMaxConcurrentTracksPreset= helper; stop using =WebcamResolution= for active Hyper Core media settings.
-- Modify [[file:config/src/lib.rs][config/src/lib.rs]]: replace =Config.resolution= with =video_constraint_publish_webcam=, =video_constraint_subscribe=, and =video_max_concurrent_tracks=.
-- Modify [[file:config/src/default-config.yaml][config/src/default-config.yaml]]: default both constraints to =none= and =video_max_concurrent_tracks= to =null= or omitted.
+** Simulator repo
+
+- Modify [[file:config/src/client_config.rs][config/src/client_config.rs]]: add =VideoConstraint= and a CLI/TUI-friendly =VideoMaxConcurrentTracksPreset= helper; remove =WebcamResolution=.
+- Modify [[file:config/src/lib.rs][config/src/lib.rs]]: replace =Config.resolution= with =video_constraint_publish_webcam=, =video_constraint_subscribe=, and =video_max_concurrent_tracks=; update the exported names.
+- Modify [[file:config/src/default-config.yaml][config/src/default-config.yaml]]: default both constraints to =none= and omit =video_max_concurrent_tracks=.
 - Modify [[file:browser/src/participant/frontend/commands.rs][browser/src/participant/frontend/commands.rs]]: replace camera resolution commands with media setting commands and unit tests over a fake =BrowserDriver=.
-- Modify [[file:browser/src/participant/frontend/core.rs][browser/src/participant/frontend/core.rs]]: apply and refresh the three new settings.
-- Modify [[file:browser/src/participant/shared/spec.rs][browser/src/participant/shared/spec.rs]], [[file:browser/src/participant/shared/state.rs][state.rs]], [[file:browser/src/participant/shared/messages.rs][messages.rs]], [[file:browser/src/participant/remote_stub.rs][remote_stub.rs]], and [[file:browser/src/participant/mod.rs][mod.rs]]: thread the new setting names through participant state and commands.
-- Modify [[file:src/headless.rs][src/headless.rs]]: replace =--resolution= and participant JSON =resolution= with the three new fields.
-- Modify [[file:tui/src/tui/components/browser_start.rs][tui/src/tui/components/browser_start.rs]] and [[file:tui/src/tui/components/participants.rs][participants.rs]]: replace the camera resolution selector/table cell with outgoing constraint, incoming constraint, and track-limit controls.
-- Modify [[file:cloudflare-worker-client/openapi/cloudflare-browser-simulator.json][cloudflare-worker-client/openapi/cloudflare-browser-simulator.json]], [[file:cloudflare-worker-client/src/client.rs][client.rs]], and [[file:browser/src/participant/cloudflare/mod.rs][browser/src/participant/cloudflare/mod.rs]]: replace worker schema and mappings for legacy resolution.
+- Modify [[file:browser/src/participant/frontend/core.rs][browser/src/participant/frontend/core.rs]]: apply and refresh the three new settings; dispatch the three new commands.
+- Modify [[file:browser/src/participant/frontend/lite.rs][browser/src/participant/frontend/lite.rs]]: warn-unsupported on the three commands AND replace the hardcoded =refresh_state_inner= resolution default with the three new defaulted fields.
+- Modify [[file:browser/src/participant/shared/spec.rs][spec.rs]], [[file:browser/src/participant/shared/state.rs][state.rs]], [[file:browser/src/participant/shared/messages.rs][messages.rs]], [[file:browser/src/participant/shared/runtime.rs][runtime.rs]], [[file:browser/src/participant/remote_stub.rs][remote_stub.rs]], and [[file:browser/src/participant/mod.rs][mod.rs]]: thread the new setting names through participant state and commands. =runtime.rs= has an exhaustive =ParticipantMessage= match (test mock) that must be updated. =mod.rs= must drop the =set_webcam_resolution= singular alias.
+- Modify [[file:src/headless.rs][src/headless.rs]]: replace =--resolution= and participant JSON =resolution= with the three new fields (plain =Option<usize>= for the track limit).
+- Modify [[file:tui/src/tui/components/browser_start.rs][tui/src/tui/components/browser_start.rs]] and [[file:tui/src/tui/components/participants.rs][participants.rs]]: replace the camera resolution selector/table cell with outgoing constraint, incoming constraint, and track-limit controls (start screen: three fields; participants table: one combined column + chooser sub-menu).
+- Modify [[file:cloudflare-worker-client/openapi/cloudflare-browser-simulator.json][cloudflare-worker-client/openapi/cloudflare-browser-simulator.json]] (re-vendored, not hand-edited), [[file:cloudflare-worker-client/src/client.rs][client.rs]], [[file:browser/src/participant/cloudflare/mod.rs][browser/src/participant/cloudflare/mod.rs]], and [[file:browser/tests/cloudflare_driver.rs][browser/tests/cloudflare_driver.rs]].
+
+** Worker repo (=../cloudflare-browser-simulator=)
+
+- Modify =worker/src/api/schemas.ts=: replace =WebcamResolutionSchema= with =VideoConstraintSchema=; replace =resolution= / =webcamResolution= in =ParticipantSettings= and =ParticipantState= with the three new fields; replace the =set-webcam-resolution= command schema with three new ones and add them to the command union.
+- Modify =worker/src/frontend/core.ts=: replace =setWebcamResolution= in =CoreControls= with three methods that call =hyper.settings.media.actions.*=; update the command switch, the pre-join apply, the state readback (read bare strings + number|null from =hyper.settings.media=), and =buildParticipantState= defaults.
+- Modify =worker/src/frontend/lite.ts=: replace the =setWebcamResolution= stub with three no-op stubs; update the unsupported log, the command cases, and =buildLiteParticipantState= defaults.
+- Modify worker unit tests (=worker/src/*.test.ts=) and the worker CLI smoke test (=cli/src/commands/smoke_test.rs=) fixtures.
+- Regenerate =cli/openapi/cloudflare-browser-simulator.json= and =worker/worker-configuration.d.ts= via the justfile recipes.
 
 * Task 1: Add Config Types and Replace Active Config Fields
 
@@ -94,7 +126,7 @@ const CAMERA_RES_SET: &str = "hyper.settings.videoCodec.actions.setVideoResoluti
 
 - [ ] Step 1: Write failing config type tests.
 
-Add these tests in =config/src/client_config.rs=.
+Replace the existing =tests= module in =config/src/client_config.rs= with:
 
 #+BEGIN_SRC rust
 #[cfg(test)]
@@ -134,10 +166,14 @@ mod tests {
         assert_eq!(VideoMaxConcurrentTracksPreset::Unlimited.to_option(), None);
         assert_eq!(VideoMaxConcurrentTracksPreset::One.to_option(), Some(1));
         assert_eq!(VideoMaxConcurrentTracksPreset::Two.to_option(), Some(2));
+        assert_eq!(VideoMaxConcurrentTracksPreset::Three.to_option(), Some(3));
+        assert_eq!(VideoMaxConcurrentTracksPreset::Four.to_option(), Some(4));
         assert_eq!(VideoMaxConcurrentTracksPreset::from_option(None), VideoMaxConcurrentTracksPreset::Unlimited);
         assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(1)), VideoMaxConcurrentTracksPreset::One);
-        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(2)), VideoMaxConcurrentTracksPreset::Two);
-        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(8)), VideoMaxConcurrentTracksPreset::Custom);
+        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(4)), VideoMaxConcurrentTracksPreset::Four);
+        // Off-list live values fall back to Unlimited for TUI preselection only;
+        // the participants table displays the real number separately.
+        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(8)), VideoMaxConcurrentTracksPreset::Unlimited);
     }
 
     #[test]
@@ -150,24 +186,20 @@ mod tests {
 }
 #+END_SRC
 
-Replace the existing =tests= module instead of creating a duplicate module.
-
 - [ ] Step 2: Run the failing config type tests.
 
-Run:
-
 #+BEGIN_SRC bash
 cargo test -p client-simulator-config video_constraint_round_trips_hyper_media_setting_names video_track_limit_presets_convert_to_nullable_track_counts
 #+END_SRC
 
-Expected: the command fails because =VideoConstraint= and =VideoMaxConcurrentTracksPreset= do not exist.
+Expected: fails because =VideoConstraint= and =VideoMaxConcurrentTracksPreset= do not exist.
 
-- [ ] Step 3: Add the new config enums.
+- [ ] Step 3: Add the new config enums and remove =WebcamResolution=.
 
-Add this near =WebcamResolution= in =config/src/client_config.rs=. Keep =WebcamResolution= only if Cloudflare compatibility tests still need it during the transition; do not use it for active Hyper Core media settings after Task 3.
+In =config/src/client_config.rs=, delete the =WebcamResolution= enum and add:
 
 #+BEGIN_SRC rust
-#[derive(Debug, Default, Clone, Copy, Display, EnumIter, EnumString, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Default, Clone, Copy, Display, EnumIter, EnumString, Serialize, Deserialize, PartialEq, Eq)]
 pub enum VideoConstraint {
     #[default]
     #[strum(to_string = "none")]
@@ -211,8 +243,10 @@ pub enum VideoMaxConcurrentTracksPreset {
     One,
     #[strum(to_string = "2")]
     Two,
-    #[strum(to_string = "custom")]
-    Custom,
+    #[strum(to_string = "3")]
+    Three,
+    #[strum(to_string = "4")]
+    Four,
 }
 
 impl VideoMaxConcurrentTracksPreset {
@@ -221,7 +255,8 @@ impl VideoMaxConcurrentTracksPreset {
             Self::Unlimited => None,
             Self::One => Some(1),
             Self::Two => Some(2),
-            Self::Custom => None,
+            Self::Three => Some(3),
+            Self::Four => Some(4),
         }
     }
 
@@ -230,15 +265,21 @@ impl VideoMaxConcurrentTracksPreset {
             None => Self::Unlimited,
             Some(1) => Self::One,
             Some(2) => Self::Two,
-            Some(_) => Self::Custom,
+            Some(3) => Self::Three,
+            Some(4) => Self::Four,
+            // Off-list values (e.g. set via config/CLI) have no preset; the TUI
+            // selector falls back to Unlimited, while the table shows the real value.
+            Some(_) => Self::Unlimited,
         }
     }
 }
 #+END_SRC
 
-- [ ] Step 4: Export the new types.
+(=WebcamResolution= is removed entirely; nothing keeps it during the transition because Task 6 also replaces the Cloudflare mappings.)
+
+- [ ] Step 4: Update the exports.
 
-Modify the =pub use client_config= block in =config/src/lib.rs=.
+In =config/src/lib.rs=, replace =WebcamResolution, WebcamResolutionIter= in the =pub use client_config= block with:
 
 #+BEGIN_SRC rust
 pub use client_config::{
@@ -274,7 +315,7 @@ pub video_constraint_subscribe: VideoConstraint,
 pub video_max_concurrent_tracks: Option<usize>,
 #+END_SRC
 
-Update =impl config::Source for Config= so the collected source emits only the new fields:
+In =impl config::Source for Config=, replace the =resolution= insert with:
 
 #+BEGIN_SRC rust
 cache.insert(
@@ -290,17 +331,9 @@ if let Some(value) = self.video_max_concurrent_tracks {
 }
 #+END_SRC
 
-Remove the old =resolution= insert from this method.
-
 - [ ] Step 6: Update default YAML.
 
-In =config/src/default-config.yaml=, replace:
-
-#+BEGIN_SRC yaml
-resolution: auto
-#+END_SRC
-
-with:
+In =config/src/default-config.yaml=, replace =resolution: auto= with:
 
 #+BEGIN_SRC yaml
 video_constraint_publish_webcam: none
@@ -310,7 +343,7 @@ video_max_concurrent_tracks:
 
 - [ ] Step 7: Add config deserialization tests.
 
-Add these tests in =config/src/lib.rs=.
+Add to the =tests= module in =config/src/lib.rs=:
 
 #+BEGIN_SRC rust
 #[test]
@@ -347,8 +380,6 @@ fn default_video_max_concurrent_tracks_is_unlimited() {
 
 - [ ] Step 8: Run config tests.
 
-Run:
-
 #+BEGIN_SRC bash
 cargo test -p client-simulator-config
 #+END_SRC
@@ -500,22 +531,30 @@ mod tests {
             )],
         );
     }
+
+    #[tokio::test]
+    async fn reads_integer_valued_max_concurrent_tracks_even_as_float() {
+        // The page may hand back a JSON number that serde sees as a float (e.g. 2.0).
+        let driver = RecordingDriver::with_result(json!(2.0));
+
+        let value = get_video_max_concurrent_tracks(&driver).await.unwrap();
+
+        assert_eq!(value, Some(2));
+    }
 }
 #+END_SRC
 
 - [ ] Step 2: Run the failing browser command tests.
 
-Run:
-
 #+BEGIN_SRC bash
-cargo test -p client-simulator-browser video_constraints_through_media_settings_api gets_video_constraints_from_media_settings_api gets_nullable_video_max_concurrent_tracks
+cargo test -p client-simulator-browser sets_video_constraints_through_media_settings_api gets_video_constraints_from_media_settings_api gets_nullable_video_max_concurrent_tracks reads_integer_valued_max_concurrent_tracks_even_as_float
 #+END_SRC
 
-Expected: the command fails because the new functions and imported types do not exist.
+Expected: fails because the new functions and imported types do not exist.
 
 - [ ] Step 3: Replace the command constants and functions.
 
-In =browser/src/participant/frontend/commands.rs=, import =VideoConstraint= instead of =WebcamResolution= for video constraints:
+Import =VideoConstraint= instead of =WebcamResolution=:
 
 #+BEGIN_SRC rust
 use client_simulator_config::{
@@ -538,7 +577,7 @@ const VIDEO_MAX_CONCURRENT_TRACKS_SET: &str =
     "hyper.settings.media.actions.setVideoMaxConcurrentTracks(arguments[0]);";
 #+END_SRC
 
-Replace =get_outgoing_camera_resolution= and =set_outgoing_camera_resolution= with:
+Replace =get_outgoing_camera_resolution= / =set_outgoing_camera_resolution= with:
 
 #+BEGIN_SRC rust
 pub(super) async fn get_video_constraint_publish_webcam(driver: &dyn BrowserDriver) -> Result<VideoConstraint> {
@@ -567,8 +606,11 @@ pub(super) async fn set_video_constraint_subscribe(driver: &dyn BrowserDriver, v
 }
 
 pub(super) async fn get_video_max_concurrent_tracks(driver: &dyn BrowserDriver) -> Result<Option<usize>> {
+    // Read as a nullable float to tolerate the page returning e.g. `2.0`, then cast.
     let value = driver.eval(VIDEO_MAX_CONCURRENT_TRACKS_GET, None).await?;
-    serde_json::from_value(value).context("failed to read videoMaxConcurrentTracks from eval result")
+    let as_f64: Option<f64> =
+        serde_json::from_value(value).context("failed to read videoMaxConcurrentTracks from eval result")?;
+    Ok(as_f64.map(|value| value as usize))
 }
 
 pub(super) async fn set_video_max_concurrent_tracks(
@@ -581,13 +623,11 @@ pub(super) async fn set_video_max_concurrent_tracks(
 
 - [ ] Step 4: Run browser command tests.
 
-Run:
-
 #+BEGIN_SRC bash
-cargo test -p client-simulator-browser video_constraints
+cargo test -p client-simulator-browser video_constraint
 #+END_SRC
 
-Expected: command tests pass and no remaining test references call =videoResolutionForWebcamEncoder=.
+Expected: command tests pass; no remaining references to =videoResolutionForWebcamEncoder=.
 
 * Task 3: Thread New Settings Through Participant Runtime
 
@@ -596,16 +636,17 @@ Expected: command tests pass and no remaining test references call =videoResolut
 - Modify: [[file:browser/src/participant/shared/spec.rs][browser/src/participant/shared/spec.rs]]
 - Modify: [[file:browser/src/participant/shared/state.rs][browser/src/participant/shared/state.rs]]
 - Modify: [[file:browser/src/participant/shared/messages.rs][browser/src/participant/shared/messages.rs]]
+- Modify: [[file:browser/src/participant/shared/runtime.rs][browser/src/participant/shared/runtime.rs]]
 - Modify: [[file:browser/src/participant/frontend/core.rs][browser/src/participant/frontend/core.rs]]
+- Modify: [[file:browser/src/participant/frontend/lite.rs][browser/src/participant/frontend/lite.rs]]
 - Modify: [[file:browser/src/participant/remote_stub.rs][browser/src/participant/remote_stub.rs]]
 - Modify: [[file:browser/src/participant/mod.rs][browser/src/participant/mod.rs]]
-- Modify: [[file:browser/src/participant/frontend/lite.rs][browser/src/participant/frontend/lite.rs]]
 
 ** Steps
 
 - [ ] Step 1: Write failing launch-spec and state tests.
 
-Update =browser/src/participant/shared/spec.rs= test =converts_participant_config_to_launch_spec= so its config and assertions use all three new fields:
+Update the =spec.rs= test =converts_participant_config_to_launch_spec= so its config and assertions use all three new fields:
 
 #+BEGIN_SRC rust
 let participant_config = ParticipantConfig {
@@ -635,23 +676,15 @@ assert_eq!(spec.settings.video_max_concurrent_tracks, Some(2));
 
 - [ ] Step 2: Run the failing launch-spec test.
 
-Run:
-
 #+BEGIN_SRC bash
 cargo test -p client-simulator-browser converts_participant_config_to_launch_spec
 #+END_SRC
 
-Expected: the test fails because =ParticipantSettings= still has =resolution=.
+Expected: fails because =ParticipantSettings= still has =resolution=.
 
 - [ ] Step 3: Replace participant setting and state fields.
 
-In =browser/src/participant/shared/spec.rs=, replace:
-
-#+BEGIN_SRC rust
-pub(in crate::participant) resolution: WebcamResolution,
-#+END_SRC
-
-with:
+In =spec.rs=, replace =pub(in crate::participant) resolution: WebcamResolution,= with:
 
 #+BEGIN_SRC rust
 pub(in crate::participant) video_constraint_publish_webcam: VideoConstraint,
@@ -659,15 +692,9 @@ pub(in crate::participant) video_constraint_subscribe: VideoConstraint,
 pub(in crate::participant) video_max_concurrent_tracks: Option<usize>,
 #+END_SRC
 
-In =ParticipantSettings::from=, assign the new fields from =app_config=.
-
-In =browser/src/participant/shared/state.rs=, replace:
-
-#+BEGIN_SRC rust
-pub webcam_resolution: WebcamResolution,
-#+END_SRC
+In =ParticipantSettings::from=, assign the three new fields from =app_config=.
 
-with:
+In =state.rs=, replace =pub webcam_resolution: WebcamResolution,= with:
 
 #+BEGIN_SRC rust
 pub video_constraint_publish_webcam: VideoConstraint,
@@ -675,15 +702,9 @@ pub video_constraint_subscribe: VideoConstraint,
 pub video_max_concurrent_tracks: Option<usize>,
 #+END_SRC
 
-- [ ] Step 4: Replace participant commands.
+- [ ] Step 4: Replace participant commands and the public API.
 
-In =browser/src/participant/shared/messages.rs=, replace:
-
-#+BEGIN_SRC rust
-SetWebcamResolutions(WebcamResolution),
-#+END_SRC
-
-with:
+In =messages.rs=, replace =SetWebcamResolutions(WebcamResolution),= with:
 
 #+BEGIN_SRC rust
 SetVideoConstraintPublishWebcam(VideoConstraint),
@@ -691,7 +712,7 @@ SetVideoConstraintSubscribe(VideoConstraint),
 SetVideoMaxConcurrentTracks(Option<usize>),
 #+END_SRC
 
-In =browser/src/participant/mod.rs=, replace =set_webcam_resolutions= and =set_webcam_resolution= with:
+In =mod.rs=, *delete* both =set_webcam_resolutions= and the =set_webcam_resolution= singular alias, and add:
 
 #+BEGIN_SRC rust
 pub fn set_video_constraint_publish_webcam(&self, value: client_simulator_config::VideoConstraint) {
@@ -707,9 +728,11 @@ pub fn set_video_max_concurrent_tracks(&self, value: Option<usize>) {
 }
 #+END_SRC
 
-- [ ] Step 5: Apply new settings in Hyper Core frontend automation.
+In =runtime.rs=, update the exhaustive =ParticipantMessage= match in the test-mock =handle_command= (it currently lists =SetWebcamResolutions(_)= among the no-op arms) so it lists the three new variants instead. This is required for the crate to compile.
 
-Update imports in =browser/src/participant/frontend/core.rs= to use the new command functions from Task 2. In =apply_all_settings=, replace the old outgoing resolution setter with:
+- [ ] Step 5: Apply and refresh new settings in Hyper Core (=core.rs=).
+
+Update imports to the new command functions. In =apply_all_settings=, replace the outgoing-resolution setter with:
 
 #+BEGIN_SRC rust
 set_video_constraint_publish_webcam(driver, settings.video_constraint_publish_webcam)
@@ -748,7 +771,7 @@ async fn set_video_max_concurrent_tracks_inner(&self, value: Option<usize>) -> R
 }
 #+END_SRC
 
-In =refresh_state_inner=, populate the new state fields:
+In =refresh_state_inner=, populate the new state fields (keep the existing =if let Ok(...)= soft-fail pattern):
 
 #+BEGIN_SRC rust
 if let Ok(value) = get_video_constraint_publish_webcam(driver).await {
@@ -764,11 +787,11 @@ if let Ok(value) = get_video_max_concurrent_tracks(driver).await {
 }
 #+END_SRC
 
-Update =handle_command= to dispatch the three new =ParticipantMessage= variants.
+Update =handle_command= to dispatch the three new =ParticipantMessage= variants to the three inner setters.
 
-- [ ] Step 6: Update Hyper Lite and remote stub behavior.
+- [ ] Step 6: Update Hyper Lite (=lite.rs=).
 
-In =browser/src/participant/frontend/lite.rs=, make the three new commands return a clear unsupported message matching the old lite behavior:
+Replace =set_webcam_resolutions_inner= with three no-op inner methods that warn, matching the existing lite pattern:
 
 #+BEGIN_SRC rust
 warn!(
@@ -777,7 +800,19 @@ warn!(
 );
 #+END_SRC
 
-In =browser/src/participant/remote_stub.rs=, initialize and mutate the three new fields:
+Update =handle_command= to dispatch the three new variants to those no-ops.
+
+Also update lite's =refresh_state_inner= — it currently hardcodes =webcam_resolution: WebcamResolution::default()=. Replace that single field with the three new fields, defaulted:
+
+#+BEGIN_SRC rust
+video_constraint_publish_webcam: VideoConstraint::default(),
+video_constraint_subscribe: VideoConstraint::default(),
+video_max_concurrent_tracks: None,
+#+END_SRC
+
+- [ ] Step 7: Update the remote stub (=remote_stub.rs=).
+
+Initialize the three new state fields from =launch_spec.settings=:
 
 #+BEGIN_SRC rust
 video_constraint_publish_webcam: self.launch_spec.settings.video_constraint_publish_webcam,
@@ -785,7 +820,7 @@ video_constraint_subscribe: self.launch_spec.settings.video_constraint_subscribe
 video_max_concurrent_tracks: self.launch_spec.settings.video_max_concurrent_tracks,
 #+END_SRC
 
-and in command handling:
+and handle the three commands:
 
 #+BEGIN_SRC rust
 ParticipantMessage::SetVideoConstraintPublishWebcam(value) => {
@@ -802,18 +837,18 @@ ParticipantMessage::SetVideoMaxConcurrentTracks(value) => {
 }
 #+END_SRC
 
-- [ ] Step 7: Run browser runtime tests.
-
-Run:
+- [ ] Step 8: Run browser runtime tests.
 
 #+BEGIN_SRC bash
 cargo test -p client-simulator-browser converts_participant_config_to_launch_spec remote_stub
 #+END_SRC
 
-Expected: tests pass or expose remaining direct references to =WebcamResolution= that need replacement.
+Expected: tests pass or expose remaining =WebcamResolution= references that need replacement.
 
 * Task 4: Replace Headless CLI and Participant JSON Fields
 
+Note: =null= = absent = "no override" (plain =Option<usize>=). No double-option, no =serde_with=, no custom parser. A participant cannot force unlimited via CLI/JSON when a numeric value is in play; to get unlimited, omit the field / rely on the default.
+
 ** Files
 
 - Modify: [[file:src/headless.rs][src/headless.rs]]
@@ -822,8 +857,6 @@ Expected: tests pass or expose remaining direct references to =WebcamResolution=
 
 - [ ] Step 1: Write failing headless parsing and override tests.
 
-Update =src/headless.rs= tests so command-line and participant JSON use the new names:
-
 #+BEGIN_SRC rust
 #[test]
 fn cli_parsing_accepts_video_constraint_options() {
@@ -836,18 +869,18 @@ fn cli_parsing_accepts_video_constraint_options() {
         "--video-max-concurrent-tracks",
         "2",
         "--participant",
-        r#"{"video_constraint_publish_webcam":"360p","video_constraint_subscribe":"none","video_max_concurrent_tracks":null}"#,
+        r#"{"video_constraint_publish_webcam":"360p","video_constraint_subscribe":"none","video_max_concurrent_tracks":1}"#,
     ]);
     let args = cli.args;
 
     assert_eq!(args.video_constraint_publish_webcam, Some(VideoConstraint::P480));
     assert_eq!(args.video_constraint_subscribe, Some(VideoConstraint::P720));
-    assert_eq!(args.video_max_concurrent_tracks, Some(Some(2)));
+    assert_eq!(args.video_max_concurrent_tracks, Some(2));
     assert_eq!(args.participants.len(), 1);
 }
 
 #[test]
-fn participant_json_can_override_video_constraints_to_unlimited() {
+fn participant_json_overrides_video_constraints_and_treats_null_tracks_as_absent() {
     let global_config = Config {
         video_constraint_publish_webcam: VideoConstraint::P720,
         video_constraint_subscribe: VideoConstraint::P720,
@@ -857,29 +890,45 @@ fn participant_json_can_override_video_constraints_to_unlimited() {
 
     let configs = build_participant_configs(
         global_config,
-        &[r#"{"video_constraint_publish_webcam":"360p","video_constraint_subscribe":"480p","video_max_concurrent_tracks":null}"#.to_string()],
+        &[r#"{"video_constraint_publish_webcam":"360p","video_max_concurrent_tracks":null}"#.to_string()],
     )
     .expect("participant configs");
 
+    // publish overridden; subscribe omitted -> inherits global;
+    // max tracks null is treated as absent -> inherits global Some(2).
     assert_eq!(configs[0].video_constraint_publish_webcam, VideoConstraint::P360);
-    assert_eq!(configs[0].video_constraint_subscribe, VideoConstraint::P480);
-    assert_eq!(configs[0].video_max_concurrent_tracks, None);
+    assert_eq!(configs[0].video_constraint_subscribe, VideoConstraint::P720);
+    assert_eq!(configs[0].video_max_concurrent_tracks, Some(2));
+}
+
+#[test]
+fn participant_json_numeric_tracks_override_global() {
+    let global_config = Config {
+        video_max_concurrent_tracks: None,
+        ..Default::default()
+    };
+
+    let configs = build_participant_configs(
+        global_config,
+        &[r#"{"video_max_concurrent_tracks":3}"#.to_string()],
+    )
+    .expect("participant configs");
+
+    assert_eq!(configs[0].video_max_concurrent_tracks, Some(3));
 }
 #+END_SRC
 
 - [ ] Step 2: Run the failing headless tests.
 
-Run:
-
 #+BEGIN_SRC bash
-cargo test -p hyper-client-simulator headless::tests::cli_parsing_accepts_video_constraint_options headless::tests::participant_json_can_override_video_constraints_to_unlimited
+cargo test -p hyper-client-simulator headless::tests::cli_parsing_accepts_video_constraint_options headless::tests::participant_json_overrides_video_constraints_and_treats_null_tracks_as_absent headless::tests::participant_json_numeric_tracks_override_global
 #+END_SRC
 
-Expected: the command fails because =HeadlessArgs= and =ParticipantOverride= still use =resolution=.
+Expected: fails because =HeadlessArgs= and =ParticipantOverride= still use =resolution=.
 
 - [ ] Step 3: Replace =HeadlessArgs= fields.
 
-In =src/headless.rs=, replace:
+Replace the import of =WebcamResolution= with =VideoConstraint=. Replace:
 
 #+BEGIN_SRC rust
 #[clap(long, value_name = "RESOLUTION")]
@@ -895,68 +944,50 @@ pub video_constraint_publish_webcam: Option<VideoConstraint>,
 #[clap(long = "video-constraint-subscribe", value_name = "CONSTRAINT")]
 pub video_constraint_subscribe: Option<VideoConstraint>,
 
-#[clap(long = "video-max-concurrent-tracks", value_name = "TRACKS", value_parser = parse_video_max_concurrent_tracks)]
-pub video_max_concurrent_tracks: Option<Option<usize>>,
+#[clap(long = "video-max-concurrent-tracks", value_name = "TRACKS")]
+pub video_max_concurrent_tracks: Option<usize>,
 #+END_SRC
 
-Add this parser in =src/headless.rs=:
-
-#+BEGIN_SRC rust
-fn parse_video_max_concurrent_tracks(raw: &str) -> Result<Option<usize>, String> {
-    match raw {
-        "none" | "null" | "unlimited" => Ok(None),
-        _ => raw
-            .parse::<usize>()
-            .map(Some)
-            .map_err(|err| format!("expected unlimited/null/none or a non-negative integer: {err}")),
-    }
-}
-#+END_SRC
+(No custom =value_parser=; a bare integer parses into =usize=. To run unlimited, omit the flag.)
 
-- [ ] Step 4: Replace participant JSON override fields.
+- [ ] Step 4: Replace participant JSON override fields and apply logic.
 
 In =ParticipantOverride=, replace =resolution= with:
 
 #+BEGIN_SRC rust
 video_constraint_publish_webcam: Option<VideoConstraint>,
 video_constraint_subscribe: Option<VideoConstraint>,
-video_max_concurrent_tracks: Option<Option<usize>>,
+video_max_concurrent_tracks: Option<usize>,
 #+END_SRC
 
-In =apply_cli_overrides= and =apply_participant_override=, set the three =Config= fields. Because =video_max_concurrent_tracks= is nullable, assign when the outer option is present:
+In =apply_cli_overrides= and =apply_participant_override=, set the three =Config= fields with the same =if let Some(value)= pattern as the other fields (JSON =null= deserializes to =None= and is skipped):
 
 #+BEGIN_SRC rust
-if let Some(value) = args.video_max_concurrent_tracks {
-    config.video_max_concurrent_tracks = value;
+if let Some(value) = args.video_constraint_publish_webcam {
+    config.video_constraint_publish_webcam = value;
 }
-
-if let Some(value) = override_.video_max_concurrent_tracks {
-    config.video_max_concurrent_tracks = value;
+if let Some(value) = args.video_constraint_subscribe {
+    config.video_constraint_subscribe = value;
+}
+if let Some(value) = args.video_max_concurrent_tracks {
+    config.video_max_concurrent_tracks = Some(value);
 }
 #+END_SRC
 
-- [ ] Step 5: Remove old =resolution= headless support.
-
-Delete =resolution= from:
+(and the analogous block reading from =override_= in =apply_participant_override=.)
 
-- =HeadlessArgs=
-- =ParticipantOverride=
-- =apply_cli_overrides=
-- =apply_participant_override=
-- headless tests
+- [ ] Step 5: Remove old =resolution= headless support.
 
-Then run:
+Delete =resolution= from =HeadlessArgs=, =ParticipantOverride=, =apply_cli_overrides=, =apply_participant_override=, and old tests. Then:
 
 #+BEGIN_SRC bash
 rg -n "\bresolution\b|WebcamResolution" src/headless.rs
 #+END_SRC
 
-Expected: no matches in =src/headless.rs=.
+Expected: no matches.
 
 - [ ] Step 6: Run headless tests.
 
-Run:
-
 #+BEGIN_SRC bash
 cargo test -p hyper-client-simulator headless
 #+END_SRC
@@ -972,9 +1003,9 @@ Expected: all headless tests pass.
 
 ** Steps
 
-- [ ] Step 1: Replace imports and component fields.
+- [ ] Step 1: Replace imports and the start-screen field model.
 
-In both files, replace =WebcamResolution= imports and =resolution_list= fields with:
+In both files, replace the =WebcamResolution= import with:
 
 #+BEGIN_SRC rust
 use client_simulator_config::{
@@ -987,7 +1018,15 @@ use client_simulator_config::{
 };
 #+END_SRC
 
-Use these component fields:
+In =browser_start.rs=, replace the single =SelectedField::Resolution= variant with three variants in the same navigation position (between =Transport= and =BackgroundBlur=):
+
+#+BEGIN_SRC rust
+VideoConstraintPublishWebcam,
+VideoConstraintSubscribe,
+VideoMaxConcurrentTracks,
+#+END_SRC
+
+Update the exhaustive =MoveUp= / =MoveDown= match arms (the circular field order), the per-field render rows (two more =Constraint::Length(1)= rows and two more render blocks), and replace the =resolution_list= field with three list fields:
 
 #+BEGIN_SRC rust
 video_constraint_publish_webcam_list: Option<EnumListInput<VideoConstraint>>,
@@ -997,7 +1036,7 @@ video_max_concurrent_tracks_list: Option<EnumListInput<VideoMaxConcurrentTracksP
 
 - [ ] Step 2: Update start-screen labels and selection handlers.
 
-In =browser_start.rs=, replace camera resolution text with:
+Help text:
 
 #+BEGIN_SRC rust
 SelectedField::VideoConstraintPublishWebcam => " Select outgoing webcam max resolution. <enter> to select. ",
@@ -1005,21 +1044,64 @@ SelectedField::VideoConstraintSubscribe => " Select incoming max resolution. <en
 SelectedField::VideoMaxConcurrentTracks => " Select max concurrent webcam tracks. <enter> to select. ",
 #+END_SRC
 
-When a preset is selected, assign:
+The two constraint lists are seeded from =self.config.video_constraint_*= via =VideoConstraint::iter()=. The track-limit list is seeded from the preset, and on selection writes back through =to_option=:
 
 #+BEGIN_SRC rust
+// open:
+self.video_max_concurrent_tracks_list = Some(EnumListInput::new(
+    "Max concurrent webcam tracks",
+    VideoMaxConcurrentTracksPreset::iter(),
+    VideoMaxConcurrentTracksPreset::from_option(self.config.video_max_concurrent_tracks),
+));
+// on finish:
 self.config.video_max_concurrent_tracks = value.to_option();
 #+END_SRC
 
-For the current value, derive the preset with:
+Update the =Esc=-to-close and =draw= blocks to cover all three lists.
+
+- [ ] Step 3: Participants table — one combined column.
+
+Replace the single =Resolution= header/cell with ONE combined column (table stays at 12 columns). Header "Video constraints"; cell:
+
+#+BEGIN_SRC rust
+let publish = state.video_constraint_publish_webcam.to_string();
+let subscribe = state.video_constraint_subscribe.to_string();
+let tracks = state
+    .video_max_concurrent_tracks
+    .map(|value| value.to_string())
+    .unwrap_or_else(|| "∞".to_string());
+let video_constraints = format!("out:{publish} in:{subscribe} t:{tracks}");
+#+END_SRC
+
+Give the combined column more width than the old 8% (it holds ~22 chars at the extreme, e.g. =out:1080p in:1080p t:∞=) and rebalance the other percentage widths so they still sum to 100. Exact split at implementer discretion (e.g. bump this column to ~16–18% and shave a couple of points each from Name / Created / Noise Suppression / Blur). Truncation on an 80-col terminal is acceptable per the design decision.
+
+- [ ] Step 4: Participants table — per-participant edit via a chooser sub-menu.
+
+Keep the single =r= key. Pressing =r= opens a small chooser listing the three settings; selecting one opens that setting's value list; selecting a value sends the command. Add a chooser enum and the modal state:
 
 #+BEGIN_SRC rust
-VideoMaxConcurrentTracksPreset::from_option(self.config.video_max_concurrent_tracks)
+#[derive(Copy, Clone, Debug, PartialEq, Eq, strum::Display, strum::EnumIter, strum::EnumString)]
+enum VideoSetting {
+    #[strum(to_string = "Outgoing constraint")]
+    PublishWebcam,
+    #[strum(to_string = "Incoming constraint")]
+    Subscribe,
+    #[strum(to_string = "Track limit")]
+    MaxTracks,
+}
+
+// component state:
+video_setting_menu: Option<EnumListInput<VideoSetting>>,
+video_constraint_publish_webcam_list: Option<EnumListInput<VideoConstraint>>,
+video_constraint_subscribe_list: Option<EnumListInput<VideoConstraint>>,
+video_max_concurrent_tracks_list: Option<EnumListInput<VideoMaxConcurrentTracksPreset>>,
 #+END_SRC
 
-- [ ] Step 3: Update participant table columns and live commands.
+Flow:
 
-In =participants.rs=, replace the single camera resolution list with three selection paths:
+1. =r= → open =video_setting_menu= (preselect =PublishWebcam=).
+2. Menu =Enter= → match the chosen =VideoSetting= and open the matching value list, seeded from =selected.state.borrow()= (=from_option= for the track preset).
+3. Value-list =Enter= → send the command:
 
 #+BEGIN_SRC rust
 participant.set_video_constraint_publish_webcam(value);
@@ -1027,118 +1109,150 @@ participant.set_video_constraint_subscribe(value);
 participant.set_video_max_concurrent_tracks(value.to_option());
 #+END_SRC
 
-Display the state values with:
+4. =Esc= closes whichever modal is open; =draw= renders whichever modal is =Some=.
 
-#+BEGIN_SRC rust
-let publish_constraint = state.video_constraint_publish_webcam.to_string();
-let subscribe_constraint = state.video_constraint_subscribe.to_string();
-let max_tracks = state
-    .video_max_concurrent_tracks
-    .map(|value| value.to_string())
-    .unwrap_or_else(|| "unlimited".to_string());
-#+END_SRC
+Update the footer help text, replacing =<r>esolutions= with a single entry such as =<r> video constraints=.
 
-- [ ] Step 4: Run TUI tests.
-
-Run:
+- [ ] Step 5: Run TUI tests.
 
 #+BEGIN_SRC bash
 cargo test -p client-simulator-tui
 #+END_SRC
 
-Expected: TUI tests pass and compile errors identify any remaining old field names.
+Expected: TUI tests pass; compile errors flag any remaining old field names.
 
-* Task 6: Update Cloudflare Worker Client Contract and Mappings
+* Task 6: Update the Cloudflare Worker and Re-Vendor the Contract
 
-** Files
+Order matters: change the worker first, regenerate the OpenAPI from its Zod schemas, then re-vendor into the simulator. Do NOT hand-edit the simulator's vendored JSON — it is generated output. Wire casing is =1080p= throughout.
 
-- Modify: [[file:cloudflare-worker-client/openapi/cloudflare-browser-simulator.json][cloudflare-worker-client/openapi/cloudflare-browser-simulator.json]]
-- Modify: [[file:cloudflare-worker-client/src/client.rs][cloudflare-worker-client/src/client.rs]]
-- Modify: [[file:browser/src/participant/cloudflare/mod.rs][browser/src/participant/cloudflare/mod.rs]]
-- Modify: [[file:browser/tests/cloudflare_driver.rs][browser/tests/cloudflare_driver.rs]]
+** Part A — Worker repo (=../cloudflare-browser-simulator=)
 
-** Steps
+*** Files
 
-- [ ] Step 1: Update the OpenAPI schema.
+- Modify: =worker/src/api/schemas.ts=
+- Modify: =worker/src/frontend/core.ts=
+- Modify: =worker/src/frontend/lite.ts=
+- Modify: worker unit tests =worker/src/*.test.ts=
+- Modify: =cli/src/commands/smoke_test.rs=
+- Regenerate: =cli/openapi/cloudflare-browser-simulator.json=, =worker/worker-configuration.d.ts=
 
-In =ParticipantSettings=, replace the =resolution= property with:
+*** Steps
 
-#+BEGIN_SRC json
-"videoConstraintPublishWebcam": {
-  "type": "string",
-  "enum": ["none", "90p", "144p", "240p", "360p", "480p", "720p", "1080p", "1440p", "2160p"]
-},
-"videoConstraintSubscribe": {
-  "type": "string",
-  "enum": ["none", "90p", "144p", "240p", "360p", "480p", "720p", "1080p", "1440p", "2160p"]
-},
-"videoMaxConcurrentTracks": {
-  "type": ["number", "null"],
-  "minimum": 0
-}
+- [ ] Step 1: Update Zod schemas (=worker/src/api/schemas.ts=).
+
+Replace =WebcamResolutionSchema= with:
+
+#+BEGIN_SRC typescript
+export const VideoConstraintSchema = z.enum([
+  "none", "90p", "144p", "240p", "360p", "480p", "720p", "1080p", "1440p", "2160p",
+]);
 #+END_SRC
 
-Replace =resolution= in =required= with the three new property names.
+In =ParticipantSettingsSchema=, replace =resolution: WebcamResolutionSchema= with:
 
-In =SessionCommandRequest=, replace the =set-webcam-resolution= variant with these three variants:
+#+BEGIN_SRC typescript
+videoConstraintPublishWebcam: VideoConstraintSchema,
+videoConstraintSubscribe: VideoConstraintSchema,
+videoMaxConcurrentTracks: z.number().int().min(0).nullable(),
+#+END_SRC
 
-#+BEGIN_SRC json
-{
-  "type": "object",
-  "properties": {
-    "type": { "type": "string", "enum": ["set-video-constraint-publish-webcam"] },
-    "videoConstraintPublishWebcam": {
-      "type": "string",
-      "enum": ["none", "90p", "144p", "240p", "360p", "480p", "720p", "1080p", "1440p", "2160p"]
-    }
-  },
-  "required": ["type", "videoConstraintPublishWebcam"]
+In =ParticipantStateSchema=, replace =webcamResolution: WebcamResolutionSchema= with the same three fields.
+
+Replace =SetWebcamResolutionCommandSchema= with three command schemas, and add them to the command discriminated union (and remove the old one):
+
+#+BEGIN_SRC typescript
+const SetVideoConstraintPublishWebcamCommandSchema = z.object({
+  type: z.literal("set-video-constraint-publish-webcam"),
+  videoConstraintPublishWebcam: VideoConstraintSchema,
+});
+const SetVideoConstraintSubscribeCommandSchema = z.object({
+  type: z.literal("set-video-constraint-subscribe"),
+  videoConstraintSubscribe: VideoConstraintSchema,
+});
+const SetVideoMaxConcurrentTracksCommandSchema = z.object({
+  type: z.literal("set-video-max-concurrent-tracks"),
+  videoMaxConcurrentTracks: z.number().int().min(0).nullable(),
+});
+#+END_SRC
+
+- [ ] Step 2: Update Core controls and state (=worker/src/frontend/core.ts=).
+
+In =CoreControls=, replace =setWebcamResolution= with three methods. Implement them against =hyper.settings.media= (NOT the removed =videoCodec= API):
+
+#+BEGIN_SRC typescript
+async setVideoConstraintPublishWebcam(value) {
+  await page.evaluate((next) => {
+    const hyper = (globalThis as typeof globalThis & { hyper?: any }).hyper;
+    hyper?.settings?.media?.actions?.setVideoConstraintPublishWebcam?.(next);
+  }, value);
 },
-{
-  "type": "object",
-  "properties": {
-    "type": { "type": "string", "enum": ["set-video-constraint-subscribe"] },
-    "videoConstraintSubscribe": {
-      "type": "string",
-      "enum": ["none", "90p", "144p", "240p", "360p", "480p", "720p", "1080p", "1440p", "2160p"]
-    }
-  },
-  "required": ["type", "videoConstraintSubscribe"]
+async setVideoConstraintSubscribe(value) {
+  await page.evaluate((next) => {
+    const hyper = (globalThis as typeof globalThis & { hyper?: any }).hyper;
+    hyper?.settings?.media?.actions?.setVideoConstraintSubscribe?.(next);
+  }, value);
+},
+async setVideoMaxConcurrentTracks(value) {
+  await page.evaluate((next) => {
+    const hyper = (globalThis as typeof globalThis & { hyper?: any }).hyper;
+    hyper?.settings?.media?.actions?.setVideoMaxConcurrentTracks?.(next);
+  }, value);
 },
-{
-  "type": "object",
-  "properties": {
-    "type": { "type": "string", "enum": ["set-video-max-concurrent-tracks"] },
-    "videoMaxConcurrentTracks": {
-      "type": ["number", "null"],
-      "minimum": 0
-    }
-  },
-  "required": ["type", "videoMaxConcurrentTracks"]
-}
 #+END_SRC
 
-If the deployed worker uses different command names, update these strings to match the worker source before running tests. Do not keep =set-webcam-resolution= in the new simulator contract.
+Update the command switch (three cases), the pre-join settings apply (three calls from =request.settings=), the state readback (read =hyper.settings.media.videoConstraintPublishWebcam= / =videoConstraintSubscribe= as bare strings and =videoMaxConcurrentTracks= as a number|null), and =buildParticipantState= defaults (=none= / =none= / =null=).
+
+- [ ] Step 3: Update Lite (=worker/src/frontend/lite.ts=).
 
-- [ ] Step 2: Regenerate and compile the worker client.
+Replace the =setWebcamResolution= stub with three no-op stubs; update the unsupported log message, the command cases, and =buildLiteParticipantState= defaults (=videoConstraintPublishWebcam: "none"=, =videoConstraintSubscribe: "none"=, =videoMaxConcurrentTracks: null=).
 
-Run:
+- [ ] Step 4: Update worker unit tests.
+
+Update =worker/src/*.test.ts= fixtures/expectations that reference =resolution=, =webcamResolution=, =set-webcam-resolution=, or the =p1080= casing.
+
+- [ ] Step 5: Regenerate the OpenAPI and worker types, fix the worker CLI.
+
+From the worker repo:
 
 #+BEGIN_SRC bash
-cargo check -p cloudflare-worker-client
+just export-openapi
+just generate-worker-types
+#+END_SRC
+
+Update =cli/src/commands/smoke_test.rs= fixtures so the generated client compiles, then:
+
+#+BEGIN_SRC bash
+just check-generated
 #+END_SRC
 
-Expected: generated types include =ParticipantSettingsVideoConstraintPublishWebcam=, =ParticipantSettingsVideoConstraintSubscribe=, and command variants for all three settings. Compile errors in tests still reference =ParticipantSettingsResolution=.
+Expected: =check-generated= passes (OpenAPI + worker types regenerated, =cargo check= clean, no stray git diff).
 
-- [ ] Step 3: Update cloudflare-worker-client tests.
+- [ ] Step 6: Deploy is a MANUAL, maintainer-approved step (see Task 7). Do not run =just deploy-worker= as part of automated execution.
 
-In =cloudflare-worker-client/src/client.rs=, replace imports:
+** Part B — Simulator repo
 
-#+BEGIN_SRC rust
-ParticipantSettingsResolution,
+*** Files
+
+- Modify: [[file:cloudflare-worker-client/openapi/cloudflare-browser-simulator.json][cloudflare-worker-client/openapi/cloudflare-browser-simulator.json]] (re-vendor)
+- Modify: [[file:cloudflare-worker-client/src/client.rs][cloudflare-worker-client/src/client.rs]]
+- Modify: [[file:browser/src/participant/cloudflare/mod.rs][browser/src/participant/cloudflare/mod.rs]]
+- Modify: [[file:browser/tests/cloudflare_driver.rs][browser/tests/cloudflare_driver.rs]]
+
+*** Steps
+
+- [ ] Step 1: Re-vendor the regenerated OpenAPI and regenerate the progenitor client.
+
+#+BEGIN_SRC bash
+cp ../cloudflare-browser-simulator/cli/openapi/cloudflare-browser-simulator.json \
+   cloudflare-worker-client/openapi/cloudflare-browser-simulator.json
+cargo check -p cloudflare-worker-client
 #+END_SRC
 
-with the generated video constraint enum names from the compile output, then update =create_session_request=:
+This moves the vendored copy from =0.3.0= to the current worker version. Expect the full re-vendor to surface unrelated =0.3.0→0.4.x= schema drift — be prepared for additional progenitor type renames that ripple into =client.rs= and =cloudflare/mod.rs=. Note the generated type names (progenitor): expect =ParticipantSettingsVideoConstraintPublishWebcam=, =ParticipantSettingsVideoConstraintSubscribe=, and =SessionCommandRequest::SetVideoConstraintPublishWebcam {{ .. }}= variants (confirm exact names from the compile output).
+
+- [ ] Step 2: Update =cloudflare-worker-client/src/client.rs=.
+
+Replace the =ParticipantSettingsResolution= import/usage. Update =create_session_request=:
 
 #+BEGIN_SRC rust
 settings: ParticipantSettings {
@@ -1155,33 +1269,11 @@ settings: ParticipantSettings {
 },
 #+END_SRC
 
-Update schema-mismatch fixture JSON to contain the three new state fields if =ParticipantState= is changed in the worker schema.
+Update any schema-mismatch fixture JSON to carry the three new =ParticipantState= fields.
 
-- [ ] Step 4: Update browser Cloudflare mappings.
+- [ ] Step 3: Update =browser/src/participant/cloudflare/mod.rs=.
 
-In =browser/src/participant/cloudflare/mod.rs=, replace =map_command_webcam_resolution= with:
-
-#+BEGIN_SRC rust
-fn map_video_constraint(value: client_simulator_config::VideoConstraint) -> types::ParticipantSettingsVideoConstraintPublishWebcam {
-    match value {
-        client_simulator_config::VideoConstraint::None => types::ParticipantSettingsVideoConstraintPublishWebcam::None,
-        client_simulator_config::VideoConstraint::P90 => types::ParticipantSettingsVideoConstraintPublishWebcam::P90,
-        client_simulator_config::VideoConstraint::P144 => types::ParticipantSettingsVideoConstraintPublishWebcam::P144,
-        client_simulator_config::VideoConstraint::P240 => types::ParticipantSettingsVideoConstraintPublishWebcam::P240,
-        client_simulator_config::VideoConstraint::P360 => types::ParticipantSettingsVideoConstraintPublishWebcam::P360,
-        client_simulator_config::VideoConstraint::P480 => types::ParticipantSettingsVideoConstraintPublishWebcam::P480,
-        client_simulator_config::VideoConstraint::P720 => types::ParticipantSettingsVideoConstraintPublishWebcam::P720,
-        client_simulator_config::VideoConstraint::P1080 => types::ParticipantSettingsVideoConstraintPublishWebcam::P1080,
-        client_simulator_config::VideoConstraint::P1440 => types::ParticipantSettingsVideoConstraintPublishWebcam::P1440,
-        client_simulator_config::VideoConstraint::P2160 => types::ParticipantSettingsVideoConstraintPublishWebcam::P2160,
-    }
-}
-#+END_SRC
-
-If =progenitor= generates separate enum types for publish and subscribe settings, use two mapping functions with identical match arms:
-
-- =map_video_constraint_publish_webcam= returns =types::ParticipantSettingsVideoConstraintPublishWebcam=.
-- =map_video_constraint_subscribe= returns =types::ParticipantSettingsVideoConstraintSubscribe=.
+Replace =map_command_webcam_resolution= / the settings match with mapping function(s) over =VideoConstraint=. If progenitor emits distinct publish/subscribe enum types, use two functions with identical arms (=map_video_constraint_publish_webcam=, =map_video_constraint_subscribe=). Each arm maps =VideoConstraint::P1080 => ...::P1080=, etc.
 
 Update =map_settings=:
 
@@ -1191,7 +1283,9 @@ video_constraint_subscribe: map_video_constraint_subscribe(settings.video_constr
 video_max_concurrent_tracks: settings.video_max_concurrent_tracks.map(|value| value as f64),
 #+END_SRC
 
-Update =command_request= for the three new message variants. Use the generated variant names from =cargo check=, for example:
+(=video_max_concurrent_tracks= maps to whatever numeric type progenitor generates — likely =Option<f64>=; cast accordingly.)
+
+Update the state mapping (worker → =ParticipantState=) for the three new fields, and =command_request= for the three new message variants:
 
 #+BEGIN_SRC rust
 ParticipantMessage::SetVideoConstraintPublishWebcam(value) => {
@@ -1211,15 +1305,9 @@ ParticipantMessage::SetVideoMaxConcurrentTracks(value) => {
 }
 #+END_SRC
 
-- [ ] Step 5: Update Cloudflare tests and fixtures.
+- [ ] Step 4: Update Cloudflare tests and fixtures (=browser/tests/cloudflare_driver.rs= and the in-module tests in =cloudflare/mod.rs=).
 
-Replace expected JSON:
-
-#+BEGIN_SRC json
-{ "type": "set-webcam-resolution", "webcamResolution": "p1080" }
-#+END_SRC
-
-with three separate command expectations:
+Replace the old expected command JSON with three:
 
 #+BEGIN_SRC rust
 json!({ "type": "set-video-constraint-publish-webcam", "videoConstraintPublishWebcam": "1080p" })
@@ -1227,7 +1315,7 @@ json!({ "type": "set-video-constraint-subscribe", "videoConstraintSubscribe": "7
 json!({ "type": "set-video-max-concurrent-tracks", "videoMaxConcurrentTracks": 2 })
 #+END_SRC
 
-Update worker state fixtures that currently use =webcamResolution= so they use:
+Update worker state fixtures that used =webcamResolution= so they use:
 
 #+BEGIN_SRC json
 "videoConstraintPublishWebcam": "720p",
@@ -1235,18 +1323,16 @@ Update worker state fixtures that currently use =webcamResolution= so they use:
 "videoMaxConcurrentTracks": null
 #+END_SRC
 
-- [ ] Step 6: Run Cloudflare tests.
-
-Run:
+- [ ] Step 5: Run Cloudflare tests.
 
 #+BEGIN_SRC bash
 cargo test -p cloudflare-worker-client
 cargo test -p client-simulator-browser cloudflare
 #+END_SRC
 
-Expected: both commands pass.
+Expected: both pass.
 
-* Task 7: Remove Legacy Resolution References and Run Full Verification
+* Task 7: Remove Legacy References and Run Full Verification
 
 ** Files
 
@@ -1254,40 +1340,32 @@ Expected: both commands pass.
 
 ** Steps
 
-- [ ] Step 1: Search for legacy runtime API references.
-
-Run:
+- [ ] Step 1: Search for legacy runtime API references (both repos).
 
 #+BEGIN_SRC bash
-rg -n "videoResolutionForWebcamEncoder|setVideoResolutionForWebcamEncoder|videoResolutionWebcamMedia|setVideoResolutionWebcamMedia" .
+rg -n "videoResolutionForWebcamEncoder|setVideoResolutionForWebcamEncoder" . ../cloudflare-browser-simulator
 #+END_SRC
 
-Expected: no matches in simulator source. Matches in documentation are acceptable only if they explicitly describe removed legacy behavior.
+Expected: no matches in active source (simulator or worker). Doc references are acceptable only if they explicitly describe removed legacy behavior.
 
 - [ ] Step 2: Search for old simulator setting names.
 
-Run:
-
 #+BEGIN_SRC bash
 rg -n "\bresolution\b|WebcamResolution|webcam_resolution|SetWebcamResolutions|set_webcam_resolution|webcamResolution|set-webcam-resolution" config/src browser/src tui/src src cloudflare-worker-client browser/tests
 #+END_SRC
 
-Expected: no active simulator code uses old webcam resolution names. Remaining matches must be deliberate comments in this plan or compatibility notes outside active code.
-
-- [ ] Step 3: Run formatting and linting.
+Expected: no active simulator code uses old webcam resolution names.
 
-Run:
+- [ ] Step 3: Format and lint (simulator).
 
 #+BEGIN_SRC bash
 just fmt
 just clippy
 #+END_SRC
 
-Expected: both commands exit 0.
-
-- [ ] Step 4: Run the full test suite.
+Expected: both exit 0.
 
-Run:
+- [ ] Step 4: Run the full simulator test suite.
 
 #+BEGIN_SRC bash
 just test
@@ -1295,9 +1373,17 @@ just test
 
 Expected: all tests pass.
 
-- [ ] Step 5: Run a live local-backend smoke test against latest.dev.
+- [ ] Step 5: MANUAL — deploy the worker and confirm the deployed SDK.
 
-Run:
+This is the outward-facing, maintainer-approved step. From the worker repo:
+
+#+BEGIN_SRC bash
+just deploy-worker
+#+END_SRC
+
+Confirm =latest.dev.hyper.video= runs a Hyper build exposing =hyper.settings.media.actions.setVideoConstraintPublishWebcam= (and subscribe / max-tracks). If the deployed SDK is behind, the live runs below will fail regardless of code correctness.
+
+- [ ] Step 6: Live local-backend smoke test against latest.dev.
 
 #+BEGIN_SRC bash
 cargo run -- headless \
@@ -1312,9 +1398,7 @@ Expected:
 - Participant reaches =Joined the space=.
 - The process stays running until Ctrl-C.
 
-- [ ] Step 6: Run a nullable track-limit smoke test.
-
-Run:
+- [ ] Step 7: Nullable track-limit smoke test.
 
 #+BEGIN_SRC bash
 cargo run -- headless \
@@ -1328,11 +1412,18 @@ Expected:
 - Live page has =window.hyper.settings.media.videoMaxConcurrentTracks === null=.
 - Ctrl-C performs graceful shutdown.
 
+- [ ] Step 8: OPTIONAL — live cloudflare-backend smoke test.
+
+After the worker is deployed, optionally run one participant with =--participant '{"backend":"cloudflare", ...}'= against the deployed worker to confirm the three new commands round-trip end-to-end.
+
 * Self-Review Checklist
 
-- [ ] Every active simulator path that used =resolution= now has publish constraint, subscribe constraint, and max-track setting coverage.
+- [ ] Every active simulator path that used =resolution= now has publish constraint, subscribe constraint, and max-track setting coverage (config, spec, state, messages, runtime, mod, core, lite, remote_stub, headless, TUI, cloudflare).
 - [ ] Local Hyper Core browser automation uses =hyper.settings.media=, not =hyper.settings.videoCodec=, for these settings.
-- [ ] Headless CLI and participant JSON can set =video_max_concurrent_tracks= to both a number and =null=.
-- [ ] TUI can inspect and change the three new values for running participants.
-- [ ] Cloudflare worker schema and mappings no longer serialize =webcamResolution= or =set-webcam-resolution=.
+- [ ] =WebcamResolution= is fully deleted from the simulator (config enum, exports, all usages).
+- [ ] Headless CLI and participant JSON treat =null= / absent as "no override" (plain =Option<usize>=); a numeric value overrides.
+- [ ] TUI start screen exposes three fields; the participants table shows one combined column and edits the three settings via the =r= chooser sub-menu. =Custom= is gone; presets are Unlimited/1/2/3/4.
+- [ ] Worker Zod schemas, controls (=hyper.settings.media=), and lite stub updated; OpenAPI regenerated via =just export-openapi=; =just check-generated= clean.
+- [ ] Simulator re-vendored the regenerated OpenAPI (=0.3.0= → current); progenitor client + mappings updated; wire casing is =1080p=.
+- [ ] Worker deploy + live latest.dev validation performed manually by the maintainer.
 - [ ] Full verification ran with =just fmt=, =just clippy=, =just test=, and at least one live latest.dev smoke test.

From f7166f3d28c291148325412f31c00736b14f09c0 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Wed, 3 Jun 2026 11:59:06 +0200
Subject: [PATCH 22/42] Add video constraint support

Replace webcam resolution configuration with publish and subscribe video constraints plus nullable max concurrent track support across config, browser runtime, headless CLI, TUI, Cloudflare mappings, and generated client artifacts.
---
 Cargo.lock                                    |   1 +
 browser/src/participant/cloudflare/mod.rs     | 276 +++++++++++++-----
 browser/src/participant/frontend/commands.rs  | 198 ++++++++++++-
 browser/src/participant/frontend/core.rs      |  63 +++-
 browser/src/participant/frontend/lite.rs      |  33 ++-
 browser/src/participant/mod.rs                |  12 +-
 browser/src/participant/remote_stub.rs        |  24 +-
 browser/src/participant/shared/messages.rs    |  16 +-
 browser/src/participant/shared/runtime.rs     |   4 +-
 browser/src/participant/shared/spec.rs        |  20 +-
 browser/src/participant/shared/state.rs       |   6 +-
 browser/tests/cloudflare_driver.rs            |  36 ++-
 .../openapi/cloudflare-browser-simulator.json | 170 ++++++++---
 cloudflare-worker-client/src/client.rs        |   9 +-
 config/Cargo.toml                             |   3 +
 config/src/client_config.rs                   | 126 +++++++-
 config/src/default-config.yaml                |   4 +-
 config/src/lib.rs                             |  55 +++-
 src/headless.rs                               |  93 +++++-
 tui/src/tui/components/browser_start.rs       | 207 +++++++++++--
 tui/src/tui/components/participants.rs        | 185 +++++++++---
 tui/src/tui/layout.rs                         |   6 +-
 22 files changed, 1277 insertions(+), 270 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 208152b..7ea53c8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -835,6 +835,7 @@ dependencies = [
  "names",
  "reqwest",
  "serde",
+ "serde_json",
  "sha1 0.11.0",
  "strum 0.28.0",
  "temp-dir",
diff --git a/browser/src/participant/cloudflare/mod.rs b/browser/src/participant/cloudflare/mod.rs
index 268e9b1..8531e30 100644
--- a/browser/src/participant/cloudflare/mod.rs
+++ b/browser/src/participant/cloudflare/mod.rs
@@ -310,9 +310,21 @@ impl CloudflareSession {
             ParticipantMessage::SetNoiseSuppression(value) => types::SessionCommandRequest::SetNoiseSuppression {
                 noise_suppression: map_command_noise_suppression(value),
             },
-            ParticipantMessage::SetWebcamResolutions(value) => types::SessionCommandRequest::SetWebcamResolution {
-                webcam_resolution: map_command_webcam_resolution(value),
-            },
+            ParticipantMessage::SetVideoConstraintPublishWebcam(value) => {
+                types::SessionCommandRequest::SetVideoConstraintPublishWebcam {
+                    video_constraint_publish_webcam: map_command_video_constraint_publish_webcam(value),
+                }
+            }
+            ParticipantMessage::SetVideoConstraintSubscribe(value) => {
+                types::SessionCommandRequest::SetVideoConstraintSubscribe {
+                    video_constraint_subscribe: map_command_video_constraint_subscribe(value),
+                }
+            }
+            ParticipantMessage::SetVideoMaxConcurrentTracks(value) => {
+                types::SessionCommandRequest::SetVideoMaxConcurrentTracks {
+                    video_max_concurrent_tracks: value.map(|value| value as u64),
+                }
+            }
             ParticipantMessage::ToggleBackgroundBlur => types::SessionCommandRequest::ToggleBackgroundBlur,
         }
     }
@@ -574,23 +586,14 @@ fn map_settings(settings: &crate::participant::shared::ParticipantSettings) -> t
                 types::ParticipantSettingsNoiseSuppression::AiCousticsRookL48khz
             }
         },
-        resolution: match settings.resolution {
-            client_simulator_config::WebcamResolution::Auto => types::ParticipantSettingsResolution::Auto,
-            client_simulator_config::WebcamResolution::P144 => types::ParticipantSettingsResolution::P144,
-            client_simulator_config::WebcamResolution::P240 => types::ParticipantSettingsResolution::P240,
-            client_simulator_config::WebcamResolution::P360 => types::ParticipantSettingsResolution::P360,
-            client_simulator_config::WebcamResolution::P480 => types::ParticipantSettingsResolution::P480,
-            client_simulator_config::WebcamResolution::P720 => types::ParticipantSettingsResolution::P720,
-            client_simulator_config::WebcamResolution::P1080 => types::ParticipantSettingsResolution::P1080,
-            client_simulator_config::WebcamResolution::P1440 => types::ParticipantSettingsResolution::P1440,
-            client_simulator_config::WebcamResolution::P2160 => types::ParticipantSettingsResolution::P2160,
-            client_simulator_config::WebcamResolution::P4320 => types::ParticipantSettingsResolution::P4320,
-        },
         screenshare_enabled: settings.screenshare_enabled,
         transport: match settings.transport {
             client_simulator_config::TransportMode::WebRTC => types::ParticipantSettingsTransport::Webrtc,
             client_simulator_config::TransportMode::WebTransport => types::ParticipantSettingsTransport::Webtransport,
         },
+        video_constraint_publish_webcam: map_video_constraint_publish_webcam(settings.video_constraint_publish_webcam),
+        video_constraint_subscribe: map_video_constraint_subscribe(settings.video_constraint_subscribe),
+        video_max_concurrent_tracks: settings.video_max_concurrent_tracks.map(|value| value as u64),
         video_enabled: settings.video_enabled,
     }
 }
@@ -652,18 +655,11 @@ fn map_state(state: &types::ParticipantState) -> ParticipantState {
             types::ParticipantStateTransportMode::Webrtc => client_simulator_config::TransportMode::WebRTC,
             types::ParticipantStateTransportMode::Webtransport => client_simulator_config::TransportMode::WebTransport,
         },
-        webcam_resolution: match state.webcam_resolution {
-            types::ParticipantStateWebcamResolution::Auto => client_simulator_config::WebcamResolution::Auto,
-            types::ParticipantStateWebcamResolution::P144 => client_simulator_config::WebcamResolution::P144,
-            types::ParticipantStateWebcamResolution::P240 => client_simulator_config::WebcamResolution::P240,
-            types::ParticipantStateWebcamResolution::P360 => client_simulator_config::WebcamResolution::P360,
-            types::ParticipantStateWebcamResolution::P480 => client_simulator_config::WebcamResolution::P480,
-            types::ParticipantStateWebcamResolution::P720 => client_simulator_config::WebcamResolution::P720,
-            types::ParticipantStateWebcamResolution::P1080 => client_simulator_config::WebcamResolution::P1080,
-            types::ParticipantStateWebcamResolution::P1440 => client_simulator_config::WebcamResolution::P1440,
-            types::ParticipantStateWebcamResolution::P2160 => client_simulator_config::WebcamResolution::P2160,
-            types::ParticipantStateWebcamResolution::P4320 => client_simulator_config::WebcamResolution::P4320,
-        },
+        video_constraint_publish_webcam: map_state_video_constraint_publish_webcam(
+            state.video_constraint_publish_webcam,
+        ),
+        video_constraint_subscribe: map_state_video_constraint_subscribe(state.video_constraint_subscribe),
+        video_max_concurrent_tracks: state.video_max_concurrent_tracks.map(|value| value as usize),
         background_blur: state.background_blur,
         screenshare_activated: state.screenshare_activated,
     }
@@ -719,20 +715,129 @@ fn map_command_noise_suppression(
     }
 }
 
-fn map_command_webcam_resolution(
-    webcam_resolution: client_simulator_config::WebcamResolution,
-) -> types::SessionCommandRequestWebcamResolution {
-    match webcam_resolution {
-        client_simulator_config::WebcamResolution::Auto => types::SessionCommandRequestWebcamResolution::Auto,
-        client_simulator_config::WebcamResolution::P144 => types::SessionCommandRequestWebcamResolution::P144,
-        client_simulator_config::WebcamResolution::P240 => types::SessionCommandRequestWebcamResolution::P240,
-        client_simulator_config::WebcamResolution::P360 => types::SessionCommandRequestWebcamResolution::P360,
-        client_simulator_config::WebcamResolution::P480 => types::SessionCommandRequestWebcamResolution::P480,
-        client_simulator_config::WebcamResolution::P720 => types::SessionCommandRequestWebcamResolution::P720,
-        client_simulator_config::WebcamResolution::P1080 => types::SessionCommandRequestWebcamResolution::P1080,
-        client_simulator_config::WebcamResolution::P1440 => types::SessionCommandRequestWebcamResolution::P1440,
-        client_simulator_config::WebcamResolution::P2160 => types::SessionCommandRequestWebcamResolution::P2160,
-        client_simulator_config::WebcamResolution::P4320 => types::SessionCommandRequestWebcamResolution::P4320,
+fn map_video_constraint_publish_webcam(
+    value: client_simulator_config::VideoConstraint,
+) -> types::ParticipantSettingsVideoConstraintPublishWebcam {
+    match value {
+        client_simulator_config::VideoConstraint::None => types::ParticipantSettingsVideoConstraintPublishWebcam::None,
+        client_simulator_config::VideoConstraint::P90 => types::ParticipantSettingsVideoConstraintPublishWebcam::X90p,
+        client_simulator_config::VideoConstraint::P144 => types::ParticipantSettingsVideoConstraintPublishWebcam::X144p,
+        client_simulator_config::VideoConstraint::P240 => types::ParticipantSettingsVideoConstraintPublishWebcam::X240p,
+        client_simulator_config::VideoConstraint::P360 => types::ParticipantSettingsVideoConstraintPublishWebcam::X360p,
+        client_simulator_config::VideoConstraint::P480 => types::ParticipantSettingsVideoConstraintPublishWebcam::X480p,
+        client_simulator_config::VideoConstraint::P720 => types::ParticipantSettingsVideoConstraintPublishWebcam::X720p,
+        client_simulator_config::VideoConstraint::P1080 => {
+            types::ParticipantSettingsVideoConstraintPublishWebcam::X1080p
+        }
+        client_simulator_config::VideoConstraint::P1440 => {
+            types::ParticipantSettingsVideoConstraintPublishWebcam::X1440p
+        }
+        client_simulator_config::VideoConstraint::P2160 => {
+            types::ParticipantSettingsVideoConstraintPublishWebcam::X2160p
+        }
+    }
+}
+
+fn map_video_constraint_subscribe(
+    value: client_simulator_config::VideoConstraint,
+) -> types::ParticipantSettingsVideoConstraintSubscribe {
+    match value {
+        client_simulator_config::VideoConstraint::None => types::ParticipantSettingsVideoConstraintSubscribe::None,
+        client_simulator_config::VideoConstraint::P90 => types::ParticipantSettingsVideoConstraintSubscribe::X90p,
+        client_simulator_config::VideoConstraint::P144 => types::ParticipantSettingsVideoConstraintSubscribe::X144p,
+        client_simulator_config::VideoConstraint::P240 => types::ParticipantSettingsVideoConstraintSubscribe::X240p,
+        client_simulator_config::VideoConstraint::P360 => types::ParticipantSettingsVideoConstraintSubscribe::X360p,
+        client_simulator_config::VideoConstraint::P480 => types::ParticipantSettingsVideoConstraintSubscribe::X480p,
+        client_simulator_config::VideoConstraint::P720 => types::ParticipantSettingsVideoConstraintSubscribe::X720p,
+        client_simulator_config::VideoConstraint::P1080 => types::ParticipantSettingsVideoConstraintSubscribe::X1080p,
+        client_simulator_config::VideoConstraint::P1440 => types::ParticipantSettingsVideoConstraintSubscribe::X1440p,
+        client_simulator_config::VideoConstraint::P2160 => types::ParticipantSettingsVideoConstraintSubscribe::X2160p,
+    }
+}
+
+fn map_state_video_constraint_publish_webcam(
+    value: types::ParticipantStateVideoConstraintPublishWebcam,
+) -> client_simulator_config::VideoConstraint {
+    match value {
+        types::ParticipantStateVideoConstraintPublishWebcam::None => client_simulator_config::VideoConstraint::None,
+        types::ParticipantStateVideoConstraintPublishWebcam::X90p => client_simulator_config::VideoConstraint::P90,
+        types::ParticipantStateVideoConstraintPublishWebcam::X144p => client_simulator_config::VideoConstraint::P144,
+        types::ParticipantStateVideoConstraintPublishWebcam::X240p => client_simulator_config::VideoConstraint::P240,
+        types::ParticipantStateVideoConstraintPublishWebcam::X360p => client_simulator_config::VideoConstraint::P360,
+        types::ParticipantStateVideoConstraintPublishWebcam::X480p => client_simulator_config::VideoConstraint::P480,
+        types::ParticipantStateVideoConstraintPublishWebcam::X720p => client_simulator_config::VideoConstraint::P720,
+        types::ParticipantStateVideoConstraintPublishWebcam::X1080p => client_simulator_config::VideoConstraint::P1080,
+        types::ParticipantStateVideoConstraintPublishWebcam::X1440p => client_simulator_config::VideoConstraint::P1440,
+        types::ParticipantStateVideoConstraintPublishWebcam::X2160p => client_simulator_config::VideoConstraint::P2160,
+    }
+}
+
+fn map_state_video_constraint_subscribe(
+    value: types::ParticipantStateVideoConstraintSubscribe,
+) -> client_simulator_config::VideoConstraint {
+    match value {
+        types::ParticipantStateVideoConstraintSubscribe::None => client_simulator_config::VideoConstraint::None,
+        types::ParticipantStateVideoConstraintSubscribe::X90p => client_simulator_config::VideoConstraint::P90,
+        types::ParticipantStateVideoConstraintSubscribe::X144p => client_simulator_config::VideoConstraint::P144,
+        types::ParticipantStateVideoConstraintSubscribe::X240p => client_simulator_config::VideoConstraint::P240,
+        types::ParticipantStateVideoConstraintSubscribe::X360p => client_simulator_config::VideoConstraint::P360,
+        types::ParticipantStateVideoConstraintSubscribe::X480p => client_simulator_config::VideoConstraint::P480,
+        types::ParticipantStateVideoConstraintSubscribe::X720p => client_simulator_config::VideoConstraint::P720,
+        types::ParticipantStateVideoConstraintSubscribe::X1080p => client_simulator_config::VideoConstraint::P1080,
+        types::ParticipantStateVideoConstraintSubscribe::X1440p => client_simulator_config::VideoConstraint::P1440,
+        types::ParticipantStateVideoConstraintSubscribe::X2160p => client_simulator_config::VideoConstraint::P2160,
+    }
+}
+
+fn map_command_video_constraint_publish_webcam(
+    value: client_simulator_config::VideoConstraint,
+) -> types::SessionCommandRequestVideoConstraintPublishWebcam {
+    match value {
+        client_simulator_config::VideoConstraint::None => {
+            types::SessionCommandRequestVideoConstraintPublishWebcam::None
+        }
+        client_simulator_config::VideoConstraint::P90 => types::SessionCommandRequestVideoConstraintPublishWebcam::X90p,
+        client_simulator_config::VideoConstraint::P144 => {
+            types::SessionCommandRequestVideoConstraintPublishWebcam::X144p
+        }
+        client_simulator_config::VideoConstraint::P240 => {
+            types::SessionCommandRequestVideoConstraintPublishWebcam::X240p
+        }
+        client_simulator_config::VideoConstraint::P360 => {
+            types::SessionCommandRequestVideoConstraintPublishWebcam::X360p
+        }
+        client_simulator_config::VideoConstraint::P480 => {
+            types::SessionCommandRequestVideoConstraintPublishWebcam::X480p
+        }
+        client_simulator_config::VideoConstraint::P720 => {
+            types::SessionCommandRequestVideoConstraintPublishWebcam::X720p
+        }
+        client_simulator_config::VideoConstraint::P1080 => {
+            types::SessionCommandRequestVideoConstraintPublishWebcam::X1080p
+        }
+        client_simulator_config::VideoConstraint::P1440 => {
+            types::SessionCommandRequestVideoConstraintPublishWebcam::X1440p
+        }
+        client_simulator_config::VideoConstraint::P2160 => {
+            types::SessionCommandRequestVideoConstraintPublishWebcam::X2160p
+        }
+    }
+}
+
+fn map_command_video_constraint_subscribe(
+    value: client_simulator_config::VideoConstraint,
+) -> types::SessionCommandRequestVideoConstraintSubscribe {
+    match value {
+        client_simulator_config::VideoConstraint::None => types::SessionCommandRequestVideoConstraintSubscribe::None,
+        client_simulator_config::VideoConstraint::P90 => types::SessionCommandRequestVideoConstraintSubscribe::X90p,
+        client_simulator_config::VideoConstraint::P144 => types::SessionCommandRequestVideoConstraintSubscribe::X144p,
+        client_simulator_config::VideoConstraint::P240 => types::SessionCommandRequestVideoConstraintSubscribe::X240p,
+        client_simulator_config::VideoConstraint::P360 => types::SessionCommandRequestVideoConstraintSubscribe::X360p,
+        client_simulator_config::VideoConstraint::P480 => types::SessionCommandRequestVideoConstraintSubscribe::X480p,
+        client_simulator_config::VideoConstraint::P720 => types::SessionCommandRequestVideoConstraintSubscribe::X720p,
+        client_simulator_config::VideoConstraint::P1080 => types::SessionCommandRequestVideoConstraintSubscribe::X1080p,
+        client_simulator_config::VideoConstraint::P1440 => types::SessionCommandRequestVideoConstraintSubscribe::X1440p,
+        client_simulator_config::VideoConstraint::P2160 => types::SessionCommandRequestVideoConstraintSubscribe::X2160p,
     }
 }
 
@@ -770,7 +875,7 @@ mod tests {
         CloudflareConfig,
         NoiseSuppression,
         TransportMode,
-        WebcamResolution,
+        VideoConstraint,
     };
     use serde_json::{
         json,
@@ -831,7 +936,9 @@ mod tests {
                         "autoGainControl": true,
                         "noiseSuppression": "rnnoise",
                         "transportMode": "webrtc",
-                        "webcamResolution": "p720",
+                        "videoConstraintPublishWebcam": "720p",
+                        "videoConstraintSubscribe": "none",
+                        "videoMaxConcurrentTracks": null,
                         "backgroundBlur": true
                     },
                     "log": [
@@ -883,7 +990,9 @@ mod tests {
         assert!(state.joined);
         assert_eq!(state.noise_suppression, NoiseSuppression::RNNoise);
         assert_eq!(state.transport_mode, TransportMode::WebRTC);
-        assert_eq!(state.webcam_resolution, WebcamResolution::P720);
+        assert_eq!(state.video_constraint_publish_webcam, VideoConstraint::P720);
+        assert_eq!(state.video_constraint_subscribe, VideoConstraint::None);
+        assert_eq!(state.video_max_concurrent_tracks, None);
         assert!(state.auto_gain_control);
         assert!(state.background_blur);
 
@@ -925,9 +1034,11 @@ mod tests {
                     "autoGainControl": true,
                     "blur": true,
                     "noiseSuppression": "rnnoise",
-                    "resolution": "p720",
                     "screenshareEnabled": false,
                     "transport": "webrtc",
+                    "videoConstraintPublishWebcam": "720p",
+                    "videoConstraintSubscribe": "none",
+                    "videoMaxConcurrentTracks": null,
                     "videoEnabled": true
                 }
             })
@@ -954,7 +1065,9 @@ mod tests {
                         "autoGainControl": true,
                         "noiseSuppression": "ai-coustics-rook-s-48khz",
                         "transportMode": "webrtc",
-                        "webcamResolution": "p720",
+                        "videoConstraintPublishWebcam": "720p",
+                        "videoConstraintSubscribe": "none",
+                        "videoMaxConcurrentTracks": null,
                         "backgroundBlur": true
                     },
                     "log": [],
@@ -1007,7 +1120,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-commands",
-                    "state": worker_state_json(false, false, false, false, true, "none", "auto", false),
+                    "state": worker_state_json(false, false, false, false, true, "none", "none", false),
                     "log": [],
                 }),
             ),
@@ -1016,7 +1129,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-commands",
-                    "state": worker_state_json(true, false, false, false, true, "none", "auto", false),
+                    "state": worker_state_json(true, false, false, false, true, "none", "none", false),
                     "log": [],
                 }),
             ),
@@ -1025,7 +1138,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-commands",
-                    "state": worker_state_json(true, true, false, false, true, "none", "auto", false),
+                    "state": worker_state_json(true, true, false, false, true, "none", "none", false),
                     "log": [],
                 }),
             ),
@@ -1034,7 +1147,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-commands",
-                    "state": worker_state_json(true, true, true, false, true, "none", "auto", false),
+                    "state": worker_state_json(true, true, true, false, true, "none", "none", false),
                     "log": [],
                 }),
             ),
@@ -1043,7 +1156,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-commands",
-                    "state": worker_state_json(true, true, true, true, true, "none", "auto", false),
+                    "state": worker_state_json(true, true, true, true, true, "none", "none", false),
                     "log": [],
                 }),
             ),
@@ -1052,7 +1165,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-commands",
-                    "state": worker_state_json(true, true, true, true, false, "none", "auto", false),
+                    "state": worker_state_json(true, true, true, true, false, "none", "none", false),
                     "log": [],
                 }),
             ),
@@ -1061,7 +1174,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-commands",
-                    "state": worker_state_json(true, true, true, true, false, "deepfilternet", "auto", false),
+                    "state": worker_state_json(true, true, true, true, false, "deepfilternet", "none", false),
                     "log": [],
                 }),
             ),
@@ -1070,7 +1183,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-commands",
-                    "state": worker_state_json(true, true, true, true, false, "deepfilternet", "p1080", false),
+                    "state": worker_state_json(true, true, true, true, false, "deepfilternet", "1080p", false),
                     "log": [],
                 }),
             ),
@@ -1079,7 +1192,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-commands",
-                    "state": worker_state_json(true, true, true, true, false, "deepfilternet", "p1080", true),
+                    "state": worker_state_json(true, true, true, true, false, "deepfilternet", "1080p", true),
                     "log": [],
                 }),
             ),
@@ -1088,7 +1201,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-commands",
-                    "state": worker_state_json(false, true, true, false, false, "deepfilternet", "p1080", true),
+                    "state": worker_state_json(false, true, true, false, false, "deepfilternet", "1080p", true),
                     "log": [],
                 }),
             ),
@@ -1134,7 +1247,7 @@ mod tests {
                     false,
                     true,
                     NoiseSuppression::Disabled,
-                    WebcamResolution::Auto,
+                    VideoConstraint::None,
                     false,
                 ),
             ),
@@ -1148,7 +1261,7 @@ mod tests {
                     false,
                     true,
                     NoiseSuppression::Disabled,
-                    WebcamResolution::Auto,
+                    VideoConstraint::None,
                     false,
                 ),
             ),
@@ -1162,7 +1275,7 @@ mod tests {
                     false,
                     true,
                     NoiseSuppression::Disabled,
-                    WebcamResolution::Auto,
+                    VideoConstraint::None,
                     false,
                 ),
             ),
@@ -1176,7 +1289,7 @@ mod tests {
                     true,
                     true,
                     NoiseSuppression::Disabled,
-                    WebcamResolution::Auto,
+                    VideoConstraint::None,
                     false,
                 ),
             ),
@@ -1190,7 +1303,7 @@ mod tests {
                     true,
                     false,
                     NoiseSuppression::Disabled,
-                    WebcamResolution::Auto,
+                    VideoConstraint::None,
                     false,
                 ),
             ),
@@ -1204,13 +1317,13 @@ mod tests {
                     true,
                     false,
                     NoiseSuppression::Deepfilternet,
-                    WebcamResolution::Auto,
+                    VideoConstraint::None,
                     false,
                 ),
             ),
             (
-                ParticipantMessage::SetWebcamResolutions(WebcamResolution::P1080),
-                json!({ "type": "set-webcam-resolution", "webcamResolution": "p1080" }),
+                ParticipantMessage::SetVideoConstraintPublishWebcam(VideoConstraint::P1080),
+                json!({ "type": "set-video-constraint-publish-webcam", "videoConstraintPublishWebcam": "1080p" }),
                 expected_state(
                     true,
                     true,
@@ -1218,7 +1331,7 @@ mod tests {
                     true,
                     false,
                     NoiseSuppression::Deepfilternet,
-                    WebcamResolution::P1080,
+                    VideoConstraint::P1080,
                     false,
                 ),
             ),
@@ -1232,7 +1345,7 @@ mod tests {
                     true,
                     false,
                     NoiseSuppression::Deepfilternet,
-                    WebcamResolution::P1080,
+                    VideoConstraint::P1080,
                     true,
                 ),
             ),
@@ -1246,7 +1359,7 @@ mod tests {
                     false,
                     false,
                     NoiseSuppression::Deepfilternet,
-                    WebcamResolution::P1080,
+                    VideoConstraint::P1080,
                     true,
                 ),
             ),
@@ -1286,7 +1399,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-webrtc",
-                    "state": worker_state_json(false, false, false, false, true, "rnnoise", "p720", true),
+                    "state": worker_state_json(false, false, false, false, true, "rnnoise", "720p", true),
                     "log": [],
                 }),
             ),
@@ -1351,7 +1464,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-limitations",
-                    "state": worker_state_json(false, false, false, false, true, "rnnoise", "p720", true),
+                    "state": worker_state_json(false, false, false, false, true, "rnnoise", "720p", true),
                     "log": [],
                 }),
             ),
@@ -1407,7 +1520,7 @@ mod tests {
                 json!({
                     "ok": true,
                     "sessionId": "cf-session-terminated",
-                    "state": worker_state_json(true, false, false, false, true, "none", "auto", false),
+                    "state": worker_state_json(true, false, false, false, true, "none", "none", false),
                     "log": [],
                 }),
             ),
@@ -1475,7 +1588,9 @@ mod tests {
                 auto_gain_control: true,
                 noise_suppression: NoiseSuppression::RNNoise,
                 transport: TransportMode::WebRTC,
-                resolution: WebcamResolution::P720,
+                video_constraint_publish_webcam: VideoConstraint::P720,
+                video_constraint_subscribe: VideoConstraint::None,
+                video_max_concurrent_tracks: None,
                 blur: true,
             },
         }
@@ -1488,7 +1603,7 @@ mod tests {
         screenshare_activated: bool,
         auto_gain_control: bool,
         noise_suppression: &str,
-        webcam_resolution: &str,
+        video_constraint_publish_webcam: &str,
         background_blur: bool,
     ) -> Value {
         json!({
@@ -1500,7 +1615,9 @@ mod tests {
             "autoGainControl": auto_gain_control,
             "noiseSuppression": noise_suppression,
             "transportMode": "webrtc",
-            "webcamResolution": webcam_resolution,
+            "videoConstraintPublishWebcam": video_constraint_publish_webcam,
+            "videoConstraintSubscribe": "none",
+            "videoMaxConcurrentTracks": null,
             "backgroundBlur": background_blur,
         })
     }
@@ -1512,7 +1629,7 @@ mod tests {
         screenshare_activated: bool,
         auto_gain_control: bool,
         noise_suppression: NoiseSuppression,
-        webcam_resolution: WebcamResolution,
+        video_constraint_publish_webcam: VideoConstraint,
         background_blur: bool,
     ) -> ParticipantState {
         ParticipantState {
@@ -1524,7 +1641,9 @@ mod tests {
             auto_gain_control,
             noise_suppression,
             transport_mode: TransportMode::WebRTC,
-            webcam_resolution,
+            video_constraint_publish_webcam,
+            video_constraint_subscribe: VideoConstraint::None,
+            video_max_concurrent_tracks: None,
             background_blur,
             screenshare_activated,
         }
@@ -1539,7 +1658,12 @@ mod tests {
         assert_eq!(actual.auto_gain_control, expected.auto_gain_control);
         assert_eq!(actual.noise_suppression, expected.noise_suppression);
         assert_eq!(actual.transport_mode, expected.transport_mode);
-        assert_eq!(actual.webcam_resolution, expected.webcam_resolution);
+        assert_eq!(
+            actual.video_constraint_publish_webcam,
+            expected.video_constraint_publish_webcam
+        );
+        assert_eq!(actual.video_constraint_subscribe, expected.video_constraint_subscribe);
+        assert_eq!(actual.video_max_concurrent_tracks, expected.video_max_concurrent_tracks);
         assert_eq!(actual.background_blur, expected.background_blur);
         assert_eq!(actual.screenshare_activated, expected.screenshare_activated);
     }
diff --git a/browser/src/participant/frontend/commands.rs b/browser/src/participant/frontend/commands.rs
index 31f1fa8..b035c1b 100644
--- a/browser/src/participant/frontend/commands.rs
+++ b/browser/src/participant/frontend/commands.rs
@@ -1,7 +1,7 @@
 use super::driver::BrowserDriver;
 use client_simulator_config::{
     NoiseSuppression,
-    WebcamResolution,
+    VideoConstraint,
 };
 use eyre::{
     Context as _,
@@ -15,8 +15,13 @@ const AUTO_GAIN_GET: &str = "return hyper.settings.media.autoGainControl;";
 const AUTO_GAIN_SET: &str = "hyper.settings.media.actions.setAutoGainControl(arguments[0]);";
 const BACKGROUND_BLUR_GET: &str = "return hyper.settings.media.backgroundBlur;";
 const BACKGROUND_BLUR_SET: &str = "hyper.settings.media.actions.setBackgroundBlur(arguments[0]);";
-const CAMERA_RES_GET: &str = "return hyper.settings.videoCodec.videoResolutionForWebcamEncoder.name;";
-const CAMERA_RES_SET: &str = "hyper.settings.videoCodec.actions.setVideoResolutionForWebcamEncoder(arguments[0]);";
+const VIDEO_CONSTRAINT_PUBLISH_GET: &str = "return hyper.settings.media.videoConstraintPublishWebcam;";
+const VIDEO_CONSTRAINT_PUBLISH_SET: &str =
+    "hyper.settings.media.actions.setVideoConstraintPublishWebcam(arguments[0]);";
+const VIDEO_CONSTRAINT_SUBSCRIBE_GET: &str = "return hyper.settings.media.videoConstraintSubscribe;";
+const VIDEO_CONSTRAINT_SUBSCRIBE_SET: &str = "hyper.settings.media.actions.setVideoConstraintSubscribe(arguments[0]);";
+const VIDEO_MAX_CONCURRENT_TRACKS_GET: &str = "return hyper.settings.media.videoMaxConcurrentTracks;";
+const VIDEO_MAX_CONCURRENT_TRACKS_SET: &str = "hyper.settings.media.actions.setVideoMaxConcurrentTracks(arguments[0]);";
 const FORCE_WEBRTC_GET: &str = "return hyper.settings.sessionDebug.forceWebrtc;";
 const FORCE_WEBRTC_SET: &str = "hyper.settings.sessionDebug.actions.setForceWebrtc(arguments[0]);";
 
@@ -63,15 +68,41 @@ pub(super) async fn set_background_blur(driver: &dyn BrowserDriver, value: bool)
     set_value(driver, BACKGROUND_BLUR_SET, value).await
 }
 
-pub(super) async fn get_outgoing_camera_resolution(driver: &dyn BrowserDriver) -> Result<WebcamResolution> {
-    get_string(driver, CAMERA_RES_GET)
+pub(super) async fn get_video_constraint_publish_webcam(driver: &dyn BrowserDriver) -> Result<VideoConstraint> {
+    get_string(driver, VIDEO_CONSTRAINT_PUBLISH_GET)
         .await?
-        .parse::<WebcamResolution>()
-        .context("failed to parse WebcamResolution from string")
+        .parse::<VideoConstraint>()
+        .context("failed to parse videoConstraintPublishWebcam from string")
 }
 
-pub(super) async fn set_outgoing_camera_resolution(driver: &dyn BrowserDriver, value: &WebcamResolution) -> Result<()> {
-    set_value(driver, CAMERA_RES_SET, value.to_string()).await
+pub(super) async fn set_video_constraint_publish_webcam(
+    driver: &dyn BrowserDriver,
+    value: VideoConstraint,
+) -> Result<()> {
+    set_value(driver, VIDEO_CONSTRAINT_PUBLISH_SET, value.to_string()).await
+}
+
+pub(super) async fn get_video_constraint_subscribe(driver: &dyn BrowserDriver) -> Result<VideoConstraint> {
+    get_string(driver, VIDEO_CONSTRAINT_SUBSCRIBE_GET)
+        .await?
+        .parse::<VideoConstraint>()
+        .context("failed to parse videoConstraintSubscribe from string")
+}
+
+pub(super) async fn set_video_constraint_subscribe(driver: &dyn BrowserDriver, value: VideoConstraint) -> Result<()> {
+    set_value(driver, VIDEO_CONSTRAINT_SUBSCRIBE_SET, value.to_string()).await
+}
+
+pub(super) async fn get_video_max_concurrent_tracks(driver: &dyn BrowserDriver) -> Result<Option<usize>> {
+    // Read as a nullable float to tolerate the page returning e.g. `2.0`, then cast.
+    let value = driver.eval(VIDEO_MAX_CONCURRENT_TRACKS_GET, None).await?;
+    let as_f64: Option<f64> =
+        serde_json::from_value(value).context("failed to read videoMaxConcurrentTracks from eval result")?;
+    Ok(as_f64.map(|value| value as usize))
+}
+
+pub(super) async fn set_video_max_concurrent_tracks(driver: &dyn BrowserDriver, value: Option<usize>) -> Result<()> {
+    set_value(driver, VIDEO_MAX_CONCURRENT_TRACKS_SET, value).await
 }
 
 pub(super) async fn get_force_webrtc(driver: &dyn BrowserDriver) -> Result<bool> {
@@ -81,3 +112,152 @@ pub(super) async fn get_force_webrtc(driver: &dyn BrowserDriver) -> Result<bool>
 pub(super) async fn set_force_webrtc(driver: &dyn BrowserDriver, value: bool) -> Result<()> {
     set_value(driver, FORCE_WEBRTC_SET, value).await
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use client_simulator_config::VideoConstraint;
+    use eyre::Result;
+    use futures::{
+        future::BoxFuture,
+        FutureExt as _,
+    };
+    use serde_json::json;
+    use std::{
+        sync::Mutex,
+        time::Duration,
+    };
+
+    #[derive(Default)]
+    struct RecordingDriver {
+        calls: Mutex<Vec<(String, Option<serde_json::Value>)>>,
+        next_result: Mutex<serde_json::Value>,
+    }
+
+    impl RecordingDriver {
+        fn with_result(value: serde_json::Value) -> Self {
+            Self {
+                calls: Mutex::new(Vec::new()),
+                next_result: Mutex::new(value),
+            }
+        }
+
+        fn calls(&self) -> Vec<(String, Option<serde_json::Value>)> {
+            self.calls.lock().unwrap().clone()
+        }
+    }
+
+    impl BrowserDriver for RecordingDriver {
+        fn goto(&self, _url: &str) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+
+        fn exists(&self, _selector: &str) -> BoxFuture<'_, Result<bool>> {
+            async { Ok(false) }.boxed()
+        }
+
+        fn wait_for(&self, _selector: &str, _timeout: Duration) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+
+        fn click(&self, _selector: &str) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+
+        fn fill(&self, _selector: &str, _text: &str) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+
+        fn attribute(&self, _selector: &str, _name: &str) -> BoxFuture<'_, Result<Option<String>>> {
+            async { Ok(None) }.boxed()
+        }
+
+        fn eval(&self, js_body: &str, arg: Option<serde_json::Value>) -> BoxFuture<'_, Result<serde_json::Value>> {
+            self.calls.lock().unwrap().push((js_body.to_string(), arg));
+            let value = self.next_result.lock().unwrap().clone();
+            async move { Ok(value) }.boxed()
+        }
+
+        fn set_cookie(&self, _domain: &str, _name: &str, _value: &str) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+    }
+
+    #[tokio::test]
+    async fn sets_video_constraints_through_media_settings_api() {
+        let driver = RecordingDriver::default();
+
+        set_video_constraint_publish_webcam(&driver, VideoConstraint::P480)
+            .await
+            .unwrap();
+        set_video_constraint_subscribe(&driver, VideoConstraint::P720)
+            .await
+            .unwrap();
+        set_video_max_concurrent_tracks(&driver, Some(2)).await.unwrap();
+        set_video_max_concurrent_tracks(&driver, None).await.unwrap();
+
+        assert_eq!(
+            driver.calls(),
+            vec![
+                (
+                    "hyper.settings.media.actions.setVideoConstraintPublishWebcam(arguments[0]);".to_string(),
+                    Some(json!("480p")),
+                ),
+                (
+                    "hyper.settings.media.actions.setVideoConstraintSubscribe(arguments[0]);".to_string(),
+                    Some(json!("720p")),
+                ),
+                (
+                    "hyper.settings.media.actions.setVideoMaxConcurrentTracks(arguments[0]);".to_string(),
+                    Some(json!(2)),
+                ),
+                (
+                    "hyper.settings.media.actions.setVideoMaxConcurrentTracks(arguments[0]);".to_string(),
+                    Some(serde_json::Value::Null),
+                ),
+            ],
+        );
+    }
+
+    #[tokio::test]
+    async fn gets_video_constraints_from_media_settings_api() {
+        let driver = RecordingDriver::with_result(json!("360p"));
+
+        let value = get_video_constraint_publish_webcam(&driver).await.unwrap();
+
+        assert_eq!(value, VideoConstraint::P360);
+        assert_eq!(
+            driver.calls(),
+            vec![(
+                "return hyper.settings.media.videoConstraintPublishWebcam;".to_string(),
+                None,
+            )],
+        );
+    }
+
+    #[tokio::test]
+    async fn gets_nullable_video_max_concurrent_tracks() {
+        let driver = RecordingDriver::with_result(serde_json::Value::Null);
+
+        let value = get_video_max_concurrent_tracks(&driver).await.unwrap();
+
+        assert_eq!(value, None);
+        assert_eq!(
+            driver.calls(),
+            vec![(
+                "return hyper.settings.media.videoMaxConcurrentTracks;".to_string(),
+                None,
+            )],
+        );
+    }
+
+    #[tokio::test]
+    async fn reads_integer_valued_max_concurrent_tracks_even_as_float() {
+        // The page may hand back a JSON number that serde sees as a float (e.g. 2.0).
+        let driver = RecordingDriver::with_result(json!(2.0));
+
+        let value = get_video_max_concurrent_tracks(&driver).await.unwrap();
+
+        assert_eq!(value, Some(2));
+    }
+}
diff --git a/browser/src/participant/frontend/core.rs b/browser/src/participant/frontend/core.rs
index b4acff4..129490f 100644
--- a/browser/src/participant/frontend/core.rs
+++ b/browser/src/participant/frontend/core.rs
@@ -10,12 +10,16 @@ use super::{
         get_background_blur,
         get_force_webrtc,
         get_noise_suppression,
-        get_outgoing_camera_resolution,
+        get_video_constraint_publish_webcam,
+        get_video_constraint_subscribe,
+        get_video_max_concurrent_tracks,
         set_auto_gain_control,
         set_background_blur,
         set_force_webrtc,
         set_noise_suppression,
-        set_outgoing_camera_resolution,
+        set_video_constraint_publish_webcam,
+        set_video_constraint_subscribe,
+        set_video_max_concurrent_tracks,
     },
     driver::{
         decode_test_state,
@@ -28,7 +32,7 @@ use crate::auth::BorrowedCookie;
 use client_simulator_config::{
     NoiseSuppression,
     TransportMode,
-    WebcamResolution,
+    VideoConstraint,
 };
 use eyre::{
     Context as _,
@@ -156,9 +160,15 @@ impl ParticipantInner {
         set_background_blur(driver, settings.blur)
             .await
             .context("failed to set background blur")?;
-        set_outgoing_camera_resolution(driver, &settings.resolution)
+        set_video_constraint_publish_webcam(driver, settings.video_constraint_publish_webcam)
             .await
-            .context("failed to set outgoing camera resolution")?;
+            .context("failed to set outgoing webcam video constraint")?;
+        set_video_constraint_subscribe(driver, settings.video_constraint_subscribe)
+            .await
+            .context("failed to set incoming video constraint")?;
+        set_video_max_concurrent_tracks(driver, settings.video_max_concurrent_tracks)
+            .await
+            .context("failed to set max concurrent video tracks")?;
         set_force_webrtc(driver, settings.transport == TransportMode::WebRTC)
             .await
             .context("failed to set transport mode")?;
@@ -226,14 +236,25 @@ impl ParticipantInner {
             .map(|_| ())
     }
 
-    async fn set_webcam_resolutions_inner(&self, value: WebcamResolution) -> Result<()> {
-        debug!(participant = %self.participant_name(), "Changing to {value} resolution");
+    async fn set_video_constraint_publish_webcam_inner(&self, value: VideoConstraint) -> Result<()> {
+        info!(participant = %self.participant_name(), "Changing outgoing webcam video constraint to {value}");
+        set_video_constraint_publish_webcam(self.context.driver.as_ref(), value)
+            .await
+            .context("Failed to set outgoing webcam video constraint")
+    }
 
-        set_outgoing_camera_resolution(self.context.driver.as_ref(), &value)
+    async fn set_video_constraint_subscribe_inner(&self, value: VideoConstraint) -> Result<()> {
+        info!(participant = %self.participant_name(), "Changing incoming video constraint to {value}");
+        set_video_constraint_subscribe(self.context.driver.as_ref(), value)
             .await
-            .context("Failed to set outgoing camera resolution")?;
+            .context("Failed to set incoming video constraint")
+    }
 
-        Ok(())
+    async fn set_video_max_concurrent_tracks_inner(&self, value: Option<usize>) -> Result<()> {
+        info!(participant = %self.participant_name(), ?value, "Changing max concurrent video tracks");
+        set_video_max_concurrent_tracks(self.context.driver.as_ref(), value)
+            .await
+            .context("Failed to set max concurrent video tracks")
     }
 
     async fn set_noise_suppression_inner(&self, value: NoiseSuppression) -> Result<()> {
@@ -311,8 +332,16 @@ impl ParticipantInner {
             }
         }
 
-        if let Ok(value) = get_outgoing_camera_resolution(driver).await {
-            state.webcam_resolution = value;
+        if let Ok(value) = get_video_constraint_publish_webcam(driver).await {
+            state.video_constraint_publish_webcam = value;
+        }
+
+        if let Ok(value) = get_video_constraint_subscribe(driver).await {
+            state.video_constraint_subscribe = value;
+        }
+
+        if let Ok(value) = get_video_max_concurrent_tracks(driver).await {
+            state.video_max_concurrent_tracks = value;
         }
 
         if let Ok(blur) = get_background_blur(driver).await {
@@ -342,7 +371,15 @@ impl FrontendAutomation for ParticipantInner {
                 ParticipantMessage::ToggleVideo => self.toggle_video_inner().await,
                 ParticipantMessage::ToggleScreenshare => self.toggle_screen_share_inner().await,
                 ParticipantMessage::ToggleAutoGainControl => self.toggle_auto_gain_control_inner().await,
-                ParticipantMessage::SetWebcamResolutions(value) => self.set_webcam_resolutions_inner(value).await,
+                ParticipantMessage::SetVideoConstraintPublishWebcam(value) => {
+                    self.set_video_constraint_publish_webcam_inner(value).await
+                }
+                ParticipantMessage::SetVideoConstraintSubscribe(value) => {
+                    self.set_video_constraint_subscribe_inner(value).await
+                }
+                ParticipantMessage::SetVideoMaxConcurrentTracks(value) => {
+                    self.set_video_max_concurrent_tracks_inner(value).await
+                }
                 ParticipantMessage::SetNoiseSuppression(value) => self.set_noise_suppression_inner(value).await,
                 ParticipantMessage::ToggleBackgroundBlur => self.toggle_background_blur_inner().await,
             }
diff --git a/browser/src/participant/frontend/lite.rs b/browser/src/participant/frontend/lite.rs
index fbf44dd..b623575 100644
--- a/browser/src/participant/frontend/lite.rs
+++ b/browser/src/participant/frontend/lite.rs
@@ -16,7 +16,7 @@ use super::{
 use client_simulator_config::{
     NoiseSuppression,
     TransportMode,
-    WebcamResolution,
+    VideoConstraint,
 };
 use eyre::{
     Context as _,
@@ -272,11 +272,18 @@ impl ParticipantInnerLite {
         Ok(())
     }
 
-    async fn set_webcam_resolutions_inner(&self, _value: WebcamResolution) -> Result<()> {
-        debug!(
-            participant = %self.participant_name(),
-            "Webcam resolution changes not supported in lite frontend"
-        );
+    async fn set_video_constraint_publish_webcam_inner(&self, _value: VideoConstraint) -> Result<()> {
+        self.log_unsupported("Video constraint");
+        Ok(())
+    }
+
+    async fn set_video_constraint_subscribe_inner(&self, _value: VideoConstraint) -> Result<()> {
+        self.log_unsupported("Video constraint");
+        Ok(())
+    }
+
+    async fn set_video_max_concurrent_tracks_inner(&self, _value: Option<usize>) -> Result<()> {
+        self.log_unsupported("Video constraint");
         Ok(())
     }
 
@@ -352,7 +359,9 @@ impl ParticipantInnerLite {
             joined,
             auto_gain_control: self.context.launch_spec.settings.auto_gain_control,
             transport_mode: TransportMode::default(),
-            webcam_resolution: WebcamResolution::default(),
+            video_constraint_publish_webcam: VideoConstraint::default(),
+            video_constraint_subscribe: VideoConstraint::default(),
+            video_max_concurrent_tracks: None,
             noise_suppression: NoiseSuppression::default(),
             muted: !self.context.launch_spec.settings.audio_enabled,
             video_activated: self.context.launch_spec.settings.video_enabled,
@@ -447,7 +456,15 @@ impl FrontendAutomation for ParticipantInnerLite {
                 ParticipantMessage::ToggleVideo => self.toggle_video_inner().await,
                 ParticipantMessage::ToggleScreenshare => self.toggle_screen_share_inner().await,
                 ParticipantMessage::ToggleAutoGainControl => self.toggle_auto_gain_control_inner().await,
-                ParticipantMessage::SetWebcamResolutions(value) => self.set_webcam_resolutions_inner(value).await,
+                ParticipantMessage::SetVideoConstraintPublishWebcam(value) => {
+                    self.set_video_constraint_publish_webcam_inner(value).await
+                }
+                ParticipantMessage::SetVideoConstraintSubscribe(value) => {
+                    self.set_video_constraint_subscribe_inner(value).await
+                }
+                ParticipantMessage::SetVideoMaxConcurrentTracks(value) => {
+                    self.set_video_max_concurrent_tracks_inner(value).await
+                }
                 ParticipantMessage::SetNoiseSuppression(value) => self.set_noise_suppression_inner(value).await,
                 ParticipantMessage::ToggleBackgroundBlur => self.toggle_background_blur_inner().await,
             }
diff --git a/browser/src/participant/mod.rs b/browser/src/participant/mod.rs
index 14f7d86..8ce3f09 100644
--- a/browser/src/participant/mod.rs
+++ b/browser/src/participant/mod.rs
@@ -410,12 +410,16 @@ impl Participant {
         self.send_message(ParticipantMessage::SetNoiseSuppression(value));
     }
 
-    pub fn set_webcam_resolutions(&self, value: client_simulator_config::WebcamResolution) {
-        self.send_message(ParticipantMessage::SetWebcamResolutions(value));
+    pub fn set_video_constraint_publish_webcam(&self, value: client_simulator_config::VideoConstraint) {
+        self.send_message(ParticipantMessage::SetVideoConstraintPublishWebcam(value));
     }
 
-    pub fn set_webcam_resolution(&self, value: client_simulator_config::WebcamResolution) {
-        self.set_webcam_resolutions(value);
+    pub fn set_video_constraint_subscribe(&self, value: client_simulator_config::VideoConstraint) {
+        self.send_message(ParticipantMessage::SetVideoConstraintSubscribe(value));
+    }
+
+    pub fn set_video_max_concurrent_tracks(&self, value: Option<usize>) {
+        self.send_message(ParticipantMessage::SetVideoMaxConcurrentTracks(value));
     }
 
     pub fn toggle_background_blur(&self) {
diff --git a/browser/src/participant/remote_stub.rs b/browser/src/participant/remote_stub.rs
index 00a7a63..a8e6bc5 100644
--- a/browser/src/participant/remote_stub.rs
+++ b/browser/src/participant/remote_stub.rs
@@ -62,7 +62,9 @@ impl ParticipantDriverSession for RemoteStubSession {
                 auto_gain_control: self.launch_spec.settings.auto_gain_control,
                 noise_suppression: self.launch_spec.settings.noise_suppression,
                 transport_mode: self.launch_spec.settings.transport,
-                webcam_resolution: self.launch_spec.settings.resolution,
+                video_constraint_publish_webcam: self.launch_spec.settings.video_constraint_publish_webcam,
+                video_constraint_subscribe: self.launch_spec.settings.video_constraint_subscribe,
+                video_max_concurrent_tracks: self.launch_spec.settings.video_max_concurrent_tracks,
                 background_blur: self.launch_spec.settings.blur,
                 screenshare_activated: self.launch_spec.settings.screenshare_enabled,
             };
@@ -106,9 +108,23 @@ impl ParticipantDriverSession for RemoteStubSession {
                     self.state.noise_suppression = value;
                     self.log_message("debug", format!("remote stub set noise suppression to {value}"));
                 }
-                ParticipantMessage::SetWebcamResolutions(value) => {
-                    self.state.webcam_resolution = value;
-                    self.log_message("debug", format!("remote stub set camera resolution to {value}"));
+                ParticipantMessage::SetVideoConstraintPublishWebcam(value) => {
+                    self.state.video_constraint_publish_webcam = value;
+                    self.log_message(
+                        "debug",
+                        format!("remote stub set outgoing webcam video constraint to {value}"),
+                    );
+                }
+                ParticipantMessage::SetVideoConstraintSubscribe(value) => {
+                    self.state.video_constraint_subscribe = value;
+                    self.log_message("debug", format!("remote stub set incoming video constraint to {value}"));
+                }
+                ParticipantMessage::SetVideoMaxConcurrentTracks(value) => {
+                    self.state.video_max_concurrent_tracks = value;
+                    self.log_message(
+                        "debug",
+                        format!("remote stub set max concurrent video tracks to {value:?}"),
+                    );
                 }
                 ParticipantMessage::ToggleBackgroundBlur => {
                     self.state.background_blur = !self.state.background_blur;
diff --git a/browser/src/participant/shared/messages.rs b/browser/src/participant/shared/messages.rs
index dd00abf..b29ca22 100644
--- a/browser/src/participant/shared/messages.rs
+++ b/browser/src/participant/shared/messages.rs
@@ -1,10 +1,10 @@
 use client_simulator_config::{
     NoiseSuppression,
-    WebcamResolution,
+    VideoConstraint,
 };
-use derive_more::Display;
+use std::fmt;
 
-#[derive(Clone, Display, serde::Serialize, serde::Deserialize, Debug)]
+#[derive(Clone, serde::Serialize, serde::Deserialize, Debug)]
 pub enum ParticipantMessage {
     Join,
     Leave,
@@ -14,10 +14,18 @@ pub enum ParticipantMessage {
     ToggleScreenshare,
     ToggleAutoGainControl,
     SetNoiseSuppression(NoiseSuppression),
-    SetWebcamResolutions(WebcamResolution),
+    SetVideoConstraintPublishWebcam(VideoConstraint),
+    SetVideoConstraintSubscribe(VideoConstraint),
+    SetVideoMaxConcurrentTracks(Option<usize>),
     ToggleBackgroundBlur,
 }
 
+impl fmt::Display for ParticipantMessage {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{self:?}")
+    }
+}
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ParticipantLogMessage {
     pub username: String,
diff --git a/browser/src/participant/shared/runtime.rs b/browser/src/participant/shared/runtime.rs
index be6225c..58f418e 100644
--- a/browser/src/participant/shared/runtime.rs
+++ b/browser/src/participant/shared/runtime.rs
@@ -325,7 +325,9 @@ mod tests {
                     | ParticipantMessage::ToggleScreenshare
                     | ParticipantMessage::ToggleAutoGainControl
                     | ParticipantMessage::SetNoiseSuppression(_)
-                    | ParticipantMessage::SetWebcamResolutions(_)
+                    | ParticipantMessage::SetVideoConstraintPublishWebcam(_)
+                    | ParticipantMessage::SetVideoConstraintSubscribe(_)
+                    | ParticipantMessage::SetVideoMaxConcurrentTracks(_)
                     | ParticipantMessage::ToggleBackgroundBlur => {}
                 }
                 Ok(())
diff --git a/browser/src/participant/shared/spec.rs b/browser/src/participant/shared/spec.rs
index 79fcd64..9b80857 100644
--- a/browser/src/participant/shared/spec.rs
+++ b/browser/src/participant/shared/spec.rs
@@ -2,7 +2,7 @@ use client_simulator_config::{
     NoiseSuppression,
     ParticipantConfig,
     TransportMode,
-    WebcamResolution,
+    VideoConstraint,
 };
 use url::Url;
 
@@ -31,7 +31,9 @@ pub(in crate::participant) struct ParticipantSettings {
     pub(in crate::participant) auto_gain_control: bool,
     pub(in crate::participant) noise_suppression: NoiseSuppression,
     pub(in crate::participant) transport: TransportMode,
-    pub(in crate::participant) resolution: WebcamResolution,
+    pub(in crate::participant) video_constraint_publish_webcam: VideoConstraint,
+    pub(in crate::participant) video_constraint_subscribe: VideoConstraint,
+    pub(in crate::participant) video_max_concurrent_tracks: Option<usize>,
     pub(in crate::participant) blur: bool,
 }
 
@@ -45,7 +47,9 @@ impl From<&ParticipantConfig> for ParticipantSettings {
             auto_gain_control: app_config.auto_gain_control,
             noise_suppression: app_config.noise_suppression,
             transport: app_config.transport,
-            resolution: app_config.resolution,
+            video_constraint_publish_webcam: app_config.video_constraint_publish_webcam,
+            video_constraint_subscribe: app_config.video_constraint_subscribe,
+            video_max_concurrent_tracks: app_config.video_max_concurrent_tracks,
             blur: app_config.blur,
         }
     }
@@ -89,7 +93,7 @@ mod tests {
         NoiseSuppression,
         ParticipantConfig,
         TransportMode,
-        WebcamResolution,
+        VideoConstraint,
     };
     use url::Url;
 
@@ -105,7 +109,9 @@ mod tests {
                 auto_gain_control: true,
                 noise_suppression: NoiseSuppression::RNNoise,
                 transport: TransportMode::WebRTC,
-                resolution: WebcamResolution::P720,
+                video_constraint_publish_webcam: VideoConstraint::P480,
+                video_constraint_subscribe: VideoConstraint::P720,
+                video_max_concurrent_tracks: Some(2),
                 blur: true,
                 ..Default::default()
             },
@@ -122,7 +128,9 @@ mod tests {
         assert!(spec.settings.auto_gain_control);
         assert_eq!(spec.settings.noise_suppression, NoiseSuppression::RNNoise);
         assert_eq!(spec.settings.transport, TransportMode::WebRTC);
-        assert_eq!(spec.settings.resolution, WebcamResolution::P720);
+        assert_eq!(spec.settings.video_constraint_publish_webcam, VideoConstraint::P480);
+        assert_eq!(spec.settings.video_constraint_subscribe, VideoConstraint::P720);
+        assert_eq!(spec.settings.video_max_concurrent_tracks, Some(2));
         assert!(spec.settings.blur);
     }
 }
diff --git a/browser/src/participant/shared/state.rs b/browser/src/participant/shared/state.rs
index a1302c0..c1db5a4 100644
--- a/browser/src/participant/shared/state.rs
+++ b/browser/src/participant/shared/state.rs
@@ -1,7 +1,7 @@
 use client_simulator_config::{
     NoiseSuppression,
     TransportMode,
-    WebcamResolution,
+    VideoConstraint,
 };
 
 #[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
@@ -14,7 +14,9 @@ pub struct ParticipantState {
     pub auto_gain_control: bool,
     pub noise_suppression: NoiseSuppression,
     pub transport_mode: TransportMode,
-    pub webcam_resolution: WebcamResolution,
+    pub video_constraint_publish_webcam: VideoConstraint,
+    pub video_constraint_subscribe: VideoConstraint,
+    pub video_max_concurrent_tracks: Option<usize>,
     pub background_blur: bool,
     pub screenshare_activated: bool,
 }
diff --git a/browser/tests/cloudflare_driver.rs b/browser/tests/cloudflare_driver.rs
index a60892b..3e588dc 100644
--- a/browser/tests/cloudflare_driver.rs
+++ b/browser/tests/cloudflare_driver.rs
@@ -9,7 +9,7 @@ use client_simulator_config::{
     CloudflareConfig,
     Config,
     ParticipantBackendKind,
-    WebcamResolution,
+    VideoConstraint,
 };
 use serde_json::{
     json,
@@ -50,7 +50,7 @@ async fn cloudflare_runtime_updates_public_participant_state_from_worker_command
             json!({
                 "ok": true,
                 "sessionId": "cf-runtime-commands",
-                "state": worker_state_json(false, false, false, "p720"),
+                "state": worker_state_json(false, false, false, "720p"),
                 "log": [],
             }),
         ),
@@ -59,7 +59,7 @@ async fn cloudflare_runtime_updates_public_participant_state_from_worker_command
             json!({
                 "ok": true,
                 "sessionId": "cf-runtime-commands",
-                "state": worker_state_json(true, false, false, "p720"),
+                "state": worker_state_json(true, false, false, "720p"),
                 "log": [],
             }),
         ),
@@ -68,7 +68,7 @@ async fn cloudflare_runtime_updates_public_participant_state_from_worker_command
             json!({
                 "ok": true,
                 "sessionId": "cf-runtime-commands",
-                "state": worker_state_json(true, true, false, "p720"),
+                "state": worker_state_json(true, true, false, "720p"),
                 "log": [],
             }),
         ),
@@ -77,7 +77,7 @@ async fn cloudflare_runtime_updates_public_participant_state_from_worker_command
             json!({
                 "ok": true,
                 "sessionId": "cf-runtime-commands",
-                "state": worker_state_json(true, true, true, "p720"),
+                "state": worker_state_json(true, true, true, "720p"),
                 "log": [],
             }),
         ),
@@ -86,7 +86,7 @@ async fn cloudflare_runtime_updates_public_participant_state_from_worker_command
             json!({
                 "ok": true,
                 "sessionId": "cf-runtime-commands",
-                "state": worker_state_json(false, true, true, "p720"),
+                "state": worker_state_json(false, true, true, "720p"),
                 "log": [],
             }),
         ),
@@ -109,7 +109,7 @@ async fn cloudflare_runtime_updates_public_participant_state_from_worker_command
     let state = participant.state.clone();
 
     let started = wait_for_state(&state, |current| {
-        current.running && !current.joined && current.webcam_resolution == WebcamResolution::P720
+        current.running && !current.joined && current.video_constraint_publish_webcam == VideoConstraint::P720
     })
     .await;
     assert!(started.running);
@@ -157,7 +157,7 @@ async fn cloudflare_runtime_survives_command_failures_and_can_still_close() {
             json!({
                 "ok": true,
                 "sessionId": "cf-runtime-errors",
-                "state": worker_state_json(false, false, false, "p720"),
+                "state": worker_state_json(false, false, false, "720p"),
                 "log": [],
             }),
         ),
@@ -187,7 +187,7 @@ async fn cloudflare_runtime_survives_command_failures_and_can_still_close() {
     let state = participant.state.clone();
 
     wait_for_state(&state, |current| {
-        current.running && !current.joined && current.webcam_resolution == WebcamResolution::P720
+        current.running && !current.joined && current.video_constraint_publish_webcam == VideoConstraint::P720
     })
     .await;
 
@@ -218,7 +218,7 @@ async fn cloudflare_runtime_marks_participant_stopped_when_worker_state_poll_fai
             json!({
                 "ok": true,
                 "sessionId": "cf-runtime-terminated",
-                "state": worker_state_json(true, false, false, "p720"),
+                "state": worker_state_json(true, false, false, "720p"),
                 "log": [],
             }),
         ),
@@ -240,7 +240,7 @@ async fn cloudflare_runtime_marks_participant_stopped_when_worker_state_poll_fai
     let state = participant.state.clone();
 
     wait_for_state(&state, |current| {
-        current.running && current.joined && current.webcam_resolution == WebcamResolution::P720
+        current.running && current.joined && current.video_constraint_publish_webcam == VideoConstraint::P720
     })
     .await;
     wait_for_state(&state, |current| !current.running).await;
@@ -277,7 +277,9 @@ async fn cloudflare_runtime_fetches_hyper_core_cookie_before_creating_worker_ses
                     "autoGainControl": true,
                     "noiseSuppression": "ai-coustics-rook-s-48khz",
                     "transportMode": "webrtc",
-                    "webcamResolution": "p1080",
+                    "videoConstraintPublishWebcam": "1080p",
+                    "videoConstraintSubscribe": "none",
+                    "videoMaxConcurrentTracks": null,
                     "backgroundBlur": false,
                 },
                 "log": [],
@@ -288,7 +290,7 @@ async fn cloudflare_runtime_fetches_hyper_core_cookie_before_creating_worker_ses
             json!({
                 "ok": true,
                 "sessionId": "cf-runtime-core",
-                "state": worker_state_json(false, false, false, "p720"),
+                "state": worker_state_json(false, false, false, "720p"),
                 "log": [],
             }),
         ),
@@ -314,7 +316,7 @@ async fn cloudflare_runtime_fetches_hyper_core_cookie_before_creating_worker_ses
         current.running
             && current.joined
             && current.video_activated
-            && current.webcam_resolution == WebcamResolution::P1080
+            && current.video_constraint_publish_webcam == VideoConstraint::P1080
     })
     .await;
     assert!(started.running);
@@ -370,7 +372,7 @@ fn cloudflare_config(session_url: &str, base_url: &str, health_poll_interval_ms:
     config
 }
 
-fn worker_state_json(joined: bool, muted: bool, video_activated: bool, webcam_resolution: &str) -> Value {
+fn worker_state_json(joined: bool, muted: bool, video_activated: bool, video_constraint_publish_webcam: &str) -> Value {
     json!({
         "running": true,
         "joined": joined,
@@ -380,7 +382,9 @@ fn worker_state_json(joined: bool, muted: bool, video_activated: bool, webcam_re
         "autoGainControl": true,
         "noiseSuppression": "none",
         "transportMode": "webrtc",
-        "webcamResolution": webcam_resolution,
+        "videoConstraintPublishWebcam": video_constraint_publish_webcam,
+        "videoConstraintSubscribe": "none",
+        "videoMaxConcurrentTracks": null,
         "backgroundBlur": false,
     })
 }
diff --git a/cloudflare-worker-client/openapi/cloudflare-browser-simulator.json b/cloudflare-worker-client/openapi/cloudflare-browser-simulator.json
index b52fe5a..f1875a1 100644
--- a/cloudflare-worker-client/openapi/cloudflare-browser-simulator.json
+++ b/cloudflare-worker-client/openapi/cloudflare-browser-simulator.json
@@ -2,7 +2,7 @@
   "openapi": "3.0.3",
   "info": {
     "title": "cloudflare-browser-simulator",
-    "version": "0.3.0",
+    "version": "0.4.1",
     "description": "Cloudflare Worker that launches Browser Rendering sessions, joins Hyper rooms, and exposes its API contract from code."
   },
   "components": {
@@ -267,21 +267,41 @@
               "webtransport"
             ]
           },
-          "webcamResolution": {
+          "videoConstraintPublishWebcam": {
             "type": "string",
             "enum": [
-              "auto",
-              "p144",
-              "p240",
-              "p360",
-              "p480",
-              "p720",
-              "p1080",
-              "p1440",
-              "p2160",
-              "p4320"
+              "none",
+              "90p",
+              "144p",
+              "240p",
+              "360p",
+              "480p",
+              "720p",
+              "1080p",
+              "1440p",
+              "2160p"
+            ]
+          },
+          "videoConstraintSubscribe": {
+            "type": "string",
+            "enum": [
+              "none",
+              "90p",
+              "144p",
+              "240p",
+              "360p",
+              "480p",
+              "720p",
+              "1080p",
+              "1440p",
+              "2160p"
             ]
           },
+          "videoMaxConcurrentTracks": {
+            "type": "integer",
+            "nullable": true,
+            "minimum": 0
+          },
           "backgroundBlur": {
             "type": "boolean"
           }
@@ -295,7 +315,9 @@
           "autoGainControl",
           "noiseSuppression",
           "transportMode",
-          "webcamResolution",
+          "videoConstraintPublishWebcam",
+          "videoConstraintSubscribe",
+          "videoMaxConcurrentTracks",
           "backgroundBlur"
         ]
       },
@@ -490,21 +512,41 @@
               "webtransport"
             ]
           },
-          "resolution": {
+          "videoConstraintPublishWebcam": {
+            "type": "string",
+            "enum": [
+              "none",
+              "90p",
+              "144p",
+              "240p",
+              "360p",
+              "480p",
+              "720p",
+              "1080p",
+              "1440p",
+              "2160p"
+            ]
+          },
+          "videoConstraintSubscribe": {
             "type": "string",
             "enum": [
-              "auto",
-              "p144",
-              "p240",
-              "p360",
-              "p480",
-              "p720",
-              "p1080",
-              "p1440",
-              "p2160",
-              "p4320"
+              "none",
+              "90p",
+              "144p",
+              "240p",
+              "360p",
+              "480p",
+              "720p",
+              "1080p",
+              "1440p",
+              "2160p"
             ]
           },
+          "videoMaxConcurrentTracks": {
+            "type": "integer",
+            "nullable": true,
+            "minimum": 0
+          },
           "blur": {
             "type": "boolean",
             "description": "Whether background blur should be enabled."
@@ -517,7 +559,9 @@
           "autoGainControl",
           "noiseSuppression",
           "transport",
-          "resolution",
+          "videoConstraintPublishWebcam",
+          "videoConstraintSubscribe",
+          "videoMaxConcurrentTracks",
           "blur"
         ]
       },
@@ -766,28 +810,78 @@
               "type": {
                 "type": "string",
                 "enum": [
-                  "set-webcam-resolution"
+                  "set-video-constraint-publish-webcam"
                 ]
               },
-              "webcamResolution": {
+              "videoConstraintPublishWebcam": {
                 "type": "string",
                 "enum": [
-                  "auto",
-                  "p144",
-                  "p240",
-                  "p360",
-                  "p480",
-                  "p720",
-                  "p1080",
-                  "p1440",
-                  "p2160",
-                  "p4320"
+                  "none",
+                  "90p",
+                  "144p",
+                  "240p",
+                  "360p",
+                  "480p",
+                  "720p",
+                  "1080p",
+                  "1440p",
+                  "2160p"
                 ]
               }
             },
             "required": [
               "type",
-              "webcamResolution"
+              "videoConstraintPublishWebcam"
+            ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": [
+                  "set-video-constraint-subscribe"
+                ]
+              },
+              "videoConstraintSubscribe": {
+                "type": "string",
+                "enum": [
+                  "none",
+                  "90p",
+                  "144p",
+                  "240p",
+                  "360p",
+                  "480p",
+                  "720p",
+                  "1080p",
+                  "1440p",
+                  "2160p"
+                ]
+              }
+            },
+            "required": [
+              "type",
+              "videoConstraintSubscribe"
+            ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": [
+                  "set-video-max-concurrent-tracks"
+                ]
+              },
+              "videoMaxConcurrentTracks": {
+                "type": "integer",
+                "nullable": true,
+                "minimum": 0
+              }
+            },
+            "required": [
+              "type",
+              "videoMaxConcurrentTracks"
             ]
           },
           {
diff --git a/cloudflare-worker-client/src/client.rs b/cloudflare-worker-client/src/client.rs
index 5973d4d..5377a30 100644
--- a/cloudflare-worker-client/src/client.rs
+++ b/cloudflare-worker-client/src/client.rs
@@ -220,8 +220,9 @@ mod tests {
     use crate::generated::types::{
         ParticipantSettings,
         ParticipantSettingsNoiseSuppression,
-        ParticipantSettingsResolution,
         ParticipantSettingsTransport,
+        ParticipantSettingsVideoConstraintPublishWebcam,
+        ParticipantSettingsVideoConstraintSubscribe,
         SessionCreateRequest,
         SessionCreateRequestDisplayName,
         SessionCreateRequestFrontendKind,
@@ -269,7 +270,7 @@ mod tests {
     #[tokio::test]
     async fn translates_schema_mismatches_into_rebuild_hints() {
         let response = concat!(
-            r#"{"ok":true,"sessionId":"cf-session-123","state":{"running":true,"joined":true,"muted":false,"videoActivated":true,"screenshareActivated":false,"noiseSuppression":"future-noise-model","transportMode":"webrtc","webcamResolution":"auto","backgroundBlur":false},"log":[]}"#
+            r#"{"ok":true,"sessionId":"cf-session-123","state":{"running":true,"joined":true,"muted":false,"videoActivated":true,"screenshareActivated":false,"noiseSuppression":"future-noise-model","transportMode":"webrtc","videoConstraintPublishWebcam":"none","videoConstraintSubscribe":"none","videoMaxConcurrentTracks":null,"backgroundBlur":false},"log":[]}"#
         );
         let (base_url, _request_task) = spawn_json_server(200, response).await;
         let client = CloudflareWorkerClient::new(&base_url, Duration::from_secs(5)).unwrap();
@@ -300,9 +301,11 @@ mod tests {
                 auto_gain_control: true,
                 blur: false,
                 noise_suppression: ParticipantSettingsNoiseSuppression::None,
-                resolution: ParticipantSettingsResolution::Auto,
                 screenshare_enabled: false,
                 transport: ParticipantSettingsTransport::Webrtc,
+                video_constraint_publish_webcam: ParticipantSettingsVideoConstraintPublishWebcam::None,
+                video_constraint_subscribe: ParticipantSettingsVideoConstraintSubscribe::None,
+                video_max_concurrent_tracks: None,
                 video_enabled: true,
             },
         }
diff --git a/config/Cargo.toml b/config/Cargo.toml
index eb18a7c..fbcee7e 100644
--- a/config/Cargo.toml
+++ b/config/Cargo.toml
@@ -22,5 +22,8 @@ tracing.workspace = true
 url.workspace = true
 yaml_serde.workspace = true
 
+[dev-dependencies]
+serde_json.workspace = true
+
 [lints]
 workspace = true
diff --git a/config/src/client_config.rs b/config/src/client_config.rs
index b9d672e..6930110 100644
--- a/config/src/client_config.rs
+++ b/config/src/client_config.rs
@@ -17,21 +17,79 @@ pub enum TransportMode {
     WebRTC,
 }
 
-#[derive(Debug, Default, Clone, Copy, Display, EnumIter, EnumString, Serialize, Deserialize, PartialEq, PartialOrd)]
-pub enum WebcamResolution {
+#[derive(Debug, Default, Clone, Copy, Display, EnumIter, EnumString, Serialize, Deserialize, PartialEq, Eq)]
+pub enum VideoConstraint {
     #[default]
-    #[strum(to_string = "auto")]
-    #[serde(rename = "auto")]
-    Auto,
+    #[strum(to_string = "none")]
+    #[serde(rename = "none")]
+    None,
+    #[strum(to_string = "90p")]
+    #[serde(rename = "90p")]
+    P90,
+    #[strum(to_string = "144p")]
+    #[serde(rename = "144p")]
     P144,
+    #[strum(to_string = "240p")]
+    #[serde(rename = "240p")]
     P240,
+    #[strum(to_string = "360p")]
+    #[serde(rename = "360p")]
     P360,
+    #[strum(to_string = "480p")]
+    #[serde(rename = "480p")]
     P480,
+    #[strum(to_string = "720p")]
+    #[serde(rename = "720p")]
     P720,
+    #[strum(to_string = "1080p")]
+    #[serde(rename = "1080p")]
     P1080,
+    #[strum(to_string = "1440p")]
+    #[serde(rename = "1440p")]
     P1440,
+    #[strum(to_string = "2160p")]
+    #[serde(rename = "2160p")]
     P2160,
-    P4320,
+}
+
+#[derive(Debug, Default, Clone, Copy, Display, EnumIter, EnumString, PartialEq, Eq)]
+pub enum VideoMaxConcurrentTracksPreset {
+    #[default]
+    #[strum(to_string = "unlimited")]
+    Unlimited,
+    #[strum(to_string = "1")]
+    One,
+    #[strum(to_string = "2")]
+    Two,
+    #[strum(to_string = "3")]
+    Three,
+    #[strum(to_string = "4")]
+    Four,
+}
+
+impl VideoMaxConcurrentTracksPreset {
+    pub const fn to_option(self) -> Option<usize> {
+        match self {
+            Self::Unlimited => None,
+            Self::One => Some(1),
+            Self::Two => Some(2),
+            Self::Three => Some(3),
+            Self::Four => Some(4),
+        }
+    }
+
+    pub const fn from_option(value: Option<usize>) -> Self {
+        match value {
+            None => Self::Unlimited,
+            Some(1) => Self::One,
+            Some(2) => Self::Two,
+            Some(3) => Self::Three,
+            Some(4) => Self::Four,
+            // Off-list values (e.g. set via config/CLI) have no preset; the TUI
+            // selector falls back to Unlimited, while the table shows the real value.
+            Some(_) => Self::Unlimited,
+        }
+    }
 }
 
 #[derive(Debug, Default, Clone, Copy, Display, EnumIter, EnumString, Serialize, Deserialize, PartialEq, PartialOrd)]
@@ -109,9 +167,63 @@ impl ParticipantBackendKind {
 
 #[cfg(test)]
 mod tests {
-    use super::ParticipantBackendKind;
+    use super::{
+        ParticipantBackendKind,
+        VideoConstraint,
+        VideoMaxConcurrentTracksPreset,
+    };
     use std::str::FromStr as _;
 
+    #[test]
+    fn video_constraint_round_trips_hyper_media_setting_names() {
+        let values = [
+            ("none", VideoConstraint::None),
+            ("90p", VideoConstraint::P90),
+            ("144p", VideoConstraint::P144),
+            ("240p", VideoConstraint::P240),
+            ("360p", VideoConstraint::P360),
+            ("480p", VideoConstraint::P480),
+            ("720p", VideoConstraint::P720),
+            ("1080p", VideoConstraint::P1080),
+            ("1440p", VideoConstraint::P1440),
+            ("2160p", VideoConstraint::P2160),
+        ];
+
+        for (raw, expected) in values {
+            assert_eq!(VideoConstraint::from_str(raw).unwrap(), expected);
+            assert_eq!(expected.to_string(), raw);
+            assert_eq!(serde_json::to_value(expected).unwrap(), raw);
+            assert_eq!(serde_json::from_value::<VideoConstraint>(raw.into()).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn video_track_limit_presets_convert_to_nullable_track_counts() {
+        assert_eq!(VideoMaxConcurrentTracksPreset::Unlimited.to_option(), None);
+        assert_eq!(VideoMaxConcurrentTracksPreset::One.to_option(), Some(1));
+        assert_eq!(VideoMaxConcurrentTracksPreset::Two.to_option(), Some(2));
+        assert_eq!(VideoMaxConcurrentTracksPreset::Three.to_option(), Some(3));
+        assert_eq!(VideoMaxConcurrentTracksPreset::Four.to_option(), Some(4));
+        assert_eq!(
+            VideoMaxConcurrentTracksPreset::from_option(None),
+            VideoMaxConcurrentTracksPreset::Unlimited
+        );
+        assert_eq!(
+            VideoMaxConcurrentTracksPreset::from_option(Some(1)),
+            VideoMaxConcurrentTracksPreset::One
+        );
+        assert_eq!(
+            VideoMaxConcurrentTracksPreset::from_option(Some(4)),
+            VideoMaxConcurrentTracksPreset::Four
+        );
+        // Off-list live values fall back to Unlimited for TUI preselection only;
+        // the participants table displays the real number separately.
+        assert_eq!(
+            VideoMaxConcurrentTracksPreset::from_option(Some(8)),
+            VideoMaxConcurrentTracksPreset::Unlimited
+        );
+    }
+
     #[test]
     fn aws_device_farm_round_trips_kebab_case() {
         let kind = ParticipantBackendKind::from_str("aws-device-farm").unwrap();
diff --git a/config/src/default-config.yaml b/config/src/default-config.yaml
index 20df613..381dd79 100644
--- a/config/src/default-config.yaml
+++ b/config/src/default-config.yaml
@@ -48,5 +48,7 @@ video_enabled: true
 auto_gain_control: true
 noise_suppression: none
 transport: webtransport
-resolution: auto
+video_constraint_publish_webcam: none
+video_constraint_subscribe: none
+video_max_concurrent_tracks:
 blur: false
diff --git a/config/src/lib.rs b/config/src/lib.rs
index b86312e..15a6a04 100644
--- a/config/src/lib.rs
+++ b/config/src/lib.rs
@@ -27,8 +27,10 @@ pub use client_config::{
     ParticipantBackendKind,
     TransportMode,
     TransportModeIter,
-    WebcamResolution,
-    WebcamResolutionIter,
+    VideoConstraint,
+    VideoConstraintIter,
+    VideoMaxConcurrentTracksPreset,
+    VideoMaxConcurrentTracksPresetIter,
 };
 pub use cloudflare_config::CloudflareConfig;
 use color_eyre::Result;
@@ -78,7 +80,11 @@ pub struct Config {
     #[serde(default)]
     pub transport: TransportMode,
     #[serde(default)]
-    pub resolution: WebcamResolution,
+    pub video_constraint_publish_webcam: VideoConstraint,
+    #[serde(default)]
+    pub video_constraint_subscribe: VideoConstraint,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub video_max_concurrent_tracks: Option<usize>,
     #[serde(default)]
     pub blur: bool,
 }
@@ -178,7 +184,17 @@ impl config::Source for Config {
             self.noise_suppression.to_string().into(),
         );
         cache.insert("transport".to_string(), self.transport.to_string().into());
-        cache.insert("resolution".to_string(), self.resolution.to_string().into());
+        cache.insert(
+            "video_constraint_publish_webcam".to_string(),
+            self.video_constraint_publish_webcam.to_string().into(),
+        );
+        cache.insert(
+            "video_constraint_subscribe".to_string(),
+            self.video_constraint_subscribe.to_string().into(),
+        );
+        if let Some(value) = self.video_max_concurrent_tracks {
+            cache.insert("video_max_concurrent_tracks".to_string(), (value as i64).into());
+        }
         cache.insert("blur".to_string(), self.blur.into());
         if let Some(value) = self.fake_media_selected {
             cache.insert("fake_media_selected".to_string(), (value as u64).into());
@@ -415,4 +431,35 @@ device_farm:
         assert_eq!(config.device_farm.region, "us-west-2");
         assert!(config.device_farm.debug);
     }
+
+    #[test]
+    fn parses_new_video_constraint_settings() {
+        let config: Config = config::Config::builder()
+            .add_source(Config::default())
+            .add_source(config::File::from_str(
+                r#"
+video_constraint_publish_webcam: 480p
+video_constraint_subscribe: 720p
+video_max_concurrent_tracks: 2
+"#,
+                config::FileFormat::Yaml,
+            ))
+            .build()
+            .expect("failed to build config")
+            .try_deserialize()
+            .expect("failed to deserialize config");
+
+        assert_eq!(config.video_constraint_publish_webcam, VideoConstraint::P480);
+        assert_eq!(config.video_constraint_subscribe, VideoConstraint::P720);
+        assert_eq!(config.video_max_concurrent_tracks, Some(2));
+    }
+
+    #[test]
+    fn default_video_max_concurrent_tracks_is_unlimited() {
+        let config = Config::default();
+
+        assert_eq!(config.video_constraint_publish_webcam, VideoConstraint::None);
+        assert_eq!(config.video_constraint_subscribe, VideoConstraint::None);
+        assert_eq!(config.video_max_concurrent_tracks, None);
+    }
 }
diff --git a/src/headless.rs b/src/headless.rs
index 6bef39d..af5a1eb 100644
--- a/src/headless.rs
+++ b/src/headless.rs
@@ -5,7 +5,7 @@ use client_simulator_config::{
     ParticipantBackendKind,
     TransportMode,
     TuiArgs,
-    WebcamResolution,
+    VideoConstraint,
 };
 use eyre::{
     Context as _,
@@ -51,8 +51,14 @@ pub struct HeadlessArgs {
     #[clap(long, value_name = "MODE")]
     pub transport: Option<TransportMode>,
 
-    #[clap(long, value_name = "RESOLUTION")]
-    pub resolution: Option<WebcamResolution>,
+    #[clap(long = "video-constraint-publish-webcam", value_name = "CONSTRAINT")]
+    pub video_constraint_publish_webcam: Option<VideoConstraint>,
+
+    #[clap(long = "video-constraint-subscribe", value_name = "CONSTRAINT")]
+    pub video_constraint_subscribe: Option<VideoConstraint>,
+
+    #[clap(long = "video-max-concurrent-tracks", value_name = "TRACKS")]
+    pub video_max_concurrent_tracks: Option<usize>,
 
     #[clap(long, value_parser = clap::builder::BoolishValueParser::new())]
     pub blur: Option<bool>,
@@ -73,7 +79,9 @@ struct ParticipantOverride {
     auto_gain_control: Option<bool>,
     noise_suppression: Option<NoiseSuppression>,
     transport: Option<TransportMode>,
-    resolution: Option<WebcamResolution>,
+    video_constraint_publish_webcam: Option<VideoConstraint>,
+    video_constraint_subscribe: Option<VideoConstraint>,
+    video_max_concurrent_tracks: Option<usize>,
     blur: Option<bool>,
 }
 
@@ -121,8 +129,14 @@ fn apply_cli_overrides(config: &mut Config, args: &HeadlessArgs) {
     if let Some(transport) = args.transport {
         config.transport = transport;
     }
-    if let Some(resolution) = args.resolution {
-        config.resolution = resolution;
+    if let Some(value) = args.video_constraint_publish_webcam {
+        config.video_constraint_publish_webcam = value;
+    }
+    if let Some(value) = args.video_constraint_subscribe {
+        config.video_constraint_subscribe = value;
+    }
+    if let Some(value) = args.video_max_concurrent_tracks {
+        config.video_max_concurrent_tracks = Some(value);
     }
     if let Some(blur) = args.blur {
         config.blur = blur;
@@ -157,8 +171,14 @@ fn apply_participant_override(mut config: Config, override_: ParticipantOverride
     if let Some(transport) = override_.transport {
         config.transport = transport;
     }
-    if let Some(resolution) = override_.resolution {
-        config.resolution = resolution;
+    if let Some(value) = override_.video_constraint_publish_webcam {
+        config.video_constraint_publish_webcam = value;
+    }
+    if let Some(value) = override_.video_constraint_subscribe {
+        config.video_constraint_subscribe = value;
+    }
+    if let Some(value) = override_.video_max_concurrent_tracks {
+        config.video_max_concurrent_tracks = Some(value);
     }
     if let Some(blur) = override_.blur {
         config.blur = blur;
@@ -290,6 +310,7 @@ mod tests {
     use client_simulator_config::{
         Config,
         ParticipantBackendKind,
+        VideoConstraint,
     };
     use std::{
         fs,
@@ -340,6 +361,27 @@ mod tests {
         assert_eq!(args.audio_enabled, Some(false));
     }
 
+    #[test]
+    fn cli_parsing_accepts_video_constraint_options() {
+        let cli = TestHeadlessCli::parse_from([
+            "headless",
+            "--video-constraint-publish-webcam",
+            "480p",
+            "--video-constraint-subscribe",
+            "720p",
+            "--video-max-concurrent-tracks",
+            "2",
+            "--participant",
+            r#"{"video_constraint_publish_webcam":"360p","video_constraint_subscribe":"none","video_max_concurrent_tracks":1}"#,
+        ]);
+        let args = cli.args;
+
+        assert_eq!(args.video_constraint_publish_webcam, Some(VideoConstraint::P480));
+        assert_eq!(args.video_constraint_subscribe, Some(VideoConstraint::P720));
+        assert_eq!(args.video_max_concurrent_tracks, Some(2));
+        assert_eq!(args.participants.len(), 1);
+    }
+
     #[test]
     fn participant_json_overrides_global_config() {
         let global_config = Config {
@@ -367,6 +409,41 @@ mod tests {
         assert!(!configs[0].audio_enabled);
     }
 
+    #[test]
+    fn participant_json_overrides_video_constraints_and_treats_null_tracks_as_absent() {
+        let global_config = Config {
+            video_constraint_publish_webcam: VideoConstraint::P720,
+            video_constraint_subscribe: VideoConstraint::P720,
+            video_max_concurrent_tracks: Some(2),
+            ..Default::default()
+        };
+
+        let configs = build_participant_configs(
+            global_config,
+            &[r#"{"video_constraint_publish_webcam":"360p","video_max_concurrent_tracks":null}"#.to_string()],
+        )
+        .expect("participant configs");
+
+        // publish overridden; subscribe omitted -> inherits global;
+        // max tracks null is treated as absent -> inherits global Some(2).
+        assert_eq!(configs[0].video_constraint_publish_webcam, VideoConstraint::P360);
+        assert_eq!(configs[0].video_constraint_subscribe, VideoConstraint::P720);
+        assert_eq!(configs[0].video_max_concurrent_tracks, Some(2));
+    }
+
+    #[test]
+    fn participant_json_numeric_tracks_override_global() {
+        let global_config = Config {
+            video_max_concurrent_tracks: None,
+            ..Default::default()
+        };
+
+        let configs = build_participant_configs(global_config, &[r#"{"video_max_concurrent_tracks":3}"#.to_string()])
+            .expect("participant configs");
+
+        assert_eq!(configs[0].video_max_concurrent_tracks, Some(3));
+    }
+
     #[test]
     fn unknown_participant_json_field_returns_error() {
         let error = build_participant_configs(Config::default(), &[r#"{"audio_enable":false}"#.to_string()])
diff --git a/tui/src/tui/components/browser_start.rs b/tui/src/tui/components/browser_start.rs
index 82cb2a7..a2d262f 100644
--- a/tui/src/tui/components/browser_start.rs
+++ b/tui/src/tui/components/browser_start.rs
@@ -19,7 +19,8 @@ use client_simulator_config::{
     NoiseSuppression,
     ParticipantBackendKind,
     TransportMode,
-    WebcamResolution,
+    VideoConstraint,
+    VideoMaxConcurrentTracksPreset,
 };
 use color_eyre::Result;
 use crossterm::event::KeyCode;
@@ -47,7 +48,9 @@ enum SelectedField {
     AutoGainControl,
     NoiseSuppression,
     Transport,
-    Resolution,
+    VideoConstraintPublishWebcam,
+    VideoConstraintSubscribe,
+    VideoMaxConcurrentTracks,
     BackgroundBlur,
     Headless,
     Backend,
@@ -67,7 +70,13 @@ impl SelectedField {
             SelectedField::AutoGainControl => " Automatically adjust volume? <enter> to toggle. ",
             SelectedField::NoiseSuppression => " Enable noise suppression? <enter> to select noise suppression model. ",
             SelectedField::Transport => " Select transport protocol. <enter> to select. ",
-            SelectedField::Resolution => " Select resolution for video (camera). <enter> to select. ",
+            SelectedField::VideoConstraintPublishWebcam => {
+                " Select outgoing webcam video constraint. <enter> to select. "
+            }
+            SelectedField::VideoConstraintSubscribe => " Select incoming video constraint. <enter> to select. ",
+            SelectedField::VideoMaxConcurrentTracks => {
+                " Select max concurrent webcam tracks. <enter> to select. "
+            }
             SelectedField::BackgroundBlur => " Enable background blur? <enter> to toggle. ",
             SelectedField::Headless => " Run the browser in headless mode? When disabled, will show a browser window with which you can interact. <enter> to toggle. ",
             SelectedField::Backend => " Select the participant backend. <enter> to select, <del> to reset. ",
@@ -84,7 +93,9 @@ pub(crate) enum BrowserStartAction {
     StartSelectFakeMedia,
     StartSelectNoiseSuppression,
     StartSelectTransport,
-    StartSelectResolution,
+    StartSelectVideoConstraintPublishWebcam,
+    StartSelectVideoConstraintSubscribe,
+    StartSelectVideoMaxConcurrentTracks,
     StartSelectBackend,
     StartBrowser,
     Toggle,
@@ -109,7 +120,9 @@ pub struct BrowserStart {
     fake_media_builtin_list: Option<ListInput<FakeMediaWithDescriptionItem>>,
     noise_suppression_list: Option<EnumListInput<NoiseSuppression>>,
     transport_list: Option<EnumListInput<TransportMode>>,
-    resolution_list: Option<EnumListInput<WebcamResolution>>,
+    video_constraint_publish_webcam_list: Option<EnumListInput<VideoConstraint>>,
+    video_constraint_subscribe_list: Option<EnumListInput<VideoConstraint>>,
+    video_max_concurrent_tracks_list: Option<EnumListInput<VideoMaxConcurrentTracksPreset>>,
     backend_list: Option<EnumListInput<ParticipantBackendKind>>,
     participant_store: ParticipantStore,
 }
@@ -125,7 +138,9 @@ impl BrowserStart {
             selected: SelectedField::Url,
             fake_media_builtin_list: None,
             noise_suppression_list: None,
-            resolution_list: None,
+            video_constraint_publish_webcam_list: None,
+            video_constraint_subscribe_list: None,
+            video_max_concurrent_tracks_list: None,
             transport_list: None,
             backend_list: None,
             editing: None,
@@ -171,7 +186,9 @@ impl Component for BrowserStart {
                         | SelectedField::AutoGainControl
                         | SelectedField::NoiseSuppression
                         | SelectedField::Transport
-                        | SelectedField::Resolution
+                        | SelectedField::VideoConstraintPublishWebcam
+                        | SelectedField::VideoConstraintSubscribe
+                        | SelectedField::VideoMaxConcurrentTracks
                         | SelectedField::BackgroundBlur
                         | SelectedField::Headless
                         | SelectedField::Backend
@@ -266,12 +283,68 @@ impl Component for BrowserStart {
             }
         }
 
-        if let Some(mut list) = self.resolution_list.take() {
+        if let Some(mut list) = self.video_constraint_publish_webcam_list.take() {
+            match key.code {
+                KeyCode::Enter => {
+                    match list.finish() {
+                        Ok(value) => {
+                            self.config.video_constraint_publish_webcam = value;
+                        }
+                        Err(err) => {
+                            error!(?err, "Failed to parse");
+                        }
+                    }
+                    if let Err(e) = self.config.save() {
+                        error!(?e, "Failed to save config after edit");
+                    }
+                    return Ok(Some(Action::Activate(ActivateAction::BrowserStart)));
+                }
+                KeyCode::Esc => {
+                    return Ok(Some(Action::Activate(ActivateAction::BrowserStart)));
+                }
+                _ => {}
+            }
+            let handled = list.handle_key_event(key);
+            self.video_constraint_publish_webcam_list = Some(list);
+            if handled {
+                return Ok(None);
+            }
+        }
+
+        if let Some(mut list) = self.video_constraint_subscribe_list.take() {
+            match key.code {
+                KeyCode::Enter => {
+                    match list.finish() {
+                        Ok(value) => {
+                            self.config.video_constraint_subscribe = value;
+                        }
+                        Err(err) => {
+                            error!(?err, "Failed to parse");
+                        }
+                    }
+                    if let Err(e) = self.config.save() {
+                        error!(?e, "Failed to save config after edit");
+                    }
+                    return Ok(Some(Action::Activate(ActivateAction::BrowserStart)));
+                }
+                KeyCode::Esc => {
+                    return Ok(Some(Action::Activate(ActivateAction::BrowserStart)));
+                }
+                _ => {}
+            }
+            let handled = list.handle_key_event(key);
+            self.video_constraint_subscribe_list = Some(list);
+            if handled {
+                return Ok(None);
+            }
+        }
+
+        if let Some(mut list) = self.video_max_concurrent_tracks_list.take() {
             match key.code {
                 KeyCode::Enter => {
                     match list.finish() {
                         Ok(value) => {
-                            self.config.resolution = value;
+                            self.config.video_max_concurrent_tracks = value.to_option();
                         }
                         Err(err) => {
                             error!(?err, "Failed to parse");
@@ -288,7 +361,7 @@ impl Component for BrowserStart {
                 _ => {}
             }
             let handled = list.handle_key_event(key);
-            self.resolution_list = Some(list);
+            self.video_max_concurrent_tracks_list = Some(list);
             if handled {
                 return Ok(None);
             }
@@ -370,8 +443,14 @@ impl Component for BrowserStart {
             KeyCode::Enter if self.selected == SelectedField::Transport => {
                 Some(BrowserStartAction::StartSelectTransport)
             }
-            KeyCode::Enter if self.selected == SelectedField::Resolution => {
-                Some(BrowserStartAction::StartSelectResolution)
+            KeyCode::Enter if self.selected == SelectedField::VideoConstraintPublishWebcam => {
+                Some(BrowserStartAction::StartSelectVideoConstraintPublishWebcam)
+            }
+            KeyCode::Enter if self.selected == SelectedField::VideoConstraintSubscribe => {
+                Some(BrowserStartAction::StartSelectVideoConstraintSubscribe)
+            }
+            KeyCode::Enter if self.selected == SelectedField::VideoMaxConcurrentTracks => {
+                Some(BrowserStartAction::StartSelectVideoMaxConcurrentTracks)
             }
             KeyCode::Enter if self.selected == SelectedField::BackgroundBlur => Some(BrowserStartAction::Toggle),
             KeyCode::Enter if self.selected == SelectedField::Backend => Some(BrowserStartAction::StartSelectBackend),
@@ -389,8 +468,16 @@ impl Component for BrowserStart {
                 self.noise_suppression_list = None;
                 None
             }
-            KeyCode::Esc if self.resolution_list.is_some() => {
-                self.resolution_list = None;
+            KeyCode::Esc if self.video_constraint_publish_webcam_list.is_some() => {
+                self.video_constraint_publish_webcam_list = None;
+                None
+            }
+            KeyCode::Esc if self.video_constraint_subscribe_list.is_some() => {
+                self.video_constraint_subscribe_list = None;
+                None
+            }
+            KeyCode::Esc if self.video_max_concurrent_tracks_list.is_some() => {
+                self.video_max_concurrent_tracks_list = None;
                 None
             }
             KeyCode::Esc if self.transport_list.is_some() => {
@@ -448,8 +535,10 @@ impl Component for BrowserStart {
                     SelectedField::AutoGainControl => SelectedField::ScreenshareDisable,
                     SelectedField::NoiseSuppression => SelectedField::AutoGainControl,
                     SelectedField::Transport => SelectedField::NoiseSuppression,
-                    SelectedField::Resolution => SelectedField::Transport,
-                    SelectedField::BackgroundBlur => SelectedField::Resolution,
+                    SelectedField::VideoConstraintPublishWebcam => SelectedField::Transport,
+                    SelectedField::VideoConstraintSubscribe => SelectedField::VideoConstraintPublishWebcam,
+                    SelectedField::VideoMaxConcurrentTracks => SelectedField::VideoConstraintSubscribe,
+                    SelectedField::BackgroundBlur => SelectedField::VideoMaxConcurrentTracks,
                     SelectedField::Headless => SelectedField::BackgroundBlur,
                     SelectedField::Backend => SelectedField::Headless,
                     SelectedField::StartBrowser => SelectedField::Backend,
@@ -465,8 +554,10 @@ impl Component for BrowserStart {
                     SelectedField::ScreenshareDisable => SelectedField::AutoGainControl,
                     SelectedField::AutoGainControl => SelectedField::NoiseSuppression,
                     SelectedField::NoiseSuppression => SelectedField::Transport,
-                    SelectedField::Transport => SelectedField::Resolution,
-                    SelectedField::Resolution => SelectedField::BackgroundBlur,
+                    SelectedField::Transport => SelectedField::VideoConstraintPublishWebcam,
+                    SelectedField::VideoConstraintPublishWebcam => SelectedField::VideoConstraintSubscribe,
+                    SelectedField::VideoConstraintSubscribe => SelectedField::VideoMaxConcurrentTracks,
+                    SelectedField::VideoMaxConcurrentTracks => SelectedField::BackgroundBlur,
                     SelectedField::BackgroundBlur => SelectedField::Headless,
                     SelectedField::Headless => SelectedField::Backend,
                     SelectedField::Backend => SelectedField::StartBrowser,
@@ -544,11 +635,29 @@ impl Component for BrowserStart {
                 return Ok(None);
             }
 
-            BrowserStartAction::StartSelectResolution => {
-                self.resolution_list = Some(EnumListInput::new(
-                    "Camera resolution",
-                    WebcamResolution::iter(),
-                    self.config.resolution,
+            BrowserStartAction::StartSelectVideoConstraintPublishWebcam => {
+                self.video_constraint_publish_webcam_list = Some(EnumListInput::new(
+                    "Outgoing webcam video constraint",
+                    VideoConstraint::iter(),
+                    self.config.video_constraint_publish_webcam,
+                ));
+                return Ok(None);
+            }
+
+            BrowserStartAction::StartSelectVideoConstraintSubscribe => {
+                self.video_constraint_subscribe_list = Some(EnumListInput::new(
+                    "Incoming video constraint",
+                    VideoConstraint::iter(),
+                    self.config.video_constraint_subscribe,
+                ));
+                return Ok(None);
+            }
+
+            BrowserStartAction::StartSelectVideoMaxConcurrentTracks => {
+                self.video_max_concurrent_tracks_list = Some(EnumListInput::new(
+                    "Max concurrent webcam tracks",
+                    VideoMaxConcurrentTracksPreset::iter(),
+                    VideoMaxConcurrentTracksPreset::from_option(self.config.video_max_concurrent_tracks),
                 ));
                 return Ok(None);
             }
@@ -650,7 +759,9 @@ impl Component for BrowserStart {
                 Constraint::Length(1), // Auto gain control checkbox
                 Constraint::Length(1), // Noise suppression checkbox
                 Constraint::Length(1), // Transport
-                Constraint::Length(1), // Resolution
+                Constraint::Length(1), // Outgoing webcam video constraint
+                Constraint::Length(1), // Incoming video constraint
+                Constraint::Length(1), // Max concurrent video tracks
                 Constraint::Length(1), // Background blur checkbox
                 Constraint::Length(1), // Headless checkbox
                 Constraint::Length(1), // Backend
@@ -671,7 +782,9 @@ impl Component for BrowserStart {
             "Auto gain control:",
             "Noise suppression:",
             "Transport:",
-            "Resolution:",
+            "Outgoing constraint:",
+            "Incoming constraint:",
+            "Track limit:",
             "Background blur",
             "Headless:",
             "Backend:",
@@ -773,13 +886,41 @@ impl Component for BrowserStart {
         frame.render_widget(widget, rows[current_row_index]);
         current_row_index += 1;
 
-        // --- Resolution ---
-        let resolution = self.config.resolution.to_string();
+        // --- Outgoing webcam video constraint ---
+        let publish = self.config.video_constraint_publish_webcam.to_string();
         let widget = widgets::label_and_text(
             form_labels[current_row_index],
-            &resolution,
+            &publish,
             max_length,
-            self.focused && self.selected == SelectedField::Resolution,
+            self.focused && self.selected == SelectedField::VideoConstraintPublishWebcam,
+            &theme,
+        );
+        frame.render_widget(widget, rows[current_row_index]);
+        current_row_index += 1;
+
+        // --- Incoming video constraint ---
+        let subscribe = self.config.video_constraint_subscribe.to_string();
+        let widget = widgets::label_and_text(
+            form_labels[current_row_index],
+            &subscribe,
+            max_length,
+            self.focused && self.selected == SelectedField::VideoConstraintSubscribe,
+            &theme,
+        );
+        frame.render_widget(widget, rows[current_row_index]);
+        current_row_index += 1;
+
+        // --- Max concurrent video tracks ---
+        let max_tracks = self
+            .config
+            .video_max_concurrent_tracks
+            .map(|value| value.to_string())
+            .unwrap_or_else(|| "unlimited".to_string());
+        let widget = widgets::label_and_text(
+            form_labels[current_row_index],
+            &max_tracks,
+            max_length,
+            self.focused && self.selected == SelectedField::VideoMaxConcurrentTracks,
             &theme,
         );
         frame.render_widget(widget, rows[current_row_index]);
@@ -841,7 +982,13 @@ impl Component for BrowserStart {
         if let Some(list) = &mut self.noise_suppression_list {
             list.draw(frame, area)?;
         }
-        if let Some(list) = &mut self.resolution_list {
+        if let Some(list) = &mut self.video_constraint_publish_webcam_list {
+            list.draw(frame, area)?;
+        }
+        if let Some(list) = &mut self.video_constraint_subscribe_list {
+            list.draw(frame, area)?;
+        }
+        if let Some(list) = &mut self.video_max_concurrent_tracks_list {
             list.draw(frame, area)?;
         }
         if let Some(list) = &mut self.transport_list {
diff --git a/tui/src/tui/components/participants.rs b/tui/src/tui/components/participants.rs
index c157a74..49e1615 100644
--- a/tui/src/tui/components/participants.rs
+++ b/tui/src/tui/components/participants.rs
@@ -16,7 +16,8 @@ use client_simulator_browser::participant::ParticipantStore;
 use client_simulator_config::{
     Config,
     NoiseSuppression,
-    WebcamResolution,
+    VideoConstraint,
+    VideoMaxConcurrentTracksPreset,
 };
 use color_eyre::Result;
 use crossterm::event::KeyCode;
@@ -49,7 +50,17 @@ pub(crate) enum ParticipantsAction {
     MoveUp,
     MoveDown,
     StartSelectNoiseSuppression,
-    StartSelectResolution,
+    StartSelectVideoSetting,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Display, strum::EnumIter, strum::EnumString)]
+enum VideoSetting {
+    #[strum(to_string = "Outgoing constraint")]
+    PublishWebcam,
+    #[strum(to_string = "Incoming constraint")]
+    Subscribe,
+    #[strum(to_string = "Track limit")]
+    MaxTracks,
 }
 
 #[derive(Debug)]
@@ -61,7 +72,10 @@ pub struct Participants {
     table_state: TableState,
     keymap: Keymap,
     noise_suppression_list: Option<EnumListInput<NoiseSuppression>>,
-    resolution_list: Option<EnumListInput<WebcamResolution>>,
+    video_setting_menu: Option<EnumListInput<VideoSetting>>,
+    video_constraint_publish_webcam_list: Option<EnumListInput<VideoConstraint>>,
+    video_constraint_subscribe_list: Option<EnumListInput<VideoConstraint>>,
+    video_max_concurrent_tracks_list: Option<EnumListInput<VideoMaxConcurrentTracksPreset>>,
 }
 
 impl Participants {
@@ -74,7 +88,10 @@ impl Participants {
             table_state: TableState::default(),
             keymap: Keymap::default(),
             noise_suppression_list: None,
-            resolution_list: None,
+            video_setting_menu: None,
+            video_constraint_publish_webcam_list: None,
+            video_constraint_subscribe_list: None,
+            video_max_concurrent_tracks_list: None,
         }
     }
 
@@ -198,14 +215,12 @@ impl Component for Participants {
                     }
                     return Ok(None);
                 }
-                ParticipantsAction::StartSelectResolution => {
-                    if let Some(selected) = self.selected.as_ref().and_then(|s| self.participants.get(s)) {
-                        self.resolution_list = Some(EnumListInput::new(
-                            "Camera resolution",
-                            WebcamResolution::iter(),
-                            selected.state.borrow().webcam_resolution,
-                        ));
-                    }
+                ParticipantsAction::StartSelectVideoSetting => {
+                    self.video_setting_menu = Some(EnumListInput::new(
+                        "Video constraints",
+                        VideoSetting::iter(),
+                        VideoSetting::PublishWebcam,
+                    ));
                     return Ok(None);
                 }
             },
@@ -237,23 +252,112 @@ impl Component for Participants {
             }
         }
 
-        if let Some(mut list) = self.resolution_list.take() {
+        if let Some(mut list) = self.video_setting_menu.take() {
+            match key.code {
+                KeyCode::Enter => {
+                    if let Ok(value) = list.finish() {
+                        if let Some(selected) = self.selected.as_ref().and_then(|s| self.participants.get(s)) {
+                            let state = selected.state.borrow();
+                            match value {
+                                VideoSetting::PublishWebcam => {
+                                    self.video_constraint_publish_webcam_list = Some(EnumListInput::new(
+                                        "Outgoing webcam video constraint",
+                                        VideoConstraint::iter(),
+                                        state.video_constraint_publish_webcam,
+                                    ));
+                                }
+                                VideoSetting::Subscribe => {
+                                    self.video_constraint_subscribe_list = Some(EnumListInput::new(
+                                        "Incoming video constraint",
+                                        VideoConstraint::iter(),
+                                        state.video_constraint_subscribe,
+                                    ));
+                                }
+                                VideoSetting::MaxTracks => {
+                                    self.video_max_concurrent_tracks_list = Some(EnumListInput::new(
+                                        "Max concurrent webcam tracks",
+                                        VideoMaxConcurrentTracksPreset::iter(),
+                                        VideoMaxConcurrentTracksPreset::from_option(state.video_max_concurrent_tracks),
+                                    ));
+                                }
+                            }
+                        }
+                    }
+                    return Ok(None);
+                }
+                KeyCode::Esc => {
+                    return Ok(Some(Action::Activate(ActivateAction::Participants)));
+                }
+                _ => {}
+            }
+            let handled = list.handle_key_event(key);
+            self.video_setting_menu = Some(list);
+            if handled {
+                return Ok(None);
+            }
+        }
+
+        if let Some(mut list) = self.video_constraint_publish_webcam_list.take() {
+            match key.code {
+                KeyCode::Enter => {
+                    if let Ok(value) = list.finish() {
+                        if let Some(participant) = self.selected.as_ref().and_then(|s| self.participants.get(s)) {
+                            participant.set_video_constraint_publish_webcam(value);
+                        }
+                    }
+                    return Ok(Some(Action::Activate(ActivateAction::Participants)));
+                }
+                KeyCode::Esc => {
+                    return Ok(Some(Action::Activate(ActivateAction::Participants)));
+                }
+                _ => {}
+            }
+            let handled = list.handle_key_event(key);
+            self.video_constraint_publish_webcam_list = Some(list);
+            if handled {
+                return Ok(None);
+            }
+        }
+
+        if let Some(mut list) = self.video_constraint_subscribe_list.take() {
+            match key.code {
+                KeyCode::Enter => {
+                    if let Ok(value) = list.finish() {
+                        if let Some(participant) = self.selected.as_ref().and_then(|s| self.participants.get(s)) {
+                            participant.set_video_constraint_subscribe(value);
+                        }
+                    }
+                    return Ok(Some(Action::Activate(ActivateAction::Participants)));
+                }
+                KeyCode::Esc => {
+                    return Ok(Some(Action::Activate(ActivateAction::Participants)));
+                }
+                _ => {}
+            }
+            let handled = list.handle_key_event(key);
+            self.video_constraint_subscribe_list = Some(list);
+            if handled {
+                return Ok(None);
+            }
+        }
+
+        if let Some(mut list) = self.video_max_concurrent_tracks_list.take() {
             match key.code {
                 KeyCode::Enter => {
                     if let Ok(value) = list.finish() {
                         if let Some(participant) = self.selected.as_ref().and_then(|s| self.participants.get(s)) {
-                            participant.set_webcam_resolutions(value);
+                            participant.set_video_max_concurrent_tracks(value.to_option());
                         }
                     }
                     return Ok(Some(Action::Activate(ActivateAction::Participants)));
                 }
                 KeyCode::Esc => {
-                    return Ok(Some(Action::Activate(ActivateAction::BrowserStart)));
+                    return Ok(Some(Action::Activate(ActivateAction::Participants)));
                 }
                 _ => {}
             }
             let handled = list.handle_key_event(key);
-            self.resolution_list = Some(list);
+            self.video_max_concurrent_tracks_list = Some(list);
             if handled {
                 return Ok(None);
             }
@@ -326,7 +430,7 @@ impl Component for Participants {
             )),
 
             (KeyCode::Char('r'), Some(_)) => {
-                Some(Action::ParticipantsAction(ParticipantsAction::StartSelectResolution))
+                Some(Action::ParticipantsAction(ParticipantsAction::StartSelectVideoSetting))
             }
 
             (KeyCode::Char('b'), Some(selected)) => {
@@ -351,7 +455,7 @@ impl Component for Participants {
         let [_, _, area] = header_and_two_main_areas(area)?;
 
         let help = if self.selected.is_some() {
-            " <del> to shutdown, <j>oin, <l>eave, <m>ute, <v>ideo, <s>creenshare, auto <g>ain, <n>oise suppression, <r>esolutions, <b>lur "
+            " <del> to shutdown, <j>oin, <l>eave, <m>ute, <v>ideo, <s>creenshare, auto <g>ain, <n>oise suppression, <r> video constraints, <b>lur "
         } else {
             ""
         };
@@ -382,7 +486,7 @@ impl Component for Participants {
             "Autogain",
             "Noise Suppression",
             "Transport",
-            "Resolution",
+            "Video constraints",
             "Blur",
         ];
 
@@ -411,7 +515,13 @@ impl Component for Participants {
                 let auto_gain_control = format_bool(state.auto_gain_control);
                 let noise_suppression = state.noise_suppression.to_string();
                 let transport_mode = state.transport_mode.to_string();
-                let resolution = state.webcam_resolution.to_string();
+                let publish = state.video_constraint_publish_webcam.to_string();
+                let subscribe = state.video_constraint_subscribe.to_string();
+                let tracks = state
+                    .video_max_concurrent_tracks
+                    .map(|value| value.to_string())
+                    .unwrap_or_else(|| "∞".to_string());
+                let video_constraints = format!("out:{publish} in:{subscribe} t:{tracks}");
                 let background_blur = format_bool(state.background_blur);
                 let cells = vec![
                     Cell::from(name),
@@ -424,7 +534,7 @@ impl Component for Participants {
                     Cell::from(auto_gain_control),
                     Cell::from(noise_suppression),
                     Cell::from(transport_mode),
-                    Cell::from(resolution),
+                    Cell::from(video_constraints),
                     Cell::from(background_blur),
                 ];
                 let style = if Some(&participant.name) == self.selected.as_ref() {
@@ -447,18 +557,18 @@ impl Component for Participants {
                     .title_bottom(Line::from(help).centered()),
             )
             .widths([
-                Constraint::Percentage(10), // Name
-                Constraint::Percentage(8),  // Created
-                Constraint::Percentage(7),  // Running
-                Constraint::Percentage(7),  // Joined
-                Constraint::Percentage(7),  // Muted
+                Constraint::Percentage(9),  // Name
+                Constraint::Percentage(7),  // Created
+                Constraint::Percentage(6),  // Running
+                Constraint::Percentage(6),  // Joined
+                Constraint::Percentage(6),  // Muted
                 Constraint::Percentage(7),  // Video active
-                Constraint::Percentage(9),  // Screenshare active
-                Constraint::Percentage(8),  // Auto gain
-                Constraint::Percentage(12), // Noise suppression
-                Constraint::Percentage(8),  // Transport mode
-                Constraint::Percentage(8),  // Resolution
-                Constraint::Percentage(9),  // Blur
+                Constraint::Percentage(8),  // Screenshare active
+                Constraint::Percentage(7),  // Auto gain
+                Constraint::Percentage(11), // Noise suppression
+                Constraint::Percentage(7),  // Transport mode
+                Constraint::Percentage(18), // Video constraints
+                Constraint::Percentage(8),  // Blur
             ])
             .column_spacing(1);
 
@@ -468,7 +578,16 @@ impl Component for Participants {
         if let Some(list) = &mut self.noise_suppression_list {
             list.draw(frame, area)?;
         }
-        if let Some(list) = &mut self.resolution_list {
+        if let Some(list) = &mut self.video_setting_menu {
+            list.draw(frame, area)?;
+        }
+        if let Some(list) = &mut self.video_constraint_publish_webcam_list {
+            list.draw(frame, area)?;
+        }
+        if let Some(list) = &mut self.video_constraint_subscribe_list {
+            list.draw(frame, area)?;
+        }
+        if let Some(list) = &mut self.video_max_concurrent_tracks_list {
             list.draw(frame, area)?;
         }
 
diff --git a/tui/src/tui/layout.rs b/tui/src/tui/layout.rs
index cf42bdb..86ef5e3 100644
--- a/tui/src/tui/layout.rs
+++ b/tui/src/tui/layout.rs
@@ -35,8 +35,8 @@ pub(crate) fn header_and_two_main_areas(area: Rect) -> Result<[Rect; 3]> {
     let [header, area] = header_and_main_area(area)?;
     let [a, b] = *Layout::default()
         .direction(Direction::Vertical)
-        // The browser controls pane currently needs 17 rows including borders.
-        .constraints([Constraint::Max(17), Constraint::Min(0)])
+        // The browser controls pane currently needs 19 rows including borders.
+        .constraints([Constraint::Max(19), Constraint::Min(0)])
         .split(area)
     else {
         bail!("Failed to split the area");
@@ -48,7 +48,7 @@ pub(crate) fn header_and_two_main_areas(area: Rect) -> Result<[Rect; 3]> {
 ///
 /// # Examples
 ///
-/// ```rust
+/// ```ignore
 /// use ratatui::layout::{Constraint, Rect};
 ///
 /// let area = Rect::new(0, 0, 100, 100);

From d65128999203938c026d424e3a9d21109befec69 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Wed, 3 Jun 2026 13:46:13 +0200
Subject: [PATCH 23/42] improved logging for headless mode

---
 config/src/args.rs |   7 ---
 src/headless.rs    |  17 ++----
 src/main.rs        | 146 ++++++++++++++++++++++++++++++++++-----------
 tui/src/lib.rs     |   5 +-
 tui/src/logging.rs |  29 ++++++---
 5 files changed, 140 insertions(+), 64 deletions(-)

diff --git a/config/src/args.rs b/config/src/args.rs
index 85dc523..b4f9bd5 100644
--- a/config/src/args.rs
+++ b/config/src/args.rs
@@ -1,10 +1,6 @@
 /// Client Simulator TUI
 #[derive(clap::Args, Default, Debug, Clone)]
 pub struct TuiArgs {
-    /// Verbosity level (set from parent command)
-    #[clap(skip)]
-    pub debug: u8,
-
     /// Optional URL to override the stored configuration.
     #[clap(long, value_name = "URL")]
     pub url: Option<String>,
@@ -45,9 +41,6 @@ mod config_ext {
 
         fn collect(&self) -> Result<Map<String, Value>, config::ConfigError> {
             let mut cache = HashMap::<String, Value>::new();
-            if self.debug > 0 {
-                cache.insert("debug".to_string(), (self.debug as i64).into());
-            }
             if let Some(url) = &self.url {
                 cache.insert("url".to_string(), url.clone().into());
             }
diff --git a/src/headless.rs b/src/headless.rs
index af5a1eb..8a0f466 100644
--- a/src/headless.rs
+++ b/src/headless.rs
@@ -85,8 +85,8 @@ struct ParticipantOverride {
     blur: Option<bool>,
 }
 
-pub async fn run(args: HeadlessArgs, debug: u8) -> Result<i32> {
-    init_logging(debug)?;
+pub async fn run(args: HeadlessArgs, filter: EnvFilter) -> Result<i32> {
+    init_logging(filter)?;
 
     let mut global_config = Config::new(TuiArgs::default()).context("Failed to create config")?;
     apply_cli_overrides(&mut global_config, &args);
@@ -201,23 +201,14 @@ fn build_participant_configs(global_config: Config, participants: &[String]) ->
         .collect()
 }
 
-fn init_logging(debug: u8) -> Result<()> {
-    let filter = match debug {
-        0 => "info",
-        1 => "debug",
-        _ => "trace",
-    };
+fn init_logging(filter: EnvFilter) -> Result<()> {
     let writer = std::io::stderr
         .with_min_level(tracing::Level::WARN)
         .or_else(std::io::stdout);
 
     tracing_subscriber::registry()
         .with(tracing_error::ErrorLayer::default())
-        .with(
-            fmt::layer()
-                .with_writer(writer)
-                .with_filter(EnvFilter::builder().parse_lossy(filter)),
-        )
+        .with(fmt::layer().with_writer(writer).with_filter(filter))
         .try_init()?;
 
     Ok(())
diff --git a/src/main.rs b/src/main.rs
index 119edc7..3da495a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,17 +12,59 @@ use eyre::{
     OptionExt as _,
 };
 use tracing_subscriber::{
+    filter::LevelFilter,
     fmt,
     prelude::*,
     registry,
+    EnvFilter,
 };
 
-#[derive(Parser)]
+const DEFAULT_LOGGING_DIRECTIVE: &str = "info";
+const RUST_LOG_ENV: &str = "RUST_LOG";
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, clap::ValueEnum)]
+pub enum Logging {
+    Error,
+    Warn,
+    Info,
+    Debug,
+    Trace,
+}
+
+impl Logging {
+    fn as_filter(self) -> &'static str {
+        match self {
+            Self::Error => "error",
+            Self::Warn => "warn",
+            Self::Info => "info",
+            Self::Debug => "debug",
+            Self::Trace => "trace",
+        }
+    }
+}
+
+fn logging_filter(logging: Option<Logging>, rust_log: Option<&str>) -> EnvFilter {
+    let directive = logging
+        .map(Logging::as_filter)
+        .or(rust_log)
+        .unwrap_or(DEFAULT_LOGGING_DIRECTIVE);
+
+    EnvFilter::builder()
+        .with_default_directive(LevelFilter::INFO.into())
+        .parse_lossy(directive)
+}
+
+fn logging_filter_from_env(logging: Option<Logging>) -> EnvFilter {
+    let rust_log = std::env::var(RUST_LOG_ENV).ok();
+    logging_filter(logging, rust_log.as_deref())
+}
+
+#[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
 pub struct CliArgs {
-    /// Increase verbosity level (can be used multiple times). 1x = info, 2x = debug, 3x = trace.
-    #[clap(long = "debug", action = clap::ArgAction::Count)]
-    pub debug: u8,
+    /// Tracing filter level. If absent, RUST_LOG is used.
+    #[clap(long, value_enum, value_name = "LEVEL")]
+    pub logging: Option<Logging>,
 
     #[command(subcommand)]
     command: Option<Command>,
@@ -46,7 +88,8 @@ mod tests {
     fn parses_headless_command_with_repeated_participants() {
         let args = CliArgs::parse_from([
             "hyper-client-simulator",
-            "--debug",
+            "--logging",
+            "debug",
             "headless",
             "--url",
             "https://latest.dev.hyper.video/F27-T5F-DXY",
@@ -58,7 +101,7 @@ mod tests {
 
         match args.command {
             Some(Command::Headless(headless)) => {
-                assert_eq!(args.debug, 1);
+                assert_eq!(args.logging, Some(Logging::Debug));
                 assert_eq!(
                     headless.url.as_ref().map(url::Url::as_str),
                     Some("https://latest.dev.hyper.video/F27-T5F-DXY")
@@ -68,6 +111,52 @@ mod tests {
             other => panic!("expected headless command, got {other:?}"),
         }
     }
+
+    #[test]
+    fn parses_logging_levels() {
+        for (value, logging) in [
+            ("error", Logging::Error),
+            ("warn", Logging::Warn),
+            ("info", Logging::Info),
+            ("debug", Logging::Debug),
+            ("trace", Logging::Trace),
+        ] {
+            let args = CliArgs::parse_from(["hyper-client-simulator", "--logging", value, "headless"]);
+
+            assert_eq!(args.logging, Some(logging));
+        }
+    }
+
+    #[test]
+    fn leaves_logging_empty_when_not_provided() {
+        let args = CliArgs::parse_from(["hyper-client-simulator", "headless"]);
+
+        assert_eq!(args.logging, None);
+    }
+
+    #[test]
+    fn rejects_unknown_logging_level() {
+        let err = CliArgs::try_parse_from(["hyper-client-simulator", "--logging", "verbose", "headless"])
+            .expect_err("unknown logging level should fail");
+
+        assert_eq!(err.kind(), clap::error::ErrorKind::InvalidValue);
+    }
+
+    #[test]
+    fn uses_cli_logging_for_filter_when_present() {
+        let filter = logging_filter(Some(Logging::Trace), Some("warn"));
+
+        assert_eq!(filter.to_string(), "trace");
+    }
+
+    #[test]
+    fn uses_rust_log_for_filter_when_cli_logging_is_absent() {
+        let filter = logging_filter(None, Some("warn,client_simulator_browser=debug"));
+
+        let filter = filter.to_string();
+        assert!(filter.contains("warn"));
+        assert!(filter.contains("client_simulator_browser=debug"));
+    }
 }
 
 #[derive(clap::Args, Debug, Clone)]
@@ -85,45 +174,32 @@ pub struct CookieArgs {
 async fn main() -> eyre::Result<()> {
     errors::init()?;
 
-    let CliArgs { command, debug } = CliArgs::parse();
+    let CliArgs { command, logging } = CliArgs::parse();
 
     match command {
         None => {
-            let args = TuiArgs {
-                debug,
-                ..Default::default()
-            };
-            start_tui(args).await
-        }
-        Some(Command::Tui(mut args)) => {
-            args.debug = debug;
-            start_tui(args).await
+            let args = TuiArgs::default();
+            start_tui(args, logging_filter_from_env(logging)).await
         }
+        Some(Command::Tui(args)) => start_tui(args, logging_filter_from_env(logging)).await,
         Some(Command::Headless(args)) => {
-            let code = headless::run(args, debug).await?;
+            let code = headless::run(args, logging_filter_from_env(logging)).await?;
             std::process::exit(code);
         }
-        Some(Command::Cookie(args)) => run_cookie(args, debug).await,
+        Some(Command::Cookie(args)) => run_cookie(args, logging_filter_from_env(logging)).await,
     }
 }
 
-async fn run_cookie(CookieArgs { base_url, user }: CookieArgs, debug: u8) -> eyre::Result<()> {
-    if debug > 0 {
-        let filter = match debug {
-            1 => "info",
-            2 => "debug",
-            _ => "trace",
-        };
-
-        registry()
-            .with(
-                fmt::layer()
-                    .with_span_events(fmt::format::FmtSpan::CLOSE)
-                    .with_filter(tracing_subscriber::EnvFilter::builder().parse_lossy(filter)),
-            )
-            .with(tracing_error::ErrorLayer::default())
-            .init();
-    }
+async fn run_cookie(CookieArgs { base_url, user }: CookieArgs, filter: EnvFilter) -> eyre::Result<()> {
+    registry()
+        .with(
+            fmt::layer()
+                .with_writer(std::io::stderr)
+                .with_span_events(fmt::format::FmtSpan::CLOSE)
+                .with_filter(filter),
+        )
+        .with(tracing_error::ErrorLayer::default())
+        .init();
 
     let domain = base_url
         .host_str()
diff --git a/tui/src/lib.rs b/tui/src/lib.rs
index 4a05a3b..817e555 100644
--- a/tui/src/lib.rs
+++ b/tui/src/lib.rs
@@ -1,4 +1,5 @@
 use client_simulator_config::TuiArgs;
+use tracing_subscriber::EnvFilter;
 
 #[macro_use]
 extern crate tracing;
@@ -8,8 +9,8 @@ mod tui;
 
 pub use tui::Tui;
 
-pub async fn start_tui(args: TuiArgs) -> eyre::Result<()> {
-    logging::log_init(args.debug)?;
+pub async fn start_tui(args: TuiArgs, filter: EnvFilter) -> eyre::Result<()> {
+    logging::log_init(filter)?;
 
     tui::App::new(args)?.run().await
 }
diff --git a/tui/src/logging.rs b/tui/src/logging.rs
index 1a70d19..0d1c560 100644
--- a/tui/src/logging.rs
+++ b/tui/src/logging.rs
@@ -3,14 +3,21 @@ use eyre::{
     Context as _,
     Result,
 };
-use tracing_subscriber::prelude::*;
+use tracing::{
+    level_filters::LevelFilter,
+    Level,
+};
+use tracing_subscriber::{
+    prelude::*,
+    EnvFilter,
+};
 use tui_logger::TuiLoggerFile;
 
 lazy_static::lazy_static! {
     static ref LOG_FILE: String = format!("{}.log", env!("CARGO_PKG_NAME"));
 }
 
-pub fn log_init(debug_level: u8) -> Result<()> {
+pub fn log_init(filter: EnvFilter) -> Result<()> {
     let directory = get_data_dir();
     std::fs::create_dir_all(directory.clone()).context("Failed to create directory")?;
     let log_path = directory.join(LOG_FILE.clone());
@@ -18,11 +25,7 @@ pub fn log_init(debug_level: u8) -> Result<()> {
         std::fs::remove_file(&log_path).context("Failed to remove existing log file")?;
     }
 
-    let level_filter = match debug_level {
-        0 => tui_logger::LevelFilter::Info,
-        1 => tui_logger::LevelFilter::Debug,
-        _ => tui_logger::LevelFilter::Trace,
-    };
+    let level_filter = tui_level_filter(filter.max_level_hint().unwrap_or(LevelFilter::INFO));
 
     tui_logger::init_logger(level_filter).context("Failed to initialize tui logger")?;
     tui_logger::set_level_for_target("log", level_filter);
@@ -30,7 +33,19 @@ pub fn log_init(debug_level: u8) -> Result<()> {
 
     tracing_subscriber::registry()
         .with(tracing_error::ErrorLayer::default())
+        .with(filter)
         .with(tui_logger::TuiTracingSubscriberLayer)
         .try_init()
         .context("Failed to initialize tracing subscriber")
 }
+
+fn tui_level_filter(level_filter: LevelFilter) -> tui_logger::LevelFilter {
+    match level_filter.into_level() {
+        Some(Level::ERROR) => tui_logger::LevelFilter::Error,
+        Some(Level::WARN) => tui_logger::LevelFilter::Warn,
+        Some(Level::INFO) => tui_logger::LevelFilter::Info,
+        Some(Level::DEBUG) => tui_logger::LevelFilter::Debug,
+        Some(Level::TRACE) => tui_logger::LevelFilter::Trace,
+        None => tui_logger::LevelFilter::Off,
+    }
+}

From e5e643344b45a627f3d810317b0be91e2fbfd0d0 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Wed, 3 Jun 2026 14:03:23 +0200
Subject: [PATCH 24/42] nix flake update (for recent chrome version)

---
 flake.lock | 8 ++++----
 flake.nix  | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/flake.lock b/flake.lock
index 088a973..96f37ec 100644
--- a/flake.lock
+++ b/flake.lock
@@ -20,16 +20,16 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1774273680,
-        "narHash": "sha256-a++tZ1RQsDb1I0NHrFwdGuRlR5TORvCEUksM459wKUA=",
+        "lastModified": 1780243769,
+        "narHash": "sha256-x5UQuRsH3MqI0U9afaXSNqzTPSeZlRLvFAav2Ux1pNw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "fdc7b8f7b30fdbedec91b71ed82f36e1637483ed",
+        "rev": "331800de5053fcebacf6813adb5db9c9dca22a0c",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
+        "ref": "nixos-unstable",
         "repo": "nixpkgs",
         "type": "github"
       }
diff --git a/flake.nix b/flake.nix
index 63b33bc..8c6af5a 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1,6 +1,6 @@
 {
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
     flake-utils.url = "github:numtide/flake-utils";
   };
 

From 55258868759682ccd0c2b7a372cac9c1f8297e87 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Wed, 3 Jun 2026 14:05:47 +0200
Subject: [PATCH 25/42] Fix Chrome request extra info CDP parsing

---
 Cargo.lock                                    |      2 -
 Cargo.toml                                    |      3 +
 browser/src/participant/local/session.rs      |     42 +
 vendor/chromiumoxide_cdp/Cargo.toml           |     70 +
 vendor/chromiumoxide_cdp/LICENSE-APACHE       |    201 +
 vendor/chromiumoxide_cdp/LICENSE-MIT          |     21 +
 vendor/chromiumoxide_cdp/PATCHES.md           |      5 +
 vendor/chromiumoxide_cdp/README.md            |    136 +
 .../pdl/browser_protocol.pdl                  |     57 +
 vendor/chromiumoxide_cdp/pdl/js_protocol.pdl  |   1843 +
 vendor/chromiumoxide_cdp/src/cdp.rs           | 111038 +++++++++++++++
 vendor/chromiumoxide_cdp/src/lib.rs           |    168 +
 vendor/chromiumoxide_cdp/src/revision.rs      |     17 +
 13 files changed, 113601 insertions(+), 2 deletions(-)
 create mode 100644 vendor/chromiumoxide_cdp/Cargo.toml
 create mode 100644 vendor/chromiumoxide_cdp/LICENSE-APACHE
 create mode 100644 vendor/chromiumoxide_cdp/LICENSE-MIT
 create mode 100644 vendor/chromiumoxide_cdp/PATCHES.md
 create mode 100644 vendor/chromiumoxide_cdp/README.md
 create mode 100644 vendor/chromiumoxide_cdp/pdl/browser_protocol.pdl
 create mode 100644 vendor/chromiumoxide_cdp/pdl/js_protocol.pdl
 create mode 100644 vendor/chromiumoxide_cdp/src/cdp.rs
 create mode 100644 vendor/chromiumoxide_cdp/src/lib.rs
 create mode 100644 vendor/chromiumoxide_cdp/src/revision.rs

diff --git a/Cargo.lock b/Cargo.lock
index 7ea53c8..902988d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -708,8 +708,6 @@ dependencies = [
 [[package]]
 name = "chromiumoxide_cdp"
 version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68a6a03a7ebac4ea85308f285d6959a3e6b2ce32a0c9465dc7a7b1db0144eec7"
 dependencies = [
  "chromiumoxide_pdl",
  "chromiumoxide_types",
diff --git a/Cargo.toml b/Cargo.toml
index 30cba67..3854a33 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -59,6 +59,9 @@ client-simulator-config = { path = "./config" }
 client-simulator-tui = { path = "./tui" }
 cloudflare-worker-client = { path = "./cloudflare-worker-client" }
 
+[patch.crates-io]
+chromiumoxide_cdp = { path = "vendor/chromiumoxide_cdp" }
+
 [workspace.lints.clippy]
 # Allows for simpler exports.
 module_inception = "allow"
diff --git a/browser/src/participant/local/session.rs b/browser/src/participant/local/session.rs
index 3a2373f..85e0686 100644
--- a/browser/src/participant/local/session.rs
+++ b/browser/src/participant/local/session.rs
@@ -516,6 +516,48 @@ mod tests {
         assert!(!audio_arg.starts_with("--"));
         assert!(!video_arg.starts_with("--"));
     }
+
+    #[test]
+    fn chromiumoxide_parses_chrome_146_request_extra_info_events() {
+        use chromiumoxide::{
+            cdp::events::CdpEvent,
+            types::Message,
+        };
+
+        let raw_event = serde_json::json!({
+            "method": "Network.requestWillBeSentExtraInfo",
+            "params": {
+                "requestId": "67875.221",
+                "associatedCookies": [],
+                "headers": {},
+                "connectTiming": {
+                    "requestTime": 1590260.969965
+                },
+                "clientSecurityState": {
+                    "initiatorIsSecureContext": true,
+                    "initiatorIPAddressSpace": "Public",
+                    "localNetworkAccessRequestPolicy": "PermissionBlock"
+                },
+                "siteHasCookieInOtherPartition": false
+            },
+            "sessionId": "CA7D85B4BA74D473D259E672BB4C4FB2"
+        });
+
+        let message: Message<chromiumoxide::cdp::CdpEventMessage> =
+            serde_json::from_value(raw_event).expect("Chrome 146 request extra info event should parse");
+
+        let Message::Event(event) = message else {
+            panic!("expected CDP event");
+        };
+
+        match event.params {
+            CdpEvent::NetworkRequestWillBeSentExtraInfo(event) => {
+                assert_eq!(event.request_id.as_ref(), "67875.221");
+                assert!(event.client_security_state.is_some());
+            }
+            other => panic!("expected Network.requestWillBeSentExtraInfo, got {other:?}"),
+        }
+    }
 }
 
 fn drive_browser_events(
diff --git a/vendor/chromiumoxide_cdp/Cargo.toml b/vendor/chromiumoxide_cdp/Cargo.toml
new file mode 100644
index 0000000..3a4530c
--- /dev/null
+++ b/vendor/chromiumoxide_cdp/Cargo.toml
@@ -0,0 +1,70 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2024"
+rust-version = "1.85"
+name = "chromiumoxide_cdp"
+version = "0.9.1"
+authors = ["Matthias Seitz <matthias.seitz@outlook.de>"]
+build = false
+include = [
+    "src/**/*",
+    "*.pdl",
+    "LICENSE-*",
+]
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Contains all the generated types for chromiumoxide"
+homepage = "https://github.com/mattsse/chromiumoxide"
+readme = "README.md"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/mattsse/chromiumoxide"
+
+[lib]
+name = "chromiumoxide_cdp"
+path = "src/lib.rs"
+
+[dependencies.chromiumoxide_pdl]
+version = "0.9"
+
+[dependencies.chromiumoxide_types]
+version = "0.9"
+
+[dependencies.serde]
+version = "1"
+features = ["derive"]
+
+[dependencies.serde_json]
+version = "1"
+
+[dev-dependencies.chromiumoxide_pdl]
+version = "0.9"
+
+[dev-dependencies.reqwest]
+version = "0.13"
+features = ["rustls"]
+default-features = false
+
+[dev-dependencies.tempfile]
+version = "3.10"
+
+[dev-dependencies.tokio]
+version = "1"
+features = [
+    "rt",
+    "fs",
+    "process",
+    "macros",
+]
diff --git a/vendor/chromiumoxide_cdp/LICENSE-APACHE b/vendor/chromiumoxide_cdp/LICENSE-APACHE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/vendor/chromiumoxide_cdp/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/vendor/chromiumoxide_cdp/LICENSE-MIT b/vendor/chromiumoxide_cdp/LICENSE-MIT
new file mode 100644
index 0000000..8050947
--- /dev/null
+++ b/vendor/chromiumoxide_cdp/LICENSE-MIT
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Matthias Seitz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/chromiumoxide_cdp/PATCHES.md b/vendor/chromiumoxide_cdp/PATCHES.md
new file mode 100644
index 0000000..e3fc164
--- /dev/null
+++ b/vendor/chromiumoxide_cdp/PATCHES.md
@@ -0,0 +1,5 @@
+# Local patches
+
+This is `chromiumoxide_cdp` 0.9.1 with one compatibility patch for Chrome 146.
+
+- `src/cdp.rs`: `Network.ClientSecurityState.privateNetworkRequestPolicy` accepts `localNetworkAccessRequestPolicy` as a serde alias, matching the key emitted by current Chrome for `Network.requestWillBeSentExtraInfo`.
diff --git a/vendor/chromiumoxide_cdp/README.md b/vendor/chromiumoxide_cdp/README.md
new file mode 100644
index 0000000..9c11088
--- /dev/null
+++ b/vendor/chromiumoxide_cdp/README.md
@@ -0,0 +1,136 @@
+# chromiumoxide
+
+![Build](https://github.com/mattsse/chromiumoxide/workflows/Continuous%20integration/badge.svg)
+[![Crates.io](https://img.shields.io/crates/v/chromiumoxide.svg)](https://crates.io/crates/chromiumoxide)
+[![Documentation](https://docs.rs/chromiumoxide/badge.svg)](https://docs.rs/chromiumoxide)
+
+chromiumoxide provides a high-level and async API to control Chrome or Chromium over the [DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/). It comes with support for all types of the [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/) and can launch a [headless](https://developers.google.com/web/updates/2017/04/headless-chrome) or full (non-headless) Chrome or Chromium instance or connect to an already running instance.
+
+## Usage
+
+```rust
+use futures::StreamExt;
+
+use chromiumoxide::browser::{Browser, BrowserConfig};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // create a `Browser` that spawns a `chromium` process running with UI (`with_head()`, headless is default)
+    // and the handler that drives the websocket etc.
+    let (mut browser, mut handler) =
+        Browser::launch(BrowserConfig::builder().with_head().build()?).await?;
+
+    // spawn a new task that continuously polls the handler
+    let handle = tokio::spawn(async move {
+        while let Some(h) = handler.next().await {
+            if h.is_err() {
+                break;
+            }
+        }
+    });
+
+    // create a new browser page and navigate to the url
+    let page = browser.new_page("https://en.wikipedia.org").await?;
+
+    // find and click the search toggle button to reveal the search bar
+    page.find_element(".search-toggle").await?.click().await?;
+
+    // find the search bar type into the search field and hit `Enter`,
+    // this triggers a new navigation to the search result page
+    page.find_element("input[name='search']")
+        .await?
+        .click()
+        .await?
+        .type_str("Rust programming language")
+        .await?
+        .press_key("Enter")
+        .await?;
+
+    let html = page.wait_for_navigation().await?.content().await?;
+
+    browser.close().await?;
+    handle.await?;
+    Ok(())
+}
+```
+
+The current API still lacks some functionality, but the [`Page::execute`](src/page.rs) function allows sending all `chromiumoxide_types::Command` types (see [Generated Code](README.md#generated-code)). Most `Element` and `Page` functions are basically just simplified command constructions and combinations, like `Page::pdf`:
+
+```rust
+pub async fn pdf(&self, params: PrintToPdfParams) -> Result<Vec<u8>> {
+    let res = self.execute(params).await?;
+    Ok(base64::decode(&res.data)?)
+}
+```
+
+If you need something else, the `Page::execute` function allows for writing your own command wrappers. PRs are very welcome if you think a meaningful command is missing a designated function.
+
+### Add chromiumoxide to your project
+
+`chromiumoxide` only supports the [`tokio`](https://github.com/tokio-rs/tokio) runtime.
+
+## Generated Code
+
+The [`chromiumoxide_pdl`](chromiumoxide_pdl) crate contains a [PDL parser](chromiumoxide_pdl/src/pdl/parser.rs), which is a rust rewrite of a [python script in the chromium source tree](https://chromium.googlesource.com/deps/inspector_protocol/+/refs/heads/master/pdl.py) and a [`Generator`](chromiumoxide_pdl/src/build/generator.rs) that turns the parsed PDL files into rust code. The [`chromiumoxide_cdp`](chromiumoxide_cdp) crate only purpose is to invoke the generator during its [build process](chromiumoxide_cdp/build.rs) and [include the generated output](chromiumoxide_cdp/src/lib.rs) before compiling the crate itself. This separation is done merely because the generated output is ~60K lines of rust code (not including all the proc macro expansions). So expect the compiling to take some time.
+The generator can be configured and used independently, see [chromiumoxide_cdp/build.rs](chromiumoxide_cdp/build.rs).
+
+Every chrome pdl domain is put in its own rust module, the types for the page domain of the browser_protocol are in `chromiumoxide_cdp::cdp::browser_protocol::page`, the runtime domain of the js_protocol in `chromiumoxide_cdp::cdp::js_protocol::runtime` and so on.
+
+[vanilla.aslushnikov.com](https://vanilla.aslushnikov.com/) is a great resource to browse all the types defined in the pdl files. This site displays `Command` types as defined in the pdl files as `Method`. `chromiumoxid` sticks to the `Command` nomenclature. So for everything that is defined as a command type in the pdl (=marked as `Method` on [vanilla.aslushnikov.com](https://vanilla.aslushnikov.com/)) `chromiumoxide` contains a type for command and a designated type for the return type. For every command there is a `<name of command>Params` type with builder support (`<name of command>Params::builder()`) and its corresponding return type: `<name of command>Returns`. All commands share an implementation of the `chromiumoxide_types::Command` trait.
+All Events are bundled in single enum (`CdpEvent`)
+
+## Fetcher
+
+By default `chromiumoxide` will try to find an installed version of chromium on the computer it runs on.
+It is possible to download and install one automatically for some platforms using the `fetcher` feature.
+
+You need to enable either the `rustls` or the `native-tls` feature and the `zip0` or `zip8` feature to allow the fetcher to download binaries.
+
+```rust
+use std::path::Path;
+
+use futures::StreamExt;
+use chromiumoxide::browser::{BrowserConfig};
+use chromiumoxide::fetcher::{BrowserFetcher, BrowserFetcherOptions};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let download_path = Path::new("./download");
+    tokio::fs::create_dir_all(&download_path).await?;
+    let fetcher = BrowserFetcher::new(
+        BrowserFetcherOptions::builder()
+            .with_path(&download_path)
+            .build()?,
+    );
+    let info = fetcher.fetch().await?;
+
+    let config = BrowserConfig::builder()
+        .chrome_executable(info.executable_path)
+        .build()?,
+}
+```
+
+## Known Issues
+
+- The rust files generated for the PDL files in [chromiumoxide_cdp](./chromiumoxide_cdp) don't compile when support for experimental types is manually turned off (`export CDP_NO_EXPERIMENTAL=true`). This is because the use of some experimental pdl types in the `*.pdl` files themselves are not marked as experimental.
+
+## Troubleshooting
+
+Q: A new chromium instance is being launched but then times out.
+
+A: Check that your chromium language settings are set to English. `chromiumoxide` tries to parse the debugging port from the chromium process output and that is limited to english.
+
+## License
+
+Licensed under either of these:
+
+- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+  <https://www.apache.org/licenses/LICENSE-2.0>)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or
+  <https://opensource.org/licenses/MIT>)
+
+## References
+
+- [chromedp](https://github.com/chromedp/chromedp)
+- [rust-headless-chrome](https://github.com/atroche/rust-headless-chrome) which the launch config, `KeyDefinition` and typing support among others is taken from.
+- [puppeteer](https://github.com/puppeteer/puppeteer)
diff --git a/vendor/chromiumoxide_cdp/pdl/browser_protocol.pdl b/vendor/chromiumoxide_cdp/pdl/browser_protocol.pdl
new file mode 100644
index 0000000..795d9cd
--- /dev/null
+++ b/vendor/chromiumoxide_cdp/pdl/browser_protocol.pdl
@@ -0,0 +1,57 @@
+# Copyright 2017 The Chromium Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+#
+# Contributing to Chrome DevTools Protocol: https://goo.gle/devtools-contribution-guide-cdp
+
+version
+  major 1
+  minor 3
+
+include domains/Accessibility.pdl
+include domains/Animation.pdl
+include domains/Audits.pdl
+include domains/Autofill.pdl
+include domains/BackgroundService.pdl
+include domains/BluetoothEmulation.pdl
+include domains/Browser.pdl
+include domains/CSS.pdl
+include domains/CacheStorage.pdl
+include domains/Cast.pdl
+include domains/DOM.pdl
+include domains/DOMDebugger.pdl
+include domains/DOMSnapshot.pdl
+include domains/DOMStorage.pdl
+include domains/DeviceAccess.pdl
+include domains/DeviceOrientation.pdl
+include domains/Emulation.pdl
+include domains/EventBreakpoints.pdl
+include domains/Extensions.pdl
+include domains/FedCm.pdl
+include domains/Fetch.pdl
+include domains/FileSystem.pdl
+include domains/HeadlessExperimental.pdl
+include domains/IO.pdl
+include domains/IndexedDB.pdl
+include domains/Input.pdl
+include domains/Inspector.pdl
+include domains/LayerTree.pdl
+include domains/Log.pdl
+include domains/Media.pdl
+include domains/Memory.pdl
+include domains/Network.pdl
+include domains/Overlay.pdl
+include domains/PWA.pdl
+include domains/Page.pdl
+include domains/Performance.pdl
+include domains/PerformanceTimeline.pdl
+include domains/Preload.pdl
+include domains/Security.pdl
+include domains/ServiceWorker.pdl
+include domains/Storage.pdl
+include domains/SystemInfo.pdl
+include domains/Target.pdl
+include domains/Tethering.pdl
+include domains/Tracing.pdl
+include domains/WebAudio.pdl
+include domains/WebAuthn.pdl
diff --git a/vendor/chromiumoxide_cdp/pdl/js_protocol.pdl b/vendor/chromiumoxide_cdp/pdl/js_protocol.pdl
new file mode 100644
index 0000000..bc86332
--- /dev/null
+++ b/vendor/chromiumoxide_cdp/pdl/js_protocol.pdl
@@ -0,0 +1,1843 @@
+# Copyright 2017 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+version
+  major 1
+  minor 3
+
+# This domain is deprecated - use Runtime or Log instead.
+deprecated domain Console
+  depends on Runtime
+
+  # Console message.
+  type ConsoleMessage extends object
+    properties
+      # Message source.
+      enum source
+        xml
+        javascript
+        network
+        console-api
+        storage
+        appcache
+        rendering
+        security
+        other
+        deprecation
+        worker
+      # Message severity.
+      enum level
+        log
+        warning
+        error
+        debug
+        info
+      # Message text.
+      string text
+      # URL of the message origin.
+      optional string url
+      # Line number in the resource that generated this message (1-based).
+      optional integer line
+      # Column number in the resource that generated this message (1-based).
+      optional integer column
+
+  # Does nothing.
+  command clearMessages
+
+  # Disables console domain, prevents further console messages from being reported to the client.
+  command disable
+
+  # Enables console domain, sends the messages collected so far to the client by means of the
+  # `messageAdded` notification.
+  command enable
+
+  # Issued when new console message is added.
+  event messageAdded
+    parameters
+      # Console message that has been added.
+      ConsoleMessage message
+
+# Debugger domain exposes JavaScript debugging capabilities. It allows setting and removing
+# breakpoints, stepping through execution, exploring stack traces, etc.
+domain Debugger
+  depends on Runtime
+
+  # Breakpoint identifier.
+  type BreakpointId extends string
+
+  # Call frame identifier.
+  type CallFrameId extends string
+
+  # Location in the source code.
+  type Location extends object
+    properties
+      # Script identifier as reported in the `Debugger.scriptParsed`.
+      Runtime.ScriptId scriptId
+      # Line number in the script (0-based).
+      integer lineNumber
+      # Column number in the script (0-based).
+      optional integer columnNumber
+
+  # Location in the source code.
+  experimental type ScriptPosition extends object
+    properties
+      integer lineNumber
+      integer columnNumber
+
+  # Location range within one script.
+  experimental type LocationRange extends object
+    properties
+      Runtime.ScriptId scriptId
+      ScriptPosition start
+      ScriptPosition end
+
+  # JavaScript call frame. Array of call frames form the call stack.
+  type CallFrame extends object
+    properties
+      # Call frame identifier. This identifier is only valid while the virtual machine is paused.
+      CallFrameId callFrameId
+      # Name of the JavaScript function called on this call frame.
+      string functionName
+      # Location in the source code.
+      optional Location functionLocation
+      # Location in the source code.
+      Location location
+      # JavaScript script name or url.
+      # Deprecated in favor of using the `location.scriptId` to resolve the URL via a previously
+      # sent `Debugger.scriptParsed` event.
+      deprecated string url
+      # Scope chain for this call frame.
+      array of Scope scopeChain
+      # `this` object for this call frame.
+      Runtime.RemoteObject this
+      # The value being returned, if the function is at return point.
+      optional Runtime.RemoteObject returnValue
+      # Valid only while the VM is paused and indicates whether this frame
+      # can be restarted or not. Note that a `true` value here does not
+      # guarantee that Debugger#restartFrame with this CallFrameId will be
+      # successful, but it is very likely.
+      experimental optional boolean canBeRestarted
+
+  # Scope description.
+  type Scope extends object
+    properties
+      # Scope type.
+      enum type
+        global
+        local
+        with
+        closure
+        catch
+        block
+        script
+        eval
+        module
+        wasm-expression-stack
+      # Object representing the scope. For `global` and `with` scopes it represents the actual
+      # object; for the rest of the scopes, it is artificial transient object enumerating scope
+      # variables as its properties.
+      Runtime.RemoteObject object
+      optional string name
+      # Location in the source code where scope starts
+      optional Location startLocation
+      # Location in the source code where scope ends
+      optional Location endLocation
+
+  # Search match for resource.
+  type SearchMatch extends object
+    properties
+      # Line number in resource content.
+      number lineNumber
+      # Line with match content.
+      string lineContent
+
+  type BreakLocation extends object
+    properties
+      # Script identifier as reported in the `Debugger.scriptParsed`.
+      Runtime.ScriptId scriptId
+      # Line number in the script (0-based).
+      integer lineNumber
+      # Column number in the script (0-based).
+      optional integer columnNumber
+      optional enum type
+        debuggerStatement
+        call
+        return
+
+  # Continues execution until specific location is reached.
+  command continueToLocation
+    parameters
+      # Location to continue to.
+      Location location
+      optional enum targetCallFrames
+        any
+        current
+
+  # Disables debugger for given page.
+  command disable
+
+  # Enables debugger for the given page. Clients should not assume that the debugging has been
+  # enabled until the result for this command is received.
+  command enable
+    parameters
+      # The maximum size in bytes of collected scripts (not referenced by other heap objects)
+      # the debugger can hold. Puts no limit if parameter is omitted.
+      experimental optional number maxScriptsCacheSize
+    returns
+      # Unique identifier of the debugger.
+      experimental Runtime.UniqueDebuggerId debuggerId
+
+  # Evaluates expression on a given call frame.
+  command evaluateOnCallFrame
+    parameters
+      # Call frame identifier to evaluate on.
+      CallFrameId callFrameId
+      # Expression to evaluate.
+      string expression
+      # String object group name to put result into (allows rapid releasing resulting object handles
+      # using `releaseObjectGroup`).
+      optional string objectGroup
+      # Specifies whether command line API should be available to the evaluated expression, defaults
+      # to false.
+      optional boolean includeCommandLineAPI
+      # In silent mode exceptions thrown during evaluation are not reported and do not pause
+      # execution. Overrides `setPauseOnException` state.
+      optional boolean silent
+      # Whether the result is expected to be a JSON object that should be sent by value.
+      optional boolean returnByValue
+      # Whether preview should be generated for the result.
+      experimental optional boolean generatePreview
+      # Whether to throw an exception if side effect cannot be ruled out during evaluation.
+      optional boolean throwOnSideEffect
+      # Terminate execution after timing out (number of milliseconds).
+      experimental optional Runtime.TimeDelta timeout
+    returns
+      # Object wrapper for the evaluation result.
+      Runtime.RemoteObject result
+      # Exception details.
+      optional Runtime.ExceptionDetails exceptionDetails
+
+  # Returns possible locations for breakpoint. scriptId in start and end range locations should be
+  # the same.
+  command getPossibleBreakpoints
+    parameters
+      # Start of range to search possible breakpoint locations in.
+      Location start
+      # End of range to search possible breakpoint locations in (excluding). When not specified, end
+      # of scripts is used as end of range.
+      optional Location end
+      # Only consider locations which are in the same (non-nested) function as start.
+      optional boolean restrictToFunction
+    returns
+      # List of the possible breakpoint locations.
+      array of BreakLocation locations
+
+  # Returns source for the script with given id.
+  command getScriptSource
+    parameters
+      # Id of the script to get source for.
+      Runtime.ScriptId scriptId
+    returns
+      # Script source (empty in case of Wasm bytecode).
+      string scriptSource
+      # Wasm bytecode.
+      optional binary bytecode
+
+  experimental type WasmDisassemblyChunk extends object
+    properties
+      # The next chunk of disassembled lines.
+      array of string lines
+      # The bytecode offsets describing the start of each line.
+      array of integer bytecodeOffsets
+
+  experimental command disassembleWasmModule
+    parameters
+      # Id of the script to disassemble
+      Runtime.ScriptId scriptId
+    returns
+      # For large modules, return a stream from which additional chunks of
+      # disassembly can be read successively.
+      optional string streamId
+      # The total number of lines in the disassembly text.
+      integer totalNumberOfLines
+      # The offsets of all function bodies, in the format [start1, end1,
+      # start2, end2, ...] where all ends are exclusive.
+      array of integer functionBodyOffsets
+      # The first chunk of disassembly.
+      WasmDisassemblyChunk chunk
+
+  # Disassemble the next chunk of lines for the module corresponding to the
+  # stream. If disassembly is complete, this API will invalidate the streamId
+  # and return an empty chunk. Any subsequent calls for the now invalid stream
+  # will return errors.
+  experimental command nextWasmDisassemblyChunk
+    parameters
+      string streamId
+    returns
+      # The next chunk of disassembly.
+      WasmDisassemblyChunk chunk
+
+  # This command is deprecated. Use getScriptSource instead.
+  deprecated command getWasmBytecode
+    parameters
+      # Id of the Wasm script to get source for.
+      Runtime.ScriptId scriptId
+    returns
+      # Script source.
+      binary bytecode
+
+  # Returns stack trace with given `stackTraceId`.
+  experimental command getStackTrace
+    parameters
+      Runtime.StackTraceId stackTraceId
+    returns
+      Runtime.StackTrace stackTrace
+
+  # Stops on the next JavaScript statement.
+  command pause
+
+  experimental deprecated command pauseOnAsyncCall
+    parameters
+      # Debugger will pause when async call with given stack trace is started.
+      Runtime.StackTraceId parentStackTraceId
+
+  # Removes JavaScript breakpoint.
+  command removeBreakpoint
+    parameters
+      BreakpointId breakpointId
+
+  # Restarts particular call frame from the beginning. The old, deprecated
+  # behavior of `restartFrame` is to stay paused and allow further CDP commands
+  # after a restart was scheduled. This can cause problems with restarting, so
+  # we now continue execution immediatly after it has been scheduled until we
+  # reach the beginning of the restarted frame.
+  #
+  # To stay back-wards compatible, `restartFrame` now expects a `mode`
+  # parameter to be present. If the `mode` parameter is missing, `restartFrame`
+  # errors out.
+  #
+  # The various return values are deprecated and `callFrames` is always empty.
+  # Use the call frames from the `Debugger#paused` events instead, that fires
+  # once V8 pauses at the beginning of the restarted function.
+  command restartFrame
+    parameters
+      # Call frame identifier to evaluate on.
+      CallFrameId callFrameId
+      # The `mode` parameter must be present and set to 'StepInto', otherwise
+      # `restartFrame` will error out.
+      experimental optional enum mode
+        # Pause at the beginning of the restarted function
+        StepInto
+    returns
+      # New stack trace.
+      deprecated array of CallFrame callFrames
+      # Async stack trace, if any.
+      deprecated optional Runtime.StackTrace asyncStackTrace
+      # Async stack trace, if any.
+      deprecated optional Runtime.StackTraceId asyncStackTraceId
+
+  # Resumes JavaScript execution.
+  command resume
+    parameters
+      # Set to true to terminate execution upon resuming execution. In contrast
+      # to Runtime.terminateExecution, this will allows to execute further
+      # JavaScript (i.e. via evaluation) until execution of the paused code
+      # is actually resumed, at which point termination is triggered.
+      # If execution is currently not paused, this parameter has no effect.
+      optional boolean terminateOnResume
+
+  # Searches for given string in script content.
+  command searchInContent
+    parameters
+      # Id of the script to search in.
+      Runtime.ScriptId scriptId
+      # String to search for.
+      string query
+      # If true, search is case sensitive.
+      optional boolean caseSensitive
+      # If true, treats string parameter as regex.
+      optional boolean isRegex
+    returns
+      # List of search matches.
+      array of SearchMatch result
+
+  # Enables or disables async call stacks tracking.
+  command setAsyncCallStackDepth
+    parameters
+      # Maximum depth of async call stacks. Setting to `0` will effectively disable collecting async
+      # call stacks (default).
+      integer maxDepth
+
+  # Replace previous blackbox execution contexts with passed ones. Forces backend to skip
+  # stepping/pausing in scripts in these execution contexts. VM will try to leave blackboxed script by
+  # performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+  experimental command setBlackboxExecutionContexts
+    parameters
+      # Array of execution context unique ids for the debugger to ignore.
+      array of string uniqueIds
+
+  # Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in
+  # scripts with url matching one of the patterns. VM will try to leave blackboxed script by
+  # performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+  experimental command setBlackboxPatterns
+    parameters
+      # Array of regexps that will be used to check script url for blackbox state.
+      array of string patterns
+      # If true, also ignore scripts with no source url.
+      optional boolean skipAnonymous
+
+  # Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted
+  # scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+  # Positions array contains positions where blackbox state is changed. First interval isn't
+  # blackboxed. Array should be sorted.
+  experimental command setBlackboxedRanges
+    parameters
+      # Id of the script.
+      Runtime.ScriptId scriptId
+      array of ScriptPosition positions
+
+  # Sets JavaScript breakpoint at a given location.
+  command setBreakpoint
+    parameters
+      # Location to set breakpoint in.
+      Location location
+      # Expression to use as a breakpoint condition. When specified, debugger will only stop on the
+      # breakpoint if this expression evaluates to true.
+      optional string condition
+    returns
+      # Id of the created breakpoint for further reference.
+      BreakpointId breakpointId
+      # Location this breakpoint resolved into.
+      Location actualLocation
+
+  # Sets instrumentation breakpoint.
+  command setInstrumentationBreakpoint
+    parameters
+      # Instrumentation name.
+      enum instrumentation
+        beforeScriptExecution
+        beforeScriptWithSourceMapExecution
+    returns
+      # Id of the created breakpoint for further reference.
+      BreakpointId breakpointId
+
+  # Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this
+  # command is issued, all existing parsed scripts will have breakpoints resolved and returned in
+  # `locations` property. Further matching script parsing will result in subsequent
+  # `breakpointResolved` events issued. This logical breakpoint will survive page reloads.
+  command setBreakpointByUrl
+    parameters
+      # Line number to set breakpoint at.
+      integer lineNumber
+      # URL of the resources to set breakpoint on.
+      optional string url
+      # Regex pattern for the URLs of the resources to set breakpoints on. Either `url` or
+      # `urlRegex` must be specified.
+      optional string urlRegex
+      # Script hash of the resources to set breakpoint on.
+      optional string scriptHash
+      # Offset in the line to set breakpoint at.
+      optional integer columnNumber
+      # Expression to use as a breakpoint condition. When specified, debugger will only stop on the
+      # breakpoint if this expression evaluates to true.
+      optional string condition
+    returns
+      # Id of the created breakpoint for further reference.
+      BreakpointId breakpointId
+      # List of the locations this breakpoint resolved into upon addition.
+      array of Location locations
+
+  # Sets JavaScript breakpoint before each call to the given function.
+  # If another function was created from the same source as a given one,
+  # calling it will also trigger the breakpoint.
+  experimental command setBreakpointOnFunctionCall
+    parameters
+      # Function object id.
+      Runtime.RemoteObjectId objectId
+      # Expression to use as a breakpoint condition. When specified, debugger will
+      # stop on the breakpoint if this expression evaluates to true.
+      optional string condition
+    returns
+      # Id of the created breakpoint for further reference.
+      BreakpointId breakpointId
+
+  # Activates / deactivates all breakpoints on the page.
+  command setBreakpointsActive
+    parameters
+      # New value for breakpoints active state.
+      boolean active
+
+  # Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions,
+  # or caught exceptions, no exceptions. Initial pause on exceptions state is `none`.
+  command setPauseOnExceptions
+    parameters
+      # Pause on exceptions mode.
+      enum state
+        none
+        caught
+        uncaught
+        all
+
+  # Changes return value in top frame. Available only at return break position.
+  experimental command setReturnValue
+    parameters
+      # New return value.
+      Runtime.CallArgument newValue
+
+  # Edits JavaScript source live.
+  #
+  # In general, functions that are currently on the stack can not be edited with
+  # a single exception: If the edited function is the top-most stack frame and
+  # that is the only activation of that function on the stack. In this case
+  # the live edit will be successful and a `Debugger.restartFrame` for the
+  # top-most function is automatically triggered.
+  command setScriptSource
+    parameters
+      # Id of the script to edit.
+      Runtime.ScriptId scriptId
+      # New content of the script.
+      string scriptSource
+      #  If true the change will not actually be applied. Dry run may be used to get result
+      # description without actually modifying the code.
+      optional boolean dryRun
+      # If true, then `scriptSource` is allowed to change the function on top of the stack
+      # as long as the top-most stack frame is the only activation of that function.
+      experimental optional boolean allowTopFrameEditing
+    returns
+      # New stack trace in case editing has happened while VM was stopped.
+      deprecated optional array of CallFrame callFrames
+      # Whether current call stack  was modified after applying the changes.
+      deprecated optional boolean stackChanged
+      # Async stack trace, if any.
+      deprecated optional Runtime.StackTrace asyncStackTrace
+      # Async stack trace, if any.
+      deprecated optional Runtime.StackTraceId asyncStackTraceId
+      # Whether the operation was successful or not. Only `Ok` denotes a
+      # successful live edit while the other enum variants denote why
+      # the live edit failed.
+      experimental enum status
+        Ok
+        CompileError
+        BlockedByActiveGenerator
+        BlockedByActiveFunction
+        BlockedByTopLevelEsModuleChange
+      # Exception details if any. Only present when `status` is `CompileError`.
+      optional Runtime.ExceptionDetails exceptionDetails
+
+  # Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).
+  command setSkipAllPauses
+    parameters
+      # New value for skip pauses state.
+      boolean skip
+
+  # Changes value of variable in a callframe. Object-based scopes are not supported and must be
+  # mutated manually.
+  command setVariableValue
+    parameters
+      # 0-based number of scope as was listed in scope chain. Only 'local', 'closure' and 'catch'
+      # scope types are allowed. Other scopes could be manipulated manually.
+      integer scopeNumber
+      # Variable name.
+      string variableName
+      # New variable value.
+      Runtime.CallArgument newValue
+      # Id of callframe that holds variable.
+      CallFrameId callFrameId
+
+  # Steps into the function call.
+  command stepInto
+    parameters
+      # Debugger will pause on the execution of the first async task which was scheduled
+      # before next pause.
+      experimental optional boolean breakOnAsyncCall
+      # The skipList specifies location ranges that should be skipped on step into.
+      experimental optional array of LocationRange skipList
+
+  # Steps out of the function call.
+  command stepOut
+
+  # Steps over the statement.
+  command stepOver
+    parameters
+      # The skipList specifies location ranges that should be skipped on step over.
+      experimental optional array of LocationRange skipList
+
+  # Fired when breakpoint is resolved to an actual script and location.
+  # Deprecated in favor of `resolvedBreakpoints` in the `scriptParsed` event.
+  deprecated event breakpointResolved
+    parameters
+      # Breakpoint unique identifier.
+      BreakpointId breakpointId
+      # Actual breakpoint location.
+      Location location
+
+  # Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.
+  event paused
+    parameters
+      # Call stack the virtual machine stopped on.
+      array of CallFrame callFrames
+      # Pause reason.
+      enum reason
+        ambiguous
+        assert
+        CSPViolation
+        debugCommand
+        DOM
+        EventListener
+        exception
+        instrumentation
+        OOM
+        other
+        promiseRejection
+        XHR
+        step
+      # Object containing break-specific auxiliary properties.
+      optional object data
+      # Hit breakpoints IDs
+      optional array of string hitBreakpoints
+      # Async stack trace, if any.
+      optional Runtime.StackTrace asyncStackTrace
+      # Async stack trace, if any.
+      experimental optional Runtime.StackTraceId asyncStackTraceId
+      # Never present, will be removed.
+      experimental deprecated optional Runtime.StackTraceId asyncCallStackTraceId
+
+  # Fired when the virtual machine resumed execution.
+  event resumed
+
+  # Enum of possible script languages.
+  type ScriptLanguage extends string
+    enum
+      JavaScript
+      WebAssembly
+
+  # Debug symbols available for a wasm script.
+  type DebugSymbols extends object
+    properties
+      # Type of the debug symbols.
+      enum type
+        SourceMap
+        EmbeddedDWARF
+        ExternalDWARF
+      # URL of the external symbol source.
+      optional string externalURL
+
+  type ResolvedBreakpoint extends object
+    properties
+      # Breakpoint unique identifier.
+      BreakpointId breakpointId
+      # Actual breakpoint location.
+      Location location
+
+  # Fired when virtual machine fails to parse the script.
+  event scriptFailedToParse
+    parameters
+      # Identifier of the script parsed.
+      Runtime.ScriptId scriptId
+      # URL or name of the script parsed (if any).
+      string url
+      # Line offset of the script within the resource with given URL (for script tags).
+      integer startLine
+      # Column offset of the script within the resource with given URL.
+      integer startColumn
+      # Last line of the script.
+      integer endLine
+      # Length of the last line of the script.
+      integer endColumn
+      # Specifies script creation context.
+      Runtime.ExecutionContextId executionContextId
+      # Content hash of the script, SHA-256.
+      string hash
+      # For Wasm modules, the content of the `build_id` custom section. For JavaScript the `debugId` magic comment.
+      string buildId
+      # Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'|'isolated'|'worker', frameId: string}
+      optional object executionContextAuxData
+      # URL of source map associated with script (if any).
+      optional string sourceMapURL
+      # True, if this script has sourceURL.
+      optional boolean hasSourceURL
+      # True, if this script is ES6 module.
+      optional boolean isModule
+      # This script length.
+      optional integer length
+      # JavaScript top stack frame of where the script parsed event was triggered if available.
+      experimental optional Runtime.StackTrace stackTrace
+      # If the scriptLanguage is WebAssembly, the code section offset in the module.
+      experimental optional integer codeOffset
+      # The language of the script.
+      experimental optional Debugger.ScriptLanguage scriptLanguage
+      # The name the embedder supplied for this script.
+      experimental optional string embedderName
+
+  # Fired when virtual machine parses script. This event is also fired for all known and uncollected
+  # scripts upon enabling debugger.
+  event scriptParsed
+    parameters
+      # Identifier of the script parsed.
+      Runtime.ScriptId scriptId
+      # URL or name of the script parsed (if any).
+      string url
+      # Line offset of the script within the resource with given URL (for script tags).
+      integer startLine
+      # Column offset of the script within the resource with given URL.
+      integer startColumn
+      # Last line of the script.
+      integer endLine
+      # Length of the last line of the script.
+      integer endColumn
+      # Specifies script creation context.
+      Runtime.ExecutionContextId executionContextId
+      # Content hash of the script, SHA-256.
+      string hash
+      # For Wasm modules, the content of the `build_id` custom section. For JavaScript the `debugId` magic comment.
+      string buildId
+      # Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'|'isolated'|'worker', frameId: string}
+      optional object executionContextAuxData
+      # True, if this script is generated as a result of the live edit operation.
+      experimental optional boolean isLiveEdit
+      # URL of source map associated with script (if any).
+      optional string sourceMapURL
+      # True, if this script has sourceURL.
+      optional boolean hasSourceURL
+      # True, if this script is ES6 module.
+      optional boolean isModule
+      # This script length.
+      optional integer length
+      # JavaScript top stack frame of where the script parsed event was triggered if available.
+      experimental optional Runtime.StackTrace stackTrace
+      # If the scriptLanguage is WebAssembly, the code section offset in the module.
+      experimental optional integer codeOffset
+      # The language of the script.
+      experimental optional Debugger.ScriptLanguage scriptLanguage
+      # If the scriptLanguage is WebAssembly, the source of debug symbols for the module.
+      experimental optional array of Debugger.DebugSymbols debugSymbols
+      # The name the embedder supplied for this script.
+      experimental optional string embedderName
+      # The list of set breakpoints in this script if calls to `setBreakpointByUrl`
+      # matches this script's URL or hash. Clients that use this list can ignore the
+      # `breakpointResolved` event. They are equivalent.
+      experimental optional array of ResolvedBreakpoint resolvedBreakpoints
+
+experimental domain HeapProfiler
+  depends on Runtime
+
+  # Heap snapshot object id.
+  type HeapSnapshotObjectId extends string
+
+  # Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes.
+  type SamplingHeapProfileNode extends object
+    properties
+      # Function location.
+      Runtime.CallFrame callFrame
+      # Allocations size in bytes for the node excluding children.
+      number selfSize
+      # Node id. Ids are unique across all profiles collected between startSampling and stopSampling.
+      integer id
+      # Child nodes.
+      array of SamplingHeapProfileNode children
+
+  # A single sample from a sampling profile.
+  type SamplingHeapProfileSample extends object
+    properties
+      # Allocation size in bytes attributed to the sample.
+      number size
+      # Id of the corresponding profile tree node.
+      integer nodeId
+      # Time-ordered sample ordinal number. It is unique across all profiles retrieved
+      # between startSampling and stopSampling.
+      number ordinal
+
+  # Sampling profile.
+  type SamplingHeapProfile extends object
+    properties
+      SamplingHeapProfileNode head
+      array of SamplingHeapProfileSample samples
+
+  # Enables console to refer to the node with given id via $x (see Command Line API for more details
+  # $x functions).
+  command addInspectedHeapObject
+    parameters
+      # Heap snapshot object id to be accessible by means of $x command line API.
+      HeapSnapshotObjectId heapObjectId
+
+  command collectGarbage
+
+  command disable
+
+  command enable
+
+  command getHeapObjectId
+    parameters
+      # Identifier of the object to get heap object id for.
+      Runtime.RemoteObjectId objectId
+    returns
+      # Id of the heap snapshot object corresponding to the passed remote object id.
+      HeapSnapshotObjectId heapSnapshotObjectId
+
+  command getObjectByHeapObjectId
+    parameters
+      HeapSnapshotObjectId objectId
+      # Symbolic group name that can be used to release multiple objects.
+      optional string objectGroup
+    returns
+      # Evaluation result.
+      Runtime.RemoteObject result
+
+  command getSamplingProfile
+    returns
+      # Return the sampling profile being collected.
+      SamplingHeapProfile profile
+
+  command startSampling
+    parameters
+      # Average sample interval in bytes. Poisson distribution is used for the intervals. The
+      # default value is 32768 bytes.
+      optional number samplingInterval
+      # Maximum stack depth. The default value is 128.
+      optional number stackDepth
+      # By default, the sampling heap profiler reports only objects which are
+      # still alive when the profile is returned via getSamplingProfile or
+      # stopSampling, which is useful for determining what functions contribute
+      # the most to steady-state memory usage. This flag instructs the sampling
+      # heap profiler to also include information about objects discarded by
+      # major GC, which will show which functions cause large temporary memory
+      # usage or long GC pauses.
+      optional boolean includeObjectsCollectedByMajorGC
+      # By default, the sampling heap profiler reports only objects which are
+      # still alive when the profile is returned via getSamplingProfile or
+      # stopSampling, which is useful for determining what functions contribute
+      # the most to steady-state memory usage. This flag instructs the sampling
+      # heap profiler to also include information about objects discarded by
+      # minor GC, which is useful when tuning a latency-sensitive application
+      # for minimal GC activity.
+      optional boolean includeObjectsCollectedByMinorGC
+
+  command startTrackingHeapObjects
+    parameters
+      optional boolean trackAllocations
+
+  command stopSampling
+    returns
+      # Recorded sampling heap profile.
+      SamplingHeapProfile profile
+
+  command stopTrackingHeapObjects
+    parameters
+      # If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken
+      # when the tracking is stopped.
+      optional boolean reportProgress
+      # Deprecated in favor of `exposeInternals`.
+      deprecated optional boolean treatGlobalObjectsAsRoots
+      # If true, numerical values are included in the snapshot
+      optional boolean captureNumericValue
+      # If true, exposes internals of the snapshot.
+      experimental optional boolean exposeInternals
+
+  command takeHeapSnapshot
+    parameters
+      # If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken.
+      optional boolean reportProgress
+      # If true, a raw snapshot without artificial roots will be generated.
+      # Deprecated in favor of `exposeInternals`.
+      deprecated optional boolean treatGlobalObjectsAsRoots
+      # If true, numerical values are included in the snapshot
+      optional boolean captureNumericValue
+      # If true, exposes internals of the snapshot.
+      experimental optional boolean exposeInternals
+
+  event addHeapSnapshotChunk
+    parameters
+      string chunk
+
+  # If heap objects tracking has been started then backend may send update for one or more fragments
+  event heapStatsUpdate
+    parameters
+      # An array of triplets. Each triplet describes a fragment. The first integer is the fragment
+      # index, the second integer is a total count of objects for the fragment, the third integer is
+      # a total size of the objects for the fragment.
+      array of integer statsUpdate
+
+  # If heap objects tracking has been started then backend regularly sends a current value for last
+  # seen object id and corresponding timestamp. If the were changes in the heap since last event
+  # then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
+  event lastSeenObjectId
+    parameters
+      integer lastSeenObjectId
+      number timestamp
+
+  event reportHeapSnapshotProgress
+    parameters
+      integer done
+      integer total
+      optional boolean finished
+
+  event resetProfiles
+
+domain Profiler
+  depends on Runtime
+  depends on Debugger
+
+  # Profile node. Holds callsite information, execution statistics and child nodes.
+  type ProfileNode extends object
+    properties
+      # Unique id of the node.
+      integer id
+      # Function location.
+      Runtime.CallFrame callFrame
+      # Number of samples where this node was on top of the call stack.
+      optional integer hitCount
+      # Child node ids.
+      optional array of integer children
+      # The reason of being not optimized. The function may be deoptimized or marked as don't
+      # optimize.
+      optional string deoptReason
+      # An array of source position ticks.
+      optional array of PositionTickInfo positionTicks
+
+  # Profile.
+  type Profile extends object
+    properties
+      # The list of profile nodes. First item is the root node.
+      array of ProfileNode nodes
+      # Profiling start timestamp in microseconds.
+      number startTime
+      # Profiling end timestamp in microseconds.
+      number endTime
+      # Ids of samples top nodes.
+      optional array of integer samples
+      # Time intervals between adjacent samples in microseconds. The first delta is relative to the
+      # profile startTime.
+      optional array of integer timeDeltas
+
+  # Specifies a number of samples attributed to a certain source position.
+  type PositionTickInfo extends object
+    properties
+      # Source line number (1-based).
+      integer line
+      # Number of samples attributed to the source line.
+      integer ticks
+
+  # Coverage data for a source range.
+  type CoverageRange extends object
+    properties
+      # JavaScript script source offset for the range start.
+      integer startOffset
+      # JavaScript script source offset for the range end.
+      integer endOffset
+      # Collected execution count of the source range.
+      integer count
+
+  # Coverage data for a JavaScript function.
+  type FunctionCoverage extends object
+    properties
+      # JavaScript function name.
+      string functionName
+      # Source ranges inside the function with coverage data.
+      array of CoverageRange ranges
+      # Whether coverage data for this function has block granularity.
+      boolean isBlockCoverage
+
+  # Coverage data for a JavaScript script.
+  type ScriptCoverage extends object
+    properties
+      # JavaScript script id.
+      Runtime.ScriptId scriptId
+      # JavaScript script name or url.
+      string url
+      # Functions contained in the script that has coverage data.
+      array of FunctionCoverage functions
+
+  command disable
+
+  command enable
+
+  # Collect coverage data for the current isolate. The coverage data may be incomplete due to
+  # garbage collection.
+  command getBestEffortCoverage
+    returns
+      # Coverage data for the current isolate.
+      array of ScriptCoverage result
+
+  # Changes CPU profiler sampling interval. Must be called before CPU profiles recording started.
+  command setSamplingInterval
+    parameters
+      # New sampling interval in microseconds.
+      integer interval
+
+  command start
+
+  # Enable precise code coverage. Coverage data for JavaScript executed before enabling precise code
+  # coverage may be incomplete. Enabling prevents running optimized code and resets execution
+  # counters.
+  command startPreciseCoverage
+    parameters
+      # Collect accurate call counts beyond simple 'covered' or 'not covered'.
+      optional boolean callCount
+      # Collect block-based coverage.
+      optional boolean detailed
+      # Allow the backend to send updates on its own initiative
+      optional boolean allowTriggeredUpdates
+    returns
+      # Monotonically increasing time (in seconds) when the coverage update was taken in the backend.
+      number timestamp
+
+  command stop
+    returns
+      # Recorded profile.
+      Profile profile
+
+  # Disable precise code coverage. Disabling releases unnecessary execution count records and allows
+  # executing optimized code.
+  command stopPreciseCoverage
+
+  # Collect coverage data for the current isolate, and resets execution counters. Precise code
+  # coverage needs to have started.
+  command takePreciseCoverage
+    returns
+      # Coverage data for the current isolate.
+      array of ScriptCoverage result
+      # Monotonically increasing time (in seconds) when the coverage update was taken in the backend.
+      number timestamp
+
+  event consoleProfileFinished
+    parameters
+      string id
+      # Location of console.profileEnd().
+      Debugger.Location location
+      Profile profile
+      # Profile title passed as an argument to console.profile().
+      optional string title
+
+  # Sent when new profile recording is started using console.profile() call.
+  event consoleProfileStarted
+    parameters
+      string id
+      # Location of console.profile().
+      Debugger.Location location
+      # Profile title passed as an argument to console.profile().
+      optional string title
+
+  # Reports coverage delta since the last poll (either from an event like this, or from
+  # `takePreciseCoverage` for the current isolate. May only be sent if precise code
+  # coverage has been started. This event can be trigged by the embedder to, for example,
+  # trigger collection of coverage data immediately at a certain point in time.
+  experimental event preciseCoverageDeltaUpdate
+    parameters
+      # Monotonically increasing time (in seconds) when the coverage update was taken in the backend.
+      number timestamp
+      # Identifier for distinguishing coverage events.
+      string occasion
+      # Coverage data for the current isolate.
+      array of ScriptCoverage result
+
+# Runtime domain exposes JavaScript runtime by means of remote evaluation and mirror objects.
+# Evaluation results are returned as mirror object that expose object type, string representation
+# and unique identifier that can be used for further object reference. Original objects are
+# maintained in memory unless they are either explicitly released or are released along with the
+# other objects in their object group.
+domain Runtime
+
+  # Unique script identifier.
+  type ScriptId extends string
+
+  # Represents options for serialization. Overrides `generatePreview` and `returnByValue`.
+  type SerializationOptions extends object
+    properties
+      enum serialization
+        # Whether the result should be deep-serialized. The result is put into
+        # `deepSerializedValue` and `ObjectId` is provided.
+        deep
+        # Whether the result is expected to be a JSON object which should be sent by value.
+        # The result is put either into `value` or into `unserializableValue`. Synonym of
+        # `returnByValue: true`. Overrides `returnByValue`.
+        json
+        # Only remote object id is put in the result. Same bahaviour as if no
+        # `serializationOptions`, `generatePreview` nor `returnByValue` are provided.
+        idOnly
+
+      # Deep serialization depth. Default is full depth. Respected only in `deep` serialization mode.
+      optional integer maxDepth
+
+      # Embedder-specific parameters. For example if connected to V8 in Chrome these control DOM
+      # serialization via `maxNodeDepth: integer` and `includeShadowTree: "none" | "open" | "all"`.
+      # Values can be only of type string or integer.
+      optional object additionalParameters
+
+  # Represents deep serialized value.
+  type DeepSerializedValue extends object
+    properties
+      enum type
+        undefined
+        null
+        string
+        number
+        boolean
+        bigint
+        regexp
+        date
+        symbol
+        array
+        object
+        function
+        map
+        set
+        weakmap
+        weakset
+        error
+        proxy
+        promise
+        typedarray
+        arraybuffer
+        node
+        window
+        generator
+      optional any value
+      optional string objectId
+      # Set if value reference met more then once during serialization. In such
+      # case, value is provided only to one of the serialized values. Unique
+      # per value in the scope of one CDP call.
+      optional integer weakLocalObjectReference
+
+  # Unique object identifier.
+  type RemoteObjectId extends string
+
+  # Primitive value which cannot be JSON-stringified. Includes values `-0`, `NaN`, `Infinity`,
+  # `-Infinity`, and bigint literals.
+  type UnserializableValue extends string
+
+  # Mirror object referencing original JavaScript object.
+  type RemoteObject extends object
+    properties
+      # Object type.
+      enum type
+        object
+        function
+        undefined
+        string
+        number
+        boolean
+        symbol
+        bigint
+      # Object subtype hint. Specified for `object` type values only.
+      # NOTE: If you change anything here, make sure to also update
+      # `subtype` in `ObjectPreview` and `PropertyPreview` below.
+      optional enum subtype
+        array
+        null
+        node
+        regexp
+        date
+        map
+        set
+        weakmap
+        weakset
+        iterator
+        generator
+        error
+        proxy
+        promise
+        typedarray
+        arraybuffer
+        dataview
+        webassemblymemory
+        wasmvalue
+        # blink's subtypes.
+        trustedtype
+      # Object class (constructor) name. Specified for `object` type values only.
+      optional string className
+      # Remote object value in case of primitive values or JSON values (if it was requested).
+      optional any value
+      # Primitive value which can not be JSON-stringified does not have `value`, but gets this
+      # property.
+      optional UnserializableValue unserializableValue
+      # String representation of the object.
+      optional string description
+      # Deep serialized value.
+      experimental optional DeepSerializedValue deepSerializedValue
+      # Unique object identifier (for non-primitive values).
+      optional RemoteObjectId objectId
+      # Preview containing abbreviated property values. Specified for `object` type values only.
+      experimental optional ObjectPreview preview
+      experimental optional CustomPreview customPreview
+
+  experimental type CustomPreview extends object
+    properties
+      # The JSON-stringified result of formatter.header(object, config) call.
+      # It contains json ML array that represents RemoteObject.
+      string header
+      # If formatter returns true as a result of formatter.hasBody call then bodyGetterId will
+      # contain RemoteObjectId for the function that returns result of formatter.body(object, config) call.
+      # The result value is json ML array.
+      optional RemoteObjectId bodyGetterId
+
+  # Object containing abbreviated remote object value.
+  experimental type ObjectPreview extends object
+    properties
+      # Object type.
+      enum type
+        object
+        function
+        undefined
+        string
+        number
+        boolean
+        symbol
+        bigint
+      # Object subtype hint. Specified for `object` type values only.
+      optional enum subtype
+        array
+        null
+        node
+        regexp
+        date
+        map
+        set
+        weakmap
+        weakset
+        iterator
+        generator
+        error
+        proxy
+        promise
+        typedarray
+        arraybuffer
+        dataview
+        webassemblymemory
+        wasmvalue
+        # blink's subtypes.
+        trustedtype
+      # String representation of the object.
+      optional string description
+      # True iff some of the properties or entries of the original object did not fit.
+      boolean overflow
+      # List of the properties.
+      array of PropertyPreview properties
+      # List of the entries. Specified for `map` and `set` subtype values only.
+      optional array of EntryPreview entries
+
+  experimental type PropertyPreview extends object
+    properties
+      # Property name.
+      string name
+      # Object type. Accessor means that the property itself is an accessor property.
+      enum type
+        object
+        function
+        undefined
+        string
+        number
+        boolean
+        symbol
+        accessor
+        bigint
+      # User-friendly property value string.
+      optional string value
+      # Nested value preview.
+      optional ObjectPreview valuePreview
+      # Object subtype hint. Specified for `object` type values only.
+      optional enum subtype
+        array
+        null
+        node
+        regexp
+        date
+        map
+        set
+        weakmap
+        weakset
+        iterator
+        generator
+        error
+        proxy
+        promise
+        typedarray
+        arraybuffer
+        dataview
+        webassemblymemory
+        wasmvalue
+        # blink's subtypes.
+        trustedtype
+
+  experimental type EntryPreview extends object
+    properties
+      # Preview of the key. Specified for map-like collection entries.
+      optional ObjectPreview key
+      # Preview of the value.
+      ObjectPreview value
+
+  # Object property descriptor.
+  type PropertyDescriptor extends object
+    properties
+      # Property name or symbol description.
+      string name
+      # The value associated with the property.
+      optional RemoteObject value
+      # True if the value associated with the property may be changed (data descriptors only).
+      optional boolean writable
+      # A function which serves as a getter for the property, or `undefined` if there is no getter
+      # (accessor descriptors only).
+      optional RemoteObject get
+      # A function which serves as a setter for the property, or `undefined` if there is no setter
+      # (accessor descriptors only).
+      optional RemoteObject set
+      # True if the type of this property descriptor may be changed and if the property may be
+      # deleted from the corresponding object.
+      boolean configurable
+      # True if this property shows up during enumeration of the properties on the corresponding
+      # object.
+      boolean enumerable
+      # True if the result was thrown during the evaluation.
+      optional boolean wasThrown
+      # True if the property is owned for the object.
+      optional boolean isOwn
+      # Property symbol object, if the property is of the `symbol` type.
+      optional RemoteObject symbol
+
+  # Object internal property descriptor. This property isn't normally visible in JavaScript code.
+  type InternalPropertyDescriptor extends object
+    properties
+      # Conventional property name.
+      string name
+      # The value associated with the property.
+      optional RemoteObject value
+
+  # Object private field descriptor.
+  experimental type PrivatePropertyDescriptor extends object
+    properties
+      # Private property name.
+      string name
+      # The value associated with the private property.
+      optional RemoteObject value
+      # A function which serves as a getter for the private property,
+      # or `undefined` if there is no getter (accessor descriptors only).
+      optional RemoteObject get
+      # A function which serves as a setter for the private property,
+      # or `undefined` if there is no setter (accessor descriptors only).
+      optional RemoteObject set
+
+  # Represents function call argument. Either remote object id `objectId`, primitive `value`,
+  # unserializable primitive value or neither of (for undefined) them should be specified.
+  type CallArgument extends object
+    properties
+      # Primitive value or serializable javascript object.
+      optional any value
+      # Primitive value which can not be JSON-stringified.
+      optional UnserializableValue unserializableValue
+      # Remote object handle.
+      optional RemoteObjectId objectId
+
+  # Id of an execution context.
+  type ExecutionContextId extends integer
+
+  # Description of an isolated world.
+  type ExecutionContextDescription extends object
+    properties
+      # Unique id of the execution context. It can be used to specify in which execution context
+      # script evaluation should be performed.
+      ExecutionContextId id
+      # Execution context origin.
+      string origin
+      # Human readable name describing given context.
+      string name
+      # A system-unique execution context identifier. Unlike the id, this is unique across
+      # multiple processes, so can be reliably used to identify specific context while backend
+      # performs a cross-process navigation.
+      experimental string uniqueId
+      # Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'|'isolated'|'worker', frameId: string}
+      optional object auxData
+
+  # Detailed information about exception (or error) that was thrown during script compilation or
+  # execution.
+  type ExceptionDetails extends object
+    properties
+      # Exception id.
+      integer exceptionId
+      # Exception text, which should be used together with exception object when available.
+      string text
+      # Line number of the exception location (0-based).
+      integer lineNumber
+      # Column number of the exception location (0-based).
+      integer columnNumber
+      # Script ID of the exception location.
+      optional ScriptId scriptId
+      # URL of the exception location, to be used when the script was not reported.
+      optional string url
+      # JavaScript stack trace if available.
+      optional StackTrace stackTrace
+      # Exception object if available.
+      optional RemoteObject exception
+      # Identifier of the context where exception happened.
+      optional ExecutionContextId executionContextId
+      # Dictionary with entries of meta data that the client associated
+      # with this exception, such as information about associated network
+      # requests, etc.
+      experimental optional object exceptionMetaData
+
+  # Number of milliseconds since epoch.
+  type Timestamp extends number
+
+  # Number of milliseconds.
+  type TimeDelta extends number
+
+  # Stack entry for runtime errors and assertions.
+  type CallFrame extends object
+    properties
+      # JavaScript function name.
+      string functionName
+      # JavaScript script id.
+      ScriptId scriptId
+      # JavaScript script name or url.
+      string url
+      # JavaScript script line number (0-based).
+      integer lineNumber
+      # JavaScript script column number (0-based).
+      integer columnNumber
+
+  # Call frames for assertions or error messages.
+  type StackTrace extends object
+    properties
+      # String label of this stack trace. For async traces this may be a name of the function that
+      # initiated the async call.
+      optional string description
+      # JavaScript function name.
+      array of CallFrame callFrames
+      # Asynchronous JavaScript stack trace that preceded this stack, if available.
+      optional StackTrace parent
+      # Asynchronous JavaScript stack trace that preceded this stack, if available.
+      experimental optional StackTraceId parentId
+
+  # Unique identifier of current debugger.
+  experimental type UniqueDebuggerId extends string
+
+  # If `debuggerId` is set stack trace comes from another debugger and can be resolved there. This
+  # allows to track cross-debugger calls. See `Runtime.StackTrace` and `Debugger.paused` for usages.
+  experimental type StackTraceId extends object
+    properties
+      string id
+      optional UniqueDebuggerId debuggerId
+
+  # Add handler to promise with given promise object id.
+  command awaitPromise
+    parameters
+      # Identifier of the promise.
+      RemoteObjectId promiseObjectId
+      # Whether the result is expected to be a JSON object that should be sent by value.
+      optional boolean returnByValue
+      # Whether preview should be generated for the result.
+      optional boolean generatePreview
+    returns
+      # Promise result. Will contain rejected value if promise was rejected.
+      RemoteObject result
+      # Exception details if stack strace is available.
+      optional ExceptionDetails exceptionDetails
+
+  # Calls function with given declaration on the given object. Object group of the result is
+  # inherited from the target object.
+  command callFunctionOn
+    parameters
+      # Declaration of the function to call.
+      string functionDeclaration
+      # Identifier of the object to call function on. Either objectId or executionContextId should
+      # be specified.
+      optional RemoteObjectId objectId
+      # Call arguments. All call arguments must belong to the same JavaScript world as the target
+      # object.
+      optional array of CallArgument arguments
+      # In silent mode exceptions thrown during evaluation are not reported and do not pause
+      # execution. Overrides `setPauseOnException` state.
+      optional boolean silent
+      # Whether the result is expected to be a JSON object which should be sent by value.
+      # Can be overriden by `serializationOptions`.
+      optional boolean returnByValue
+      # Whether preview should be generated for the result.
+      experimental optional boolean generatePreview
+      # Whether execution should be treated as initiated by user in the UI.
+      optional boolean userGesture
+      # Whether execution should `await` for resulting value and return once awaited promise is
+      # resolved.
+      optional boolean awaitPromise
+      # Specifies execution context which global object will be used to call function on. Either
+      # executionContextId or objectId should be specified.
+      optional ExecutionContextId executionContextId
+      # Symbolic group name that can be used to release multiple objects. If objectGroup is not
+      # specified and objectId is, objectGroup will be inherited from object.
+      optional string objectGroup
+      # Whether to throw an exception if side effect cannot be ruled out during evaluation.
+      experimental optional boolean throwOnSideEffect
+      # An alternative way to specify the execution context to call function on.
+      # Compared to contextId that may be reused across processes, this is guaranteed to be
+      # system-unique, so it can be used to prevent accidental function call
+      # in context different than intended (e.g. as a result of navigation across process
+      # boundaries).
+      # This is mutually exclusive with `executionContextId`.
+      experimental optional string uniqueContextId
+      # Specifies the result serialization. If provided, overrides
+      # `generatePreview` and `returnByValue`.
+      experimental optional SerializationOptions serializationOptions
+
+    returns
+      # Call result.
+      RemoteObject result
+      # Exception details.
+      optional ExceptionDetails exceptionDetails
+
+  # Compiles expression.
+  command compileScript
+    parameters
+      # Expression to compile.
+      string expression
+      # Source url to be set for the script.
+      string sourceURL
+      # Specifies whether the compiled script should be persisted.
+      boolean persistScript
+      # Specifies in which execution context to perform script run. If the parameter is omitted the
+      # evaluation will be performed in the context of the inspected page.
+      optional ExecutionContextId executionContextId
+    returns
+      # Id of the script.
+      optional ScriptId scriptId
+      # Exception details.
+      optional ExceptionDetails exceptionDetails
+
+  # Disables reporting of execution contexts creation.
+  command disable
+
+  # Discards collected exceptions and console API calls.
+  command discardConsoleEntries
+
+  # Enables reporting of execution contexts creation by means of `executionContextCreated` event.
+  # When the reporting gets enabled the event will be sent immediately for each existing execution
+  # context.
+  command enable
+
+  # Evaluates expression on global object.
+  command evaluate
+    parameters
+      # Expression to evaluate.
+      string expression
+      # Symbolic group name that can be used to release multiple objects.
+      optional string objectGroup
+      # Determines whether Command Line API should be available during the evaluation.
+      optional boolean includeCommandLineAPI
+      # In silent mode exceptions thrown during evaluation are not reported and do not pause
+      # execution. Overrides `setPauseOnException` state.
+      optional boolean silent
+      # Specifies in which execution context to perform evaluation. If the parameter is omitted the
+      # evaluation will be performed in the context of the inspected page.
+      # This is mutually exclusive with `uniqueContextId`, which offers an
+      # alternative way to identify the execution context that is more reliable
+      # in a multi-process environment.
+      optional ExecutionContextId contextId
+      # Whether the result is expected to be a JSON object that should be sent by value.
+      optional boolean returnByValue
+      # Whether preview should be generated for the result.
+      experimental optional boolean generatePreview
+      # Whether execution should be treated as initiated by user in the UI.
+      optional boolean userGesture
+      # Whether execution should `await` for resulting value and return once awaited promise is
+      # resolved.
+      optional boolean awaitPromise
+      # Whether to throw an exception if side effect cannot be ruled out during evaluation.
+      # This implies `disableBreaks` below.
+      experimental optional boolean throwOnSideEffect
+      # Terminate execution after timing out (number of milliseconds).
+      experimental optional TimeDelta timeout
+      # Disable breakpoints during execution.
+      experimental optional boolean disableBreaks
+      # Setting this flag to true enables `let` re-declaration and top-level `await`.
+      # Note that `let` variables can only be re-declared if they originate from
+      # `replMode` themselves.
+      experimental optional boolean replMode
+      # The Content Security Policy (CSP) for the target might block 'unsafe-eval'
+      # which includes eval(), Function(), setTimeout() and setInterval()
+      # when called with non-callable arguments. This flag bypasses CSP for this
+      # evaluation and allows unsafe-eval. Defaults to true.
+      experimental optional boolean allowUnsafeEvalBlockedByCSP
+      # An alternative way to specify the execution context to evaluate in.
+      # Compared to contextId that may be reused across processes, this is guaranteed to be
+      # system-unique, so it can be used to prevent accidental evaluation of the expression
+      # in context different than intended (e.g. as a result of navigation across process
+      # boundaries).
+      # This is mutually exclusive with `contextId`.
+      experimental optional string uniqueContextId
+      # Specifies the result serialization. If provided, overrides
+      # `generatePreview` and `returnByValue`.
+      experimental optional SerializationOptions serializationOptions
+    returns
+      # Evaluation result.
+      RemoteObject result
+      # Exception details.
+      optional ExceptionDetails exceptionDetails
+
+  # Returns the isolate id.
+  experimental command getIsolateId
+    returns
+      # The isolate id.
+      string id
+
+  # Returns the JavaScript heap usage.
+  # It is the total usage of the corresponding isolate not scoped to a particular Runtime.
+  experimental command getHeapUsage
+    returns
+      # Used JavaScript heap size in bytes.
+      number usedSize
+      # Allocated JavaScript heap size in bytes.
+      number totalSize
+      # Used size in bytes in the embedder's garbage-collected heap.
+      number embedderHeapUsedSize
+      # Size in bytes of backing storage for array buffers and external strings.
+      number backingStorageSize
+
+  # Returns properties of a given object. Object group of the result is inherited from the target
+  # object.
+  command getProperties
+    parameters
+      # Identifier of the object to return properties for.
+      RemoteObjectId objectId
+      # If true, returns properties belonging only to the element itself, not to its prototype
+      # chain.
+      optional boolean ownProperties
+      # If true, returns accessor properties (with getter/setter) only; internal properties are not
+      # returned either.
+      experimental optional boolean accessorPropertiesOnly
+      # Whether preview should be generated for the results.
+      experimental optional boolean generatePreview
+      # If true, returns non-indexed properties only.
+      experimental optional boolean nonIndexedPropertiesOnly
+    returns
+      # Object properties.
+      array of PropertyDescriptor result
+      # Internal object properties (only of the element itself).
+      optional array of InternalPropertyDescriptor internalProperties
+      # Object private properties.
+      experimental optional array of PrivatePropertyDescriptor privateProperties
+      # Exception details.
+      optional ExceptionDetails exceptionDetails
+
+  # Returns all let, const and class variables from global scope.
+  command globalLexicalScopeNames
+    parameters
+      # Specifies in which execution context to lookup global scope variables.
+      optional ExecutionContextId executionContextId
+    returns
+      array of string names
+
+  command queryObjects
+    parameters
+      # Identifier of the prototype to return objects for.
+      RemoteObjectId prototypeObjectId
+      # Symbolic group name that can be used to release the results.
+      optional string objectGroup
+    returns
+      # Array with objects.
+      RemoteObject objects
+
+  # Releases remote object with given id.
+  command releaseObject
+    parameters
+      # Identifier of the object to release.
+      RemoteObjectId objectId
+
+  # Releases all remote objects that belong to a given group.
+  command releaseObjectGroup
+    parameters
+      # Symbolic object group name.
+      string objectGroup
+
+  # Tells inspected instance to run if it was waiting for debugger to attach.
+  command runIfWaitingForDebugger
+
+  # Runs script with given id in a given context.
+  command runScript
+    parameters
+      # Id of the script to run.
+      ScriptId scriptId
+      # Specifies in which execution context to perform script run. If the parameter is omitted the
+      # evaluation will be performed in the context of the inspected page.
+      optional ExecutionContextId executionContextId
+      # Symbolic group name that can be used to release multiple objects.
+      optional string objectGroup
+      # In silent mode exceptions thrown during evaluation are not reported and do not pause
+      # execution. Overrides `setPauseOnException` state.
+      optional boolean silent
+      # Determines whether Command Line API should be available during the evaluation.
+      optional boolean includeCommandLineAPI
+      # Whether the result is expected to be a JSON object which should be sent by value.
+      optional boolean returnByValue
+      # Whether preview should be generated for the result.
+      optional boolean generatePreview
+      # Whether execution should `await` for resulting value and return once awaited promise is
+      # resolved.
+      optional boolean awaitPromise
+    returns
+      # Run result.
+      RemoteObject result
+      # Exception details.
+      optional ExceptionDetails exceptionDetails
+
+  # Enables or disables async call stacks tracking.
+  command setAsyncCallStackDepth
+    redirect Debugger
+    parameters
+      # Maximum depth of async call stacks. Setting to `0` will effectively disable collecting async
+      # call stacks (default).
+      integer maxDepth
+
+  experimental command setCustomObjectFormatterEnabled
+    parameters
+      boolean enabled
+
+  experimental command setMaxCallStackSizeToCapture
+    parameters
+      integer size
+
+  # Terminate current or next JavaScript execution.
+  # Will cancel the termination when the outer-most script execution ends.
+  experimental command terminateExecution
+
+  # If executionContextId is empty, adds binding with the given name on the
+  # global objects of all inspected contexts, including those created later,
+  # bindings survive reloads.
+  # Binding function takes exactly one argument, this argument should be string,
+  # in case of any other input, function throws an exception.
+  # Each binding function call produces Runtime.bindingCalled notification.
+  command addBinding
+    parameters
+      string name
+      # If specified, the binding would only be exposed to the specified
+      # execution context. If omitted and `executionContextName` is not set,
+      # the binding is exposed to all execution contexts of the target.
+      # This parameter is mutually exclusive with `executionContextName`.
+      # Deprecated in favor of `executionContextName` due to an unclear use case
+      # and bugs in implementation (crbug.com/1169639). `executionContextId` will be
+      # removed in the future.
+      experimental deprecated optional ExecutionContextId executionContextId
+      # If specified, the binding is exposed to the executionContext with
+      # matching name, even for contexts created after the binding is added.
+      # See also `ExecutionContext.name` and `worldName` parameter to
+      # `Page.addScriptToEvaluateOnNewDocument`.
+      # This parameter is mutually exclusive with `executionContextId`.
+      optional string executionContextName
+
+  # This method does not remove binding function from global object but
+  # unsubscribes current runtime agent from Runtime.bindingCalled notifications.
+  command removeBinding
+    parameters
+      string name
+
+  # This method tries to lookup and populate exception details for a
+  # JavaScript Error object.
+  # Note that the stackTrace portion of the resulting exceptionDetails will
+  # only be populated if the Runtime domain was enabled at the time when the
+  # Error was thrown.
+  experimental command getExceptionDetails
+    parameters
+      # The error object for which to resolve the exception details.
+      RemoteObjectId errorObjectId
+    returns
+      optional ExceptionDetails exceptionDetails
+
+  # Notification is issued every time when binding is called.
+  experimental event bindingCalled
+    parameters
+      string name
+      string payload
+      # Identifier of the context where the call was made.
+      ExecutionContextId executionContextId
+
+  # Issued when console API was called.
+  event consoleAPICalled
+    parameters
+      # Type of the call.
+      enum type
+        log
+        debug
+        info
+        error
+        warning
+        dir
+        dirxml
+        table
+        trace
+        clear
+        startGroup
+        startGroupCollapsed
+        endGroup
+        assert
+        profile
+        profileEnd
+        count
+        timeEnd
+      # Call arguments.
+      array of RemoteObject args
+      # Identifier of the context where the call was made.
+      ExecutionContextId executionContextId
+      # Call timestamp.
+      Timestamp timestamp
+      # Stack trace captured when the call was made. The async stack chain is automatically reported for
+      # the following call types: `assert`, `error`, `trace`, `warning`. For other types the async call
+      # chain can be retrieved using `Debugger.getStackTrace` and `stackTrace.parentId` field.
+      optional StackTrace stackTrace
+      # Console context descriptor for calls on non-default console context (not console.*):
+      # 'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call
+      # on named context.
+      experimental optional string context
+
+  # Issued when unhandled exception was revoked.
+  event exceptionRevoked
+    parameters
+      # Reason describing why exception was revoked.
+      string reason
+      # The id of revoked exception, as reported in `exceptionThrown`.
+      integer exceptionId
+
+  # Issued when exception was thrown and unhandled.
+  event exceptionThrown
+    parameters
+      # Timestamp of the exception.
+      Timestamp timestamp
+      ExceptionDetails exceptionDetails
+
+  # Issued when new execution context is created.
+  event executionContextCreated
+    parameters
+      # A newly created execution context.
+      ExecutionContextDescription context
+
+  # Issued when execution context is destroyed.
+  event executionContextDestroyed
+    parameters
+      # Id of the destroyed context
+      deprecated ExecutionContextId executionContextId
+      # Unique Id of the destroyed context
+      experimental string executionContextUniqueId
+
+  # Issued when all executionContexts were cleared in browser
+  event executionContextsCleared
+
+  # Issued when object should be inspected (for example, as a result of inspect() command line API
+  # call).
+  event inspectRequested
+    parameters
+      RemoteObject object
+      object hints
+      # Identifier of the context where the call was made.
+      experimental optional ExecutionContextId executionContextId
+
+# This domain is deprecated.
+deprecated domain Schema
+
+  # Description of the protocol domain.
+  type Domain extends object
+    properties
+      # Domain name.
+      string name
+      # Domain version.
+      string version
+
+  # Returns supported domains.
+  command getDomains
+    returns
+      # List of supported domains.
+      array of Domain domains
diff --git a/vendor/chromiumoxide_cdp/src/cdp.rs b/vendor/chromiumoxide_cdp/src/cdp.rs
new file mode 100644
index 0000000..e70f111
--- /dev/null
+++ b/vendor/chromiumoxide_cdp/src/cdp.rs
@@ -0,0 +1,111038 @@
+#[doc = r" This file is generated and should not be edited directly."]
+pub use events::*;
+#[doc = r" This trait allows for implementing custom events that are not covered by the"]
+#[doc = r" chrome protocol definitions."]
+#[doc = r""]
+#[doc = r" Every `CustomEvent` also requires an implementation of"]
+#[doc = r" `chromiumoxide_types::MethodType` and it must be `DeserializeOwned`"]
+#[doc = r" (`#[derive(serde::Deserialize)]`). This is necessary to identify match this"]
+#[doc = r" type against the provided `method` identifier of a `CdpEventMessage`"]
+#[doc = r" and to properly deserialize it from a `serde_json::Value`"]
+pub trait CustomEvent:
+    ::std::any::Any + serde::de::DeserializeOwned + chromiumoxide_types::MethodType + Send + Sync
+{
+    #[doc = r" Used to convert the json event into in instance of this type"]
+    fn from_json(event: serde_json::Value) -> serde_json::Result<Self>
+    where
+        Self: Sized + 'static,
+    {
+        serde_json::from_value(event)
+    }
+}
+impl<T: CustomEvent> sealed::SealedEvent for T {
+    fn as_any(&self) -> &dyn ::std::any::Any {
+        self
+    }
+}
+#[doc = r" This is trait that all Events share"]
+#[doc = r""]
+#[doc = r" This trait is sealed to prevent implementation. The only way to implement a new `Event` is by implementing `CustomEvent`"]
+pub trait Event: sealed::SealedEvent {}
+impl<T: sealed::SealedEvent> Event for T {}
+impl<T: CustomEvent + Event> sealed::SealedCustomEventConverter for T {}
+#[doc = r" Function type to convert a json event into an instance of it self but as dyn Event"]
+pub type EventConversion = Box<
+    dyn Fn(serde_json::Value) -> serde_json::Result<::std::sync::Arc<dyn Event>> + Send + 'static,
+>;
+#[doc = r" An enum that does nothing for built in types but contains the conversion method for custom events"]
+pub enum EventKind {
+    BuiltIn,
+    Custom(EventConversion),
+}
+impl EventKind {
+    #[doc = r" Whether this is a custom event"]
+    pub fn is_custom(&self) -> bool {
+        matches!(self, EventKind::Custom(_))
+    }
+}
+impl ::std::fmt::Debug for EventKind {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        match self {
+            EventKind::BuiltIn => f.debug_tuple("BuiltIn").finish(),
+            EventKind::Custom(_) => f.debug_tuple("Custom").finish(),
+        }
+    }
+}
+#[doc = r" A trait on top of the `Event` trait"]
+pub trait IntoEventKind: Event {
+    #[doc = r" What kind of event this type is"]
+    fn event_kind() -> EventKind
+    where
+        Self: Sized + 'static;
+}
+impl<T: sealed::SealedCustomEventConverter> IntoEventKind for T {
+    fn event_kind() -> EventKind
+    where
+        Self: Sized + 'static,
+    {
+        EventKind::Custom(Box::new(Self::event_arc))
+    }
+}
+pub(crate) mod sealed {
+    pub trait SealedCustomEventConverter: super::CustomEvent + super::Event {
+        fn event_arc(
+            event: serde_json::Value,
+        ) -> serde_json::Result<::std::sync::Arc<dyn super::Event>>
+        where
+            Self: Sized + 'static,
+        {
+            Ok(::std::sync::Arc::new(Self::from_json(event)?))
+        }
+    }
+    pub trait SealedEvent: ArcAny + chromiumoxide_types::MethodType {
+        #[doc = r" generate `&::std::any::Any`'s vtable from `&Trait`'s."]
+        fn as_any(&self) -> &dyn ::std::any::Any;
+    }
+    pub trait ArcAny: ::std::any::Any + Send + Sync {
+        fn into_any_arc(
+            self: ::std::sync::Arc<Self>,
+        ) -> ::std::sync::Arc<dyn ::std::any::Any + Send + Sync>;
+    }
+    impl<T: ::std::any::Any + Send + Sync> ArcAny for T {
+        fn into_any_arc(
+            self: ::std::sync::Arc<Self>,
+        ) -> ::std::sync::Arc<dyn ::std::any::Any + Send + Sync> {
+            self
+        }
+    }
+    impl dyn SealedEvent {
+        #[doc = r" Returns true if the trait object wraps an object of type `T`."]
+        #[inline]
+        pub fn is<T: SealedEvent>(&self) -> bool {
+            self.as_any().is::<T>()
+        }
+        #[inline]
+        pub fn downcast_arc<T: SealedEvent>(
+            self: ::std::sync::Arc<Self>,
+        ) -> Result<::std::sync::Arc<T>, ::std::sync::Arc<Self>>
+        where
+            T: ::std::any::Any + Send + Sync,
+        {
+            if self.is::<T>() {
+                Ok(ArcAny::into_any_arc(self).downcast::<T>().unwrap())
+            } else {
+                Err(self)
+            }
+        }
+    }
+}
+pub mod events {
+    use serde::Deserialize;
+    #[derive(Debug, PartialEq, Clone)]
+    pub struct CdpEventMessage {
+        #[doc = r" Name of the method"]
+        pub method: chromiumoxide_types::MethodId,
+        #[doc = r" The chromium session Id"]
+        pub session_id: Option<String>,
+        #[doc = r" Json params"]
+        pub params: CdpEvent,
+    }
+    impl chromiumoxide_types::Method for CdpEventMessage {
+        fn identifier(&self) -> chromiumoxide_types::MethodId {
+            match &self.params {
+                CdpEvent::DebuggerPaused(inner) => inner.identifier(),
+                CdpEvent::DebuggerResumed(inner) => inner.identifier(),
+                CdpEvent::DebuggerScriptFailedToParse(inner) => inner.identifier(),
+                CdpEvent::DebuggerScriptParsed(inner) => inner.identifier(),
+                CdpEvent::HeapProfilerAddHeapSnapshotChunk(inner) => inner.identifier(),
+                CdpEvent::HeapProfilerHeapStatsUpdate(inner) => inner.identifier(),
+                CdpEvent::HeapProfilerLastSeenObjectId(inner) => inner.identifier(),
+                CdpEvent::HeapProfilerReportHeapSnapshotProgress(inner) => inner.identifier(),
+                CdpEvent::HeapProfilerResetProfiles(inner) => inner.identifier(),
+                CdpEvent::ProfilerConsoleProfileFinished(inner) => inner.identifier(),
+                CdpEvent::ProfilerConsoleProfileStarted(inner) => inner.identifier(),
+                CdpEvent::ProfilerPreciseCoverageDeltaUpdate(inner) => inner.identifier(),
+                CdpEvent::RuntimeBindingCalled(inner) => inner.identifier(),
+                CdpEvent::RuntimeConsoleApiCalled(inner) => inner.identifier(),
+                CdpEvent::RuntimeExceptionRevoked(inner) => inner.identifier(),
+                CdpEvent::RuntimeExceptionThrown(inner) => inner.identifier(),
+                CdpEvent::RuntimeExecutionContextCreated(inner) => inner.identifier(),
+                CdpEvent::RuntimeExecutionContextDestroyed(inner) => inner.identifier(),
+                CdpEvent::RuntimeExecutionContextsCleared(inner) => inner.identifier(),
+                CdpEvent::RuntimeInspectRequested(inner) => inner.identifier(),
+                CdpEvent::AccessibilityLoadComplete(inner) => inner.identifier(),
+                CdpEvent::AccessibilityNodesUpdated(inner) => inner.identifier(),
+                CdpEvent::AnimationAnimationCanceled(inner) => inner.identifier(),
+                CdpEvent::AnimationAnimationCreated(inner) => inner.identifier(),
+                CdpEvent::AnimationAnimationStarted(inner) => inner.identifier(),
+                CdpEvent::AnimationAnimationUpdated(inner) => inner.identifier(),
+                CdpEvent::AuditsIssueAdded(inner) => inner.identifier(),
+                CdpEvent::AutofillAddressFormFilled(inner) => inner.identifier(),
+                CdpEvent::BackgroundServiceRecordingStateChanged(inner) => inner.identifier(),
+                CdpEvent::BackgroundServiceBackgroundServiceEventReceived(inner) => {
+                    inner.identifier()
+                }
+                CdpEvent::BluetoothEmulationGattOperationReceived(inner) => inner.identifier(),
+                CdpEvent::BluetoothEmulationCharacteristicOperationReceived(inner) => {
+                    inner.identifier()
+                }
+                CdpEvent::BluetoothEmulationDescriptorOperationReceived(inner) => {
+                    inner.identifier()
+                }
+                CdpEvent::BrowserDownloadWillBegin(inner) => inner.identifier(),
+                CdpEvent::BrowserDownloadProgress(inner) => inner.identifier(),
+                CdpEvent::CssFontsUpdated(inner) => inner.identifier(),
+                CdpEvent::CssMediaQueryResultChanged(inner) => inner.identifier(),
+                CdpEvent::CssStyleSheetAdded(inner) => inner.identifier(),
+                CdpEvent::CssStyleSheetChanged(inner) => inner.identifier(),
+                CdpEvent::CssStyleSheetRemoved(inner) => inner.identifier(),
+                CdpEvent::CssComputedStyleUpdated(inner) => inner.identifier(),
+                CdpEvent::CastSinksUpdated(inner) => inner.identifier(),
+                CdpEvent::CastIssueUpdated(inner) => inner.identifier(),
+                CdpEvent::DomAttributeModified(inner) => inner.identifier(),
+                CdpEvent::DomAdoptedStyleSheetsModified(inner) => inner.identifier(),
+                CdpEvent::DomAttributeRemoved(inner) => inner.identifier(),
+                CdpEvent::DomCharacterDataModified(inner) => inner.identifier(),
+                CdpEvent::DomChildNodeCountUpdated(inner) => inner.identifier(),
+                CdpEvent::DomChildNodeInserted(inner) => inner.identifier(),
+                CdpEvent::DomChildNodeRemoved(inner) => inner.identifier(),
+                CdpEvent::DomDistributedNodesUpdated(inner) => inner.identifier(),
+                CdpEvent::DomDocumentUpdated(inner) => inner.identifier(),
+                CdpEvent::DomInlineStyleInvalidated(inner) => inner.identifier(),
+                CdpEvent::DomPseudoElementAdded(inner) => inner.identifier(),
+                CdpEvent::DomTopLayerElementsUpdated(inner) => inner.identifier(),
+                CdpEvent::DomScrollableFlagUpdated(inner) => inner.identifier(),
+                CdpEvent::DomAffectedByStartingStylesFlagUpdated(inner) => inner.identifier(),
+                CdpEvent::DomPseudoElementRemoved(inner) => inner.identifier(),
+                CdpEvent::DomSetChildNodes(inner) => inner.identifier(),
+                CdpEvent::DomShadowRootPopped(inner) => inner.identifier(),
+                CdpEvent::DomShadowRootPushed(inner) => inner.identifier(),
+                CdpEvent::DomStorageDomStorageItemAdded(inner) => inner.identifier(),
+                CdpEvent::DomStorageDomStorageItemRemoved(inner) => inner.identifier(),
+                CdpEvent::DomStorageDomStorageItemUpdated(inner) => inner.identifier(),
+                CdpEvent::DomStorageDomStorageItemsCleared(inner) => inner.identifier(),
+                CdpEvent::DeviceAccessDeviceRequestPrompted(inner) => inner.identifier(),
+                CdpEvent::EmulationVirtualTimeBudgetExpired(inner) => inner.identifier(),
+                CdpEvent::FedCmDialogShown(inner) => inner.identifier(),
+                CdpEvent::FedCmDialogClosed(inner) => inner.identifier(),
+                CdpEvent::FetchRequestPaused(inner) => inner.identifier(),
+                CdpEvent::FetchAuthRequired(inner) => inner.identifier(),
+                CdpEvent::InputDragIntercepted(inner) => inner.identifier(),
+                CdpEvent::InspectorDetached(inner) => inner.identifier(),
+                CdpEvent::InspectorTargetCrashed(inner) => inner.identifier(),
+                CdpEvent::InspectorTargetReloadedAfterCrash(inner) => inner.identifier(),
+                CdpEvent::InspectorWorkerScriptLoaded(inner) => inner.identifier(),
+                CdpEvent::LayerTreeLayerPainted(inner) => inner.identifier(),
+                CdpEvent::LayerTreeLayerTreeDidChange(inner) => inner.identifier(),
+                CdpEvent::LogEntryAdded(inner) => inner.identifier(),
+                CdpEvent::MediaPlayerPropertiesChanged(inner) => inner.identifier(),
+                CdpEvent::MediaPlayerEventsAdded(inner) => inner.identifier(),
+                CdpEvent::MediaPlayerMessagesLogged(inner) => inner.identifier(),
+                CdpEvent::MediaPlayerErrorsRaised(inner) => inner.identifier(),
+                CdpEvent::MediaPlayerCreated(inner) => inner.identifier(),
+                CdpEvent::NetworkDataReceived(inner) => inner.identifier(),
+                CdpEvent::NetworkEventSourceMessageReceived(inner) => inner.identifier(),
+                CdpEvent::NetworkLoadingFailed(inner) => inner.identifier(),
+                CdpEvent::NetworkLoadingFinished(inner) => inner.identifier(),
+                CdpEvent::NetworkRequestServedFromCache(inner) => inner.identifier(),
+                CdpEvent::NetworkRequestWillBeSent(inner) => inner.identifier(),
+                CdpEvent::NetworkResourceChangedPriority(inner) => inner.identifier(),
+                CdpEvent::NetworkSignedExchangeReceived(inner) => inner.identifier(),
+                CdpEvent::NetworkResponseReceived(inner) => inner.identifier(),
+                CdpEvent::NetworkWebSocketClosed(inner) => inner.identifier(),
+                CdpEvent::NetworkWebSocketCreated(inner) => inner.identifier(),
+                CdpEvent::NetworkWebSocketFrameError(inner) => inner.identifier(),
+                CdpEvent::NetworkWebSocketFrameReceived(inner) => inner.identifier(),
+                CdpEvent::NetworkWebSocketFrameSent(inner) => inner.identifier(),
+                CdpEvent::NetworkWebSocketHandshakeResponseReceived(inner) => inner.identifier(),
+                CdpEvent::NetworkWebSocketWillSendHandshakeRequest(inner) => inner.identifier(),
+                CdpEvent::NetworkWebTransportCreated(inner) => inner.identifier(),
+                CdpEvent::NetworkWebTransportConnectionEstablished(inner) => inner.identifier(),
+                CdpEvent::NetworkWebTransportClosed(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectTcpSocketCreated(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectTcpSocketOpened(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectTcpSocketAborted(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectTcpSocketClosed(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectTcpSocketChunkSent(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectTcpSocketChunkReceived(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectUdpSocketJoinedMulticastGroup(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectUdpSocketLeftMulticastGroup(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectUdpSocketCreated(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectUdpSocketOpened(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectUdpSocketAborted(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectUdpSocketClosed(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectUdpSocketChunkSent(inner) => inner.identifier(),
+                CdpEvent::NetworkDirectUdpSocketChunkReceived(inner) => inner.identifier(),
+                CdpEvent::NetworkRequestWillBeSentExtraInfo(inner) => inner.identifier(),
+                CdpEvent::NetworkResponseReceivedExtraInfo(inner) => inner.identifier(),
+                CdpEvent::NetworkResponseReceivedEarlyHints(inner) => inner.identifier(),
+                CdpEvent::NetworkTrustTokenOperationDone(inner) => inner.identifier(),
+                CdpEvent::NetworkPolicyUpdated(inner) => inner.identifier(),
+                CdpEvent::NetworkReportingApiReportAdded(inner) => inner.identifier(),
+                CdpEvent::NetworkReportingApiReportUpdated(inner) => inner.identifier(),
+                CdpEvent::NetworkReportingApiEndpointsChangedForOrigin(inner) => inner.identifier(),
+                CdpEvent::NetworkDeviceBoundSessionsAdded(inner) => inner.identifier(),
+                CdpEvent::NetworkDeviceBoundSessionEventOccurred(inner) => inner.identifier(),
+                CdpEvent::OverlayInspectNodeRequested(inner) => inner.identifier(),
+                CdpEvent::OverlayNodeHighlightRequested(inner) => inner.identifier(),
+                CdpEvent::OverlayScreenshotRequested(inner) => inner.identifier(),
+                CdpEvent::OverlayInspectModeCanceled(inner) => inner.identifier(),
+                CdpEvent::PageDomContentEventFired(inner) => inner.identifier(),
+                CdpEvent::PageFileChooserOpened(inner) => inner.identifier(),
+                CdpEvent::PageFrameAttached(inner) => inner.identifier(),
+                CdpEvent::PageFrameDetached(inner) => inner.identifier(),
+                CdpEvent::PageFrameSubtreeWillBeDetached(inner) => inner.identifier(),
+                CdpEvent::PageFrameNavigated(inner) => inner.identifier(),
+                CdpEvent::PageDocumentOpened(inner) => inner.identifier(),
+                CdpEvent::PageFrameResized(inner) => inner.identifier(),
+                CdpEvent::PageFrameStartedNavigating(inner) => inner.identifier(),
+                CdpEvent::PageFrameRequestedNavigation(inner) => inner.identifier(),
+                CdpEvent::PageFrameStartedLoading(inner) => inner.identifier(),
+                CdpEvent::PageFrameStoppedLoading(inner) => inner.identifier(),
+                CdpEvent::PageInterstitialHidden(inner) => inner.identifier(),
+                CdpEvent::PageInterstitialShown(inner) => inner.identifier(),
+                CdpEvent::PageJavascriptDialogClosed(inner) => inner.identifier(),
+                CdpEvent::PageJavascriptDialogOpening(inner) => inner.identifier(),
+                CdpEvent::PageLifecycleEvent(inner) => inner.identifier(),
+                CdpEvent::PageBackForwardCacheNotUsed(inner) => inner.identifier(),
+                CdpEvent::PageLoadEventFired(inner) => inner.identifier(),
+                CdpEvent::PageNavigatedWithinDocument(inner) => inner.identifier(),
+                CdpEvent::PageScreencastFrame(inner) => inner.identifier(),
+                CdpEvent::PageScreencastVisibilityChanged(inner) => inner.identifier(),
+                CdpEvent::PageWindowOpen(inner) => inner.identifier(),
+                CdpEvent::PageCompilationCacheProduced(inner) => inner.identifier(),
+                CdpEvent::PerformanceMetrics(inner) => inner.identifier(),
+                CdpEvent::PerformanceTimelineTimelineEventAdded(inner) => inner.identifier(),
+                CdpEvent::PreloadRuleSetUpdated(inner) => inner.identifier(),
+                CdpEvent::PreloadRuleSetRemoved(inner) => inner.identifier(),
+                CdpEvent::PreloadPreloadEnabledStateUpdated(inner) => inner.identifier(),
+                CdpEvent::PreloadPrefetchStatusUpdated(inner) => inner.identifier(),
+                CdpEvent::PreloadPrerenderStatusUpdated(inner) => inner.identifier(),
+                CdpEvent::PreloadPreloadingAttemptSourcesUpdated(inner) => inner.identifier(),
+                CdpEvent::SecurityVisibleSecurityStateChanged(inner) => inner.identifier(),
+                CdpEvent::ServiceWorkerWorkerErrorReported(inner) => inner.identifier(),
+                CdpEvent::ServiceWorkerWorkerRegistrationUpdated(inner) => inner.identifier(),
+                CdpEvent::ServiceWorkerWorkerVersionUpdated(inner) => inner.identifier(),
+                CdpEvent::StorageCacheStorageContentUpdated(inner) => inner.identifier(),
+                CdpEvent::StorageCacheStorageListUpdated(inner) => inner.identifier(),
+                CdpEvent::StorageIndexedDbContentUpdated(inner) => inner.identifier(),
+                CdpEvent::StorageIndexedDbListUpdated(inner) => inner.identifier(),
+                CdpEvent::StorageInterestGroupAccessed(inner) => inner.identifier(),
+                CdpEvent::StorageInterestGroupAuctionEventOccurred(inner) => inner.identifier(),
+                CdpEvent::StorageInterestGroupAuctionNetworkRequestCreated(inner) => {
+                    inner.identifier()
+                }
+                CdpEvent::StorageSharedStorageAccessed(inner) => inner.identifier(),
+                CdpEvent::StorageSharedStorageWorkletOperationExecutionFinished(inner) => {
+                    inner.identifier()
+                }
+                CdpEvent::StorageStorageBucketCreatedOrUpdated(inner) => inner.identifier(),
+                CdpEvent::StorageStorageBucketDeleted(inner) => inner.identifier(),
+                CdpEvent::StorageAttributionReportingSourceRegistered(inner) => inner.identifier(),
+                CdpEvent::StorageAttributionReportingTriggerRegistered(inner) => inner.identifier(),
+                CdpEvent::StorageAttributionReportingReportSent(inner) => inner.identifier(),
+                CdpEvent::StorageAttributionReportingVerboseDebugReportSent(inner) => {
+                    inner.identifier()
+                }
+                CdpEvent::TargetAttachedToTarget(inner) => inner.identifier(),
+                CdpEvent::TargetDetachedFromTarget(inner) => inner.identifier(),
+                CdpEvent::TargetReceivedMessageFromTarget(inner) => inner.identifier(),
+                CdpEvent::TargetTargetCreated(inner) => inner.identifier(),
+                CdpEvent::TargetTargetDestroyed(inner) => inner.identifier(),
+                CdpEvent::TargetTargetCrashed(inner) => inner.identifier(),
+                CdpEvent::TargetTargetInfoChanged(inner) => inner.identifier(),
+                CdpEvent::TetheringAccepted(inner) => inner.identifier(),
+                CdpEvent::TracingBufferUsage(inner) => inner.identifier(),
+                CdpEvent::TracingDataCollected(inner) => inner.identifier(),
+                CdpEvent::TracingTracingComplete(inner) => inner.identifier(),
+                CdpEvent::WebAudioContextCreated(inner) => inner.identifier(),
+                CdpEvent::WebAudioContextWillBeDestroyed(inner) => inner.identifier(),
+                CdpEvent::WebAudioContextChanged(inner) => inner.identifier(),
+                CdpEvent::WebAudioAudioListenerCreated(inner) => inner.identifier(),
+                CdpEvent::WebAudioAudioListenerWillBeDestroyed(inner) => inner.identifier(),
+                CdpEvent::WebAudioAudioNodeCreated(inner) => inner.identifier(),
+                CdpEvent::WebAudioAudioNodeWillBeDestroyed(inner) => inner.identifier(),
+                CdpEvent::WebAudioAudioParamCreated(inner) => inner.identifier(),
+                CdpEvent::WebAudioAudioParamWillBeDestroyed(inner) => inner.identifier(),
+                CdpEvent::WebAudioNodesConnected(inner) => inner.identifier(),
+                CdpEvent::WebAudioNodesDisconnected(inner) => inner.identifier(),
+                CdpEvent::WebAudioNodeParamConnected(inner) => inner.identifier(),
+                CdpEvent::WebAudioNodeParamDisconnected(inner) => inner.identifier(),
+                CdpEvent::WebAuthnCredentialAdded(inner) => inner.identifier(),
+                CdpEvent::WebAuthnCredentialDeleted(inner) => inner.identifier(),
+                CdpEvent::WebAuthnCredentialUpdated(inner) => inner.identifier(),
+                CdpEvent::WebAuthnCredentialAsserted(inner) => inner.identifier(),
+                _ => self.method.clone(),
+            }
+        }
+    }
+    impl chromiumoxide_types::EventMessage for CdpEventMessage {
+        fn session_id(&self) -> Option<&str> {
+            self.session_id.as_deref()
+        }
+    }
+    #[derive(Debug, Clone, PartialEq)]
+    pub enum CdpEvent {
+        DebuggerPaused(super::js_protocol::debugger::EventPaused),
+        DebuggerResumed(super::js_protocol::debugger::EventResumed),
+        DebuggerScriptFailedToParse(Box<super::js_protocol::debugger::EventScriptFailedToParse>),
+        DebuggerScriptParsed(Box<super::js_protocol::debugger::EventScriptParsed>),
+        HeapProfilerAddHeapSnapshotChunk(
+            super::js_protocol::heap_profiler::EventAddHeapSnapshotChunk,
+        ),
+        HeapProfilerHeapStatsUpdate(super::js_protocol::heap_profiler::EventHeapStatsUpdate),
+        HeapProfilerLastSeenObjectId(super::js_protocol::heap_profiler::EventLastSeenObjectId),
+        HeapProfilerReportHeapSnapshotProgress(
+            super::js_protocol::heap_profiler::EventReportHeapSnapshotProgress,
+        ),
+        HeapProfilerResetProfiles(super::js_protocol::heap_profiler::EventResetProfiles),
+        ProfilerConsoleProfileFinished(super::js_protocol::profiler::EventConsoleProfileFinished),
+        ProfilerConsoleProfileStarted(super::js_protocol::profiler::EventConsoleProfileStarted),
+        ProfilerPreciseCoverageDeltaUpdate(
+            super::js_protocol::profiler::EventPreciseCoverageDeltaUpdate,
+        ),
+        RuntimeBindingCalled(super::js_protocol::runtime::EventBindingCalled),
+        RuntimeConsoleApiCalled(super::js_protocol::runtime::EventConsoleApiCalled),
+        RuntimeExceptionRevoked(super::js_protocol::runtime::EventExceptionRevoked),
+        RuntimeExceptionThrown(Box<super::js_protocol::runtime::EventExceptionThrown>),
+        RuntimeExecutionContextCreated(super::js_protocol::runtime::EventExecutionContextCreated),
+        RuntimeExecutionContextDestroyed(
+            super::js_protocol::runtime::EventExecutionContextDestroyed,
+        ),
+        RuntimeExecutionContextsCleared(super::js_protocol::runtime::EventExecutionContextsCleared),
+        RuntimeInspectRequested(Box<super::js_protocol::runtime::EventInspectRequested>),
+        AccessibilityLoadComplete(Box<super::browser_protocol::accessibility::EventLoadComplete>),
+        AccessibilityNodesUpdated(super::browser_protocol::accessibility::EventNodesUpdated),
+        AnimationAnimationCanceled(super::browser_protocol::animation::EventAnimationCanceled),
+        AnimationAnimationCreated(super::browser_protocol::animation::EventAnimationCreated),
+        AnimationAnimationStarted(Box<super::browser_protocol::animation::EventAnimationStarted>),
+        AnimationAnimationUpdated(Box<super::browser_protocol::animation::EventAnimationUpdated>),
+        AuditsIssueAdded(Box<super::browser_protocol::audits::EventIssueAdded>),
+        AutofillAddressFormFilled(super::browser_protocol::autofill::EventAddressFormFilled),
+        BackgroundServiceRecordingStateChanged(
+            super::browser_protocol::background_service::EventRecordingStateChanged,
+        ),
+        BackgroundServiceBackgroundServiceEventReceived(
+            super::browser_protocol::background_service::EventBackgroundServiceEventReceived,
+        ),
+        BluetoothEmulationGattOperationReceived(
+            super::browser_protocol::bluetooth_emulation::EventGattOperationReceived,
+        ),
+        BluetoothEmulationCharacteristicOperationReceived(
+            super::browser_protocol::bluetooth_emulation::EventCharacteristicOperationReceived,
+        ),
+        BluetoothEmulationDescriptorOperationReceived(
+            super::browser_protocol::bluetooth_emulation::EventDescriptorOperationReceived,
+        ),
+        BrowserDownloadWillBegin(super::browser_protocol::browser::EventDownloadWillBegin),
+        BrowserDownloadProgress(super::browser_protocol::browser::EventDownloadProgress),
+        CssFontsUpdated(Box<super::browser_protocol::css::EventFontsUpdated>),
+        CssMediaQueryResultChanged(super::browser_protocol::css::EventMediaQueryResultChanged),
+        CssStyleSheetAdded(super::browser_protocol::css::EventStyleSheetAdded),
+        CssStyleSheetChanged(super::browser_protocol::css::EventStyleSheetChanged),
+        CssStyleSheetRemoved(super::browser_protocol::css::EventStyleSheetRemoved),
+        CssComputedStyleUpdated(super::browser_protocol::css::EventComputedStyleUpdated),
+        CastSinksUpdated(super::browser_protocol::cast::EventSinksUpdated),
+        CastIssueUpdated(super::browser_protocol::cast::EventIssueUpdated),
+        DomAttributeModified(super::browser_protocol::dom::EventAttributeModified),
+        DomAdoptedStyleSheetsModified(
+            super::browser_protocol::dom::EventAdoptedStyleSheetsModified,
+        ),
+        DomAttributeRemoved(super::browser_protocol::dom::EventAttributeRemoved),
+        DomCharacterDataModified(super::browser_protocol::dom::EventCharacterDataModified),
+        DomChildNodeCountUpdated(super::browser_protocol::dom::EventChildNodeCountUpdated),
+        DomChildNodeInserted(Box<super::browser_protocol::dom::EventChildNodeInserted>),
+        DomChildNodeRemoved(super::browser_protocol::dom::EventChildNodeRemoved),
+        DomDistributedNodesUpdated(super::browser_protocol::dom::EventDistributedNodesUpdated),
+        DomDocumentUpdated(super::browser_protocol::dom::EventDocumentUpdated),
+        DomInlineStyleInvalidated(super::browser_protocol::dom::EventInlineStyleInvalidated),
+        DomPseudoElementAdded(Box<super::browser_protocol::dom::EventPseudoElementAdded>),
+        DomTopLayerElementsUpdated(super::browser_protocol::dom::EventTopLayerElementsUpdated),
+        DomScrollableFlagUpdated(super::browser_protocol::dom::EventScrollableFlagUpdated),
+        DomAffectedByStartingStylesFlagUpdated(
+            super::browser_protocol::dom::EventAffectedByStartingStylesFlagUpdated,
+        ),
+        DomPseudoElementRemoved(super::browser_protocol::dom::EventPseudoElementRemoved),
+        DomSetChildNodes(super::browser_protocol::dom::EventSetChildNodes),
+        DomShadowRootPopped(super::browser_protocol::dom::EventShadowRootPopped),
+        DomShadowRootPushed(Box<super::browser_protocol::dom::EventShadowRootPushed>),
+        DomStorageDomStorageItemAdded(
+            super::browser_protocol::dom_storage::EventDomStorageItemAdded,
+        ),
+        DomStorageDomStorageItemRemoved(
+            super::browser_protocol::dom_storage::EventDomStorageItemRemoved,
+        ),
+        DomStorageDomStorageItemUpdated(
+            super::browser_protocol::dom_storage::EventDomStorageItemUpdated,
+        ),
+        DomStorageDomStorageItemsCleared(
+            super::browser_protocol::dom_storage::EventDomStorageItemsCleared,
+        ),
+        DeviceAccessDeviceRequestPrompted(
+            super::browser_protocol::device_access::EventDeviceRequestPrompted,
+        ),
+        EmulationVirtualTimeBudgetExpired(
+            super::browser_protocol::emulation::EventVirtualTimeBudgetExpired,
+        ),
+        FedCmDialogShown(super::browser_protocol::fed_cm::EventDialogShown),
+        FedCmDialogClosed(super::browser_protocol::fed_cm::EventDialogClosed),
+        FetchRequestPaused(Box<super::browser_protocol::fetch::EventRequestPaused>),
+        FetchAuthRequired(Box<super::browser_protocol::fetch::EventAuthRequired>),
+        InputDragIntercepted(super::browser_protocol::input::EventDragIntercepted),
+        InspectorDetached(super::browser_protocol::inspector::EventDetached),
+        InspectorTargetCrashed(super::browser_protocol::inspector::EventTargetCrashed),
+        InspectorTargetReloadedAfterCrash(
+            super::browser_protocol::inspector::EventTargetReloadedAfterCrash,
+        ),
+        InspectorWorkerScriptLoaded(super::browser_protocol::inspector::EventWorkerScriptLoaded),
+        LayerTreeLayerPainted(super::browser_protocol::layer_tree::EventLayerPainted),
+        LayerTreeLayerTreeDidChange(super::browser_protocol::layer_tree::EventLayerTreeDidChange),
+        LogEntryAdded(Box<super::browser_protocol::log::EventEntryAdded>),
+        MediaPlayerPropertiesChanged(super::browser_protocol::media::EventPlayerPropertiesChanged),
+        MediaPlayerEventsAdded(super::browser_protocol::media::EventPlayerEventsAdded),
+        MediaPlayerMessagesLogged(super::browser_protocol::media::EventPlayerMessagesLogged),
+        MediaPlayerErrorsRaised(super::browser_protocol::media::EventPlayerErrorsRaised),
+        MediaPlayerCreated(super::browser_protocol::media::EventPlayerCreated),
+        NetworkDataReceived(super::browser_protocol::network::EventDataReceived),
+        NetworkEventSourceMessageReceived(
+            super::browser_protocol::network::EventEventSourceMessageReceived,
+        ),
+        NetworkLoadingFailed(super::browser_protocol::network::EventLoadingFailed),
+        NetworkLoadingFinished(super::browser_protocol::network::EventLoadingFinished),
+        NetworkRequestServedFromCache(
+            super::browser_protocol::network::EventRequestServedFromCache,
+        ),
+        NetworkRequestWillBeSent(Box<super::browser_protocol::network::EventRequestWillBeSent>),
+        NetworkResourceChangedPriority(
+            super::browser_protocol::network::EventResourceChangedPriority,
+        ),
+        NetworkSignedExchangeReceived(
+            Box<super::browser_protocol::network::EventSignedExchangeReceived>,
+        ),
+        NetworkResponseReceived(Box<super::browser_protocol::network::EventResponseReceived>),
+        NetworkWebSocketClosed(super::browser_protocol::network::EventWebSocketClosed),
+        NetworkWebSocketCreated(Box<super::browser_protocol::network::EventWebSocketCreated>),
+        NetworkWebSocketFrameError(super::browser_protocol::network::EventWebSocketFrameError),
+        NetworkWebSocketFrameReceived(
+            super::browser_protocol::network::EventWebSocketFrameReceived,
+        ),
+        NetworkWebSocketFrameSent(super::browser_protocol::network::EventWebSocketFrameSent),
+        NetworkWebSocketHandshakeResponseReceived(
+            Box<super::browser_protocol::network::EventWebSocketHandshakeResponseReceived>,
+        ),
+        NetworkWebSocketWillSendHandshakeRequest(
+            super::browser_protocol::network::EventWebSocketWillSendHandshakeRequest,
+        ),
+        NetworkWebTransportCreated(Box<super::browser_protocol::network::EventWebTransportCreated>),
+        NetworkWebTransportConnectionEstablished(
+            super::browser_protocol::network::EventWebTransportConnectionEstablished,
+        ),
+        NetworkWebTransportClosed(super::browser_protocol::network::EventWebTransportClosed),
+        NetworkDirectTcpSocketCreated(
+            Box<super::browser_protocol::network::EventDirectTcpSocketCreated>,
+        ),
+        NetworkDirectTcpSocketOpened(super::browser_protocol::network::EventDirectTcpSocketOpened),
+        NetworkDirectTcpSocketAborted(
+            super::browser_protocol::network::EventDirectTcpSocketAborted,
+        ),
+        NetworkDirectTcpSocketClosed(super::browser_protocol::network::EventDirectTcpSocketClosed),
+        NetworkDirectTcpSocketChunkSent(
+            super::browser_protocol::network::EventDirectTcpSocketChunkSent,
+        ),
+        NetworkDirectTcpSocketChunkReceived(
+            super::browser_protocol::network::EventDirectTcpSocketChunkReceived,
+        ),
+        NetworkDirectUdpSocketJoinedMulticastGroup(
+            super::browser_protocol::network::EventDirectUdpSocketJoinedMulticastGroup,
+        ),
+        NetworkDirectUdpSocketLeftMulticastGroup(
+            super::browser_protocol::network::EventDirectUdpSocketLeftMulticastGroup,
+        ),
+        NetworkDirectUdpSocketCreated(
+            Box<super::browser_protocol::network::EventDirectUdpSocketCreated>,
+        ),
+        NetworkDirectUdpSocketOpened(super::browser_protocol::network::EventDirectUdpSocketOpened),
+        NetworkDirectUdpSocketAborted(
+            super::browser_protocol::network::EventDirectUdpSocketAborted,
+        ),
+        NetworkDirectUdpSocketClosed(super::browser_protocol::network::EventDirectUdpSocketClosed),
+        NetworkDirectUdpSocketChunkSent(
+            super::browser_protocol::network::EventDirectUdpSocketChunkSent,
+        ),
+        NetworkDirectUdpSocketChunkReceived(
+            super::browser_protocol::network::EventDirectUdpSocketChunkReceived,
+        ),
+        NetworkRequestWillBeSentExtraInfo(
+            super::browser_protocol::network::EventRequestWillBeSentExtraInfo,
+        ),
+        NetworkResponseReceivedExtraInfo(
+            Box<super::browser_protocol::network::EventResponseReceivedExtraInfo>,
+        ),
+        NetworkResponseReceivedEarlyHints(
+            super::browser_protocol::network::EventResponseReceivedEarlyHints,
+        ),
+        NetworkTrustTokenOperationDone(
+            super::browser_protocol::network::EventTrustTokenOperationDone,
+        ),
+        NetworkPolicyUpdated(super::browser_protocol::network::EventPolicyUpdated),
+        NetworkReportingApiReportAdded(
+            super::browser_protocol::network::EventReportingApiReportAdded,
+        ),
+        NetworkReportingApiReportUpdated(
+            super::browser_protocol::network::EventReportingApiReportUpdated,
+        ),
+        NetworkReportingApiEndpointsChangedForOrigin(
+            super::browser_protocol::network::EventReportingApiEndpointsChangedForOrigin,
+        ),
+        NetworkDeviceBoundSessionsAdded(
+            super::browser_protocol::network::EventDeviceBoundSessionsAdded,
+        ),
+        NetworkDeviceBoundSessionEventOccurred(
+            Box<super::browser_protocol::network::EventDeviceBoundSessionEventOccurred>,
+        ),
+        OverlayInspectNodeRequested(super::browser_protocol::overlay::EventInspectNodeRequested),
+        OverlayNodeHighlightRequested(
+            super::browser_protocol::overlay::EventNodeHighlightRequested,
+        ),
+        OverlayScreenshotRequested(super::browser_protocol::overlay::EventScreenshotRequested),
+        OverlayInspectModeCanceled(super::browser_protocol::overlay::EventInspectModeCanceled),
+        PageDomContentEventFired(super::browser_protocol::page::EventDomContentEventFired),
+        PageFileChooserOpened(super::browser_protocol::page::EventFileChooserOpened),
+        PageFrameAttached(super::browser_protocol::page::EventFrameAttached),
+        PageFrameDetached(super::browser_protocol::page::EventFrameDetached),
+        PageFrameSubtreeWillBeDetached(
+            super::browser_protocol::page::EventFrameSubtreeWillBeDetached,
+        ),
+        PageFrameNavigated(Box<super::browser_protocol::page::EventFrameNavigated>),
+        PageDocumentOpened(Box<super::browser_protocol::page::EventDocumentOpened>),
+        PageFrameResized(super::browser_protocol::page::EventFrameResized),
+        PageFrameStartedNavigating(super::browser_protocol::page::EventFrameStartedNavigating),
+        PageFrameRequestedNavigation(super::browser_protocol::page::EventFrameRequestedNavigation),
+        PageFrameStartedLoading(super::browser_protocol::page::EventFrameStartedLoading),
+        PageFrameStoppedLoading(super::browser_protocol::page::EventFrameStoppedLoading),
+        PageInterstitialHidden(super::browser_protocol::page::EventInterstitialHidden),
+        PageInterstitialShown(super::browser_protocol::page::EventInterstitialShown),
+        PageJavascriptDialogClosed(super::browser_protocol::page::EventJavascriptDialogClosed),
+        PageJavascriptDialogOpening(super::browser_protocol::page::EventJavascriptDialogOpening),
+        PageLifecycleEvent(super::browser_protocol::page::EventLifecycleEvent),
+        PageBackForwardCacheNotUsed(super::browser_protocol::page::EventBackForwardCacheNotUsed),
+        PageLoadEventFired(super::browser_protocol::page::EventLoadEventFired),
+        PageNavigatedWithinDocument(super::browser_protocol::page::EventNavigatedWithinDocument),
+        PageScreencastFrame(super::browser_protocol::page::EventScreencastFrame),
+        PageScreencastVisibilityChanged(
+            super::browser_protocol::page::EventScreencastVisibilityChanged,
+        ),
+        PageWindowOpen(super::browser_protocol::page::EventWindowOpen),
+        PageCompilationCacheProduced(super::browser_protocol::page::EventCompilationCacheProduced),
+        PerformanceMetrics(super::browser_protocol::performance::EventMetrics),
+        PerformanceTimelineTimelineEventAdded(
+            Box<super::browser_protocol::performance_timeline::EventTimelineEventAdded>,
+        ),
+        PreloadRuleSetUpdated(Box<super::browser_protocol::preload::EventRuleSetUpdated>),
+        PreloadRuleSetRemoved(super::browser_protocol::preload::EventRuleSetRemoved),
+        PreloadPreloadEnabledStateUpdated(
+            super::browser_protocol::preload::EventPreloadEnabledStateUpdated,
+        ),
+        PreloadPrefetchStatusUpdated(
+            Box<super::browser_protocol::preload::EventPrefetchStatusUpdated>,
+        ),
+        PreloadPrerenderStatusUpdated(
+            super::browser_protocol::preload::EventPrerenderStatusUpdated,
+        ),
+        PreloadPreloadingAttemptSourcesUpdated(
+            super::browser_protocol::preload::EventPreloadingAttemptSourcesUpdated,
+        ),
+        SecurityVisibleSecurityStateChanged(
+            Box<super::browser_protocol::security::EventVisibleSecurityStateChanged>,
+        ),
+        ServiceWorkerWorkerErrorReported(
+            super::browser_protocol::service_worker::EventWorkerErrorReported,
+        ),
+        ServiceWorkerWorkerRegistrationUpdated(
+            super::browser_protocol::service_worker::EventWorkerRegistrationUpdated,
+        ),
+        ServiceWorkerWorkerVersionUpdated(
+            super::browser_protocol::service_worker::EventWorkerVersionUpdated,
+        ),
+        StorageCacheStorageContentUpdated(
+            super::browser_protocol::storage::EventCacheStorageContentUpdated,
+        ),
+        StorageCacheStorageListUpdated(
+            super::browser_protocol::storage::EventCacheStorageListUpdated,
+        ),
+        StorageIndexedDbContentUpdated(
+            super::browser_protocol::storage::EventIndexedDbContentUpdated,
+        ),
+        StorageIndexedDbListUpdated(super::browser_protocol::storage::EventIndexedDbListUpdated),
+        StorageInterestGroupAccessed(super::browser_protocol::storage::EventInterestGroupAccessed),
+        StorageInterestGroupAuctionEventOccurred(
+            super::browser_protocol::storage::EventInterestGroupAuctionEventOccurred,
+        ),
+        StorageInterestGroupAuctionNetworkRequestCreated(
+            super::browser_protocol::storage::EventInterestGroupAuctionNetworkRequestCreated,
+        ),
+        StorageSharedStorageAccessed(
+            Box<super::browser_protocol::storage::EventSharedStorageAccessed>,
+        ),
+        StorageSharedStorageWorkletOperationExecutionFinished(
+            super::browser_protocol::storage::EventSharedStorageWorkletOperationExecutionFinished,
+        ),
+        StorageStorageBucketCreatedOrUpdated(
+            super::browser_protocol::storage::EventStorageBucketCreatedOrUpdated,
+        ),
+        StorageStorageBucketDeleted(super::browser_protocol::storage::EventStorageBucketDeleted),
+        StorageAttributionReportingSourceRegistered(
+            Box<super::browser_protocol::storage::EventAttributionReportingSourceRegistered>,
+        ),
+        StorageAttributionReportingTriggerRegistered(
+            Box<super::browser_protocol::storage::EventAttributionReportingTriggerRegistered>,
+        ),
+        StorageAttributionReportingReportSent(
+            super::browser_protocol::storage::EventAttributionReportingReportSent,
+        ),
+        StorageAttributionReportingVerboseDebugReportSent(
+            super::browser_protocol::storage::EventAttributionReportingVerboseDebugReportSent,
+        ),
+        TargetAttachedToTarget(Box<super::browser_protocol::target::EventAttachedToTarget>),
+        TargetDetachedFromTarget(super::browser_protocol::target::EventDetachedFromTarget),
+        TargetReceivedMessageFromTarget(
+            super::browser_protocol::target::EventReceivedMessageFromTarget,
+        ),
+        TargetTargetCreated(Box<super::browser_protocol::target::EventTargetCreated>),
+        TargetTargetDestroyed(super::browser_protocol::target::EventTargetDestroyed),
+        TargetTargetCrashed(super::browser_protocol::target::EventTargetCrashed),
+        TargetTargetInfoChanged(Box<super::browser_protocol::target::EventTargetInfoChanged>),
+        TetheringAccepted(super::browser_protocol::tethering::EventAccepted),
+        TracingBufferUsage(super::browser_protocol::tracing::EventBufferUsage),
+        TracingDataCollected(super::browser_protocol::tracing::EventDataCollected),
+        TracingTracingComplete(super::browser_protocol::tracing::EventTracingComplete),
+        WebAudioContextCreated(super::browser_protocol::web_audio::EventContextCreated),
+        WebAudioContextWillBeDestroyed(
+            super::browser_protocol::web_audio::EventContextWillBeDestroyed,
+        ),
+        WebAudioContextChanged(super::browser_protocol::web_audio::EventContextChanged),
+        WebAudioAudioListenerCreated(super::browser_protocol::web_audio::EventAudioListenerCreated),
+        WebAudioAudioListenerWillBeDestroyed(
+            super::browser_protocol::web_audio::EventAudioListenerWillBeDestroyed,
+        ),
+        WebAudioAudioNodeCreated(super::browser_protocol::web_audio::EventAudioNodeCreated),
+        WebAudioAudioNodeWillBeDestroyed(
+            super::browser_protocol::web_audio::EventAudioNodeWillBeDestroyed,
+        ),
+        WebAudioAudioParamCreated(super::browser_protocol::web_audio::EventAudioParamCreated),
+        WebAudioAudioParamWillBeDestroyed(
+            super::browser_protocol::web_audio::EventAudioParamWillBeDestroyed,
+        ),
+        WebAudioNodesConnected(super::browser_protocol::web_audio::EventNodesConnected),
+        WebAudioNodesDisconnected(super::browser_protocol::web_audio::EventNodesDisconnected),
+        WebAudioNodeParamConnected(super::browser_protocol::web_audio::EventNodeParamConnected),
+        WebAudioNodeParamDisconnected(
+            super::browser_protocol::web_audio::EventNodeParamDisconnected,
+        ),
+        WebAuthnCredentialAdded(Box<super::browser_protocol::web_authn::EventCredentialAdded>),
+        WebAuthnCredentialDeleted(super::browser_protocol::web_authn::EventCredentialDeleted),
+        WebAuthnCredentialUpdated(Box<super::browser_protocol::web_authn::EventCredentialUpdated>),
+        WebAuthnCredentialAsserted(
+            Box<super::browser_protocol::web_authn::EventCredentialAsserted>,
+        ),
+        Other(serde_json::Value),
+    }
+    impl CdpEvent {
+        pub fn other(other: serde_json::Value) -> Self {
+            CdpEvent::Other(other)
+        }
+        #[doc = r" Serializes the event as Json"]
+        pub fn into_json(self) -> serde_json::Result<serde_json::Value> {
+            match self {
+                CdpEvent::DebuggerPaused(inner) => serde_json::to_value(inner),
+                CdpEvent::DebuggerResumed(inner) => serde_json::to_value(inner),
+                CdpEvent::DebuggerScriptFailedToParse(inner) => serde_json::to_value(inner),
+                CdpEvent::DebuggerScriptParsed(inner) => serde_json::to_value(inner),
+                CdpEvent::HeapProfilerAddHeapSnapshotChunk(inner) => serde_json::to_value(inner),
+                CdpEvent::HeapProfilerHeapStatsUpdate(inner) => serde_json::to_value(inner),
+                CdpEvent::HeapProfilerLastSeenObjectId(inner) => serde_json::to_value(inner),
+                CdpEvent::HeapProfilerReportHeapSnapshotProgress(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::HeapProfilerResetProfiles(inner) => serde_json::to_value(inner),
+                CdpEvent::ProfilerConsoleProfileFinished(inner) => serde_json::to_value(inner),
+                CdpEvent::ProfilerConsoleProfileStarted(inner) => serde_json::to_value(inner),
+                CdpEvent::ProfilerPreciseCoverageDeltaUpdate(inner) => serde_json::to_value(inner),
+                CdpEvent::RuntimeBindingCalled(inner) => serde_json::to_value(inner),
+                CdpEvent::RuntimeConsoleApiCalled(inner) => serde_json::to_value(inner),
+                CdpEvent::RuntimeExceptionRevoked(inner) => serde_json::to_value(inner),
+                CdpEvent::RuntimeExceptionThrown(inner) => serde_json::to_value(inner),
+                CdpEvent::RuntimeExecutionContextCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::RuntimeExecutionContextDestroyed(inner) => serde_json::to_value(inner),
+                CdpEvent::RuntimeExecutionContextsCleared(inner) => serde_json::to_value(inner),
+                CdpEvent::RuntimeInspectRequested(inner) => serde_json::to_value(inner),
+                CdpEvent::AccessibilityLoadComplete(inner) => serde_json::to_value(inner),
+                CdpEvent::AccessibilityNodesUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::AnimationAnimationCanceled(inner) => serde_json::to_value(inner),
+                CdpEvent::AnimationAnimationCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::AnimationAnimationStarted(inner) => serde_json::to_value(inner),
+                CdpEvent::AnimationAnimationUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::AuditsIssueAdded(inner) => serde_json::to_value(inner),
+                CdpEvent::AutofillAddressFormFilled(inner) => serde_json::to_value(inner),
+                CdpEvent::BackgroundServiceRecordingStateChanged(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::BackgroundServiceBackgroundServiceEventReceived(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::BluetoothEmulationGattOperationReceived(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::BluetoothEmulationCharacteristicOperationReceived(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::BluetoothEmulationDescriptorOperationReceived(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::BrowserDownloadWillBegin(inner) => serde_json::to_value(inner),
+                CdpEvent::BrowserDownloadProgress(inner) => serde_json::to_value(inner),
+                CdpEvent::CssFontsUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::CssMediaQueryResultChanged(inner) => serde_json::to_value(inner),
+                CdpEvent::CssStyleSheetAdded(inner) => serde_json::to_value(inner),
+                CdpEvent::CssStyleSheetChanged(inner) => serde_json::to_value(inner),
+                CdpEvent::CssStyleSheetRemoved(inner) => serde_json::to_value(inner),
+                CdpEvent::CssComputedStyleUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::CastSinksUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::CastIssueUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::DomAttributeModified(inner) => serde_json::to_value(inner),
+                CdpEvent::DomAdoptedStyleSheetsModified(inner) => serde_json::to_value(inner),
+                CdpEvent::DomAttributeRemoved(inner) => serde_json::to_value(inner),
+                CdpEvent::DomCharacterDataModified(inner) => serde_json::to_value(inner),
+                CdpEvent::DomChildNodeCountUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::DomChildNodeInserted(inner) => serde_json::to_value(inner),
+                CdpEvent::DomChildNodeRemoved(inner) => serde_json::to_value(inner),
+                CdpEvent::DomDistributedNodesUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::DomDocumentUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::DomInlineStyleInvalidated(inner) => serde_json::to_value(inner),
+                CdpEvent::DomPseudoElementAdded(inner) => serde_json::to_value(inner),
+                CdpEvent::DomTopLayerElementsUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::DomScrollableFlagUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::DomAffectedByStartingStylesFlagUpdated(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::DomPseudoElementRemoved(inner) => serde_json::to_value(inner),
+                CdpEvent::DomSetChildNodes(inner) => serde_json::to_value(inner),
+                CdpEvent::DomShadowRootPopped(inner) => serde_json::to_value(inner),
+                CdpEvent::DomShadowRootPushed(inner) => serde_json::to_value(inner),
+                CdpEvent::DomStorageDomStorageItemAdded(inner) => serde_json::to_value(inner),
+                CdpEvent::DomStorageDomStorageItemRemoved(inner) => serde_json::to_value(inner),
+                CdpEvent::DomStorageDomStorageItemUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::DomStorageDomStorageItemsCleared(inner) => serde_json::to_value(inner),
+                CdpEvent::DeviceAccessDeviceRequestPrompted(inner) => serde_json::to_value(inner),
+                CdpEvent::EmulationVirtualTimeBudgetExpired(inner) => serde_json::to_value(inner),
+                CdpEvent::FedCmDialogShown(inner) => serde_json::to_value(inner),
+                CdpEvent::FedCmDialogClosed(inner) => serde_json::to_value(inner),
+                CdpEvent::FetchRequestPaused(inner) => serde_json::to_value(inner),
+                CdpEvent::FetchAuthRequired(inner) => serde_json::to_value(inner),
+                CdpEvent::InputDragIntercepted(inner) => serde_json::to_value(inner),
+                CdpEvent::InspectorDetached(inner) => serde_json::to_value(inner),
+                CdpEvent::InspectorTargetCrashed(inner) => serde_json::to_value(inner),
+                CdpEvent::InspectorTargetReloadedAfterCrash(inner) => serde_json::to_value(inner),
+                CdpEvent::InspectorWorkerScriptLoaded(inner) => serde_json::to_value(inner),
+                CdpEvent::LayerTreeLayerPainted(inner) => serde_json::to_value(inner),
+                CdpEvent::LayerTreeLayerTreeDidChange(inner) => serde_json::to_value(inner),
+                CdpEvent::LogEntryAdded(inner) => serde_json::to_value(inner),
+                CdpEvent::MediaPlayerPropertiesChanged(inner) => serde_json::to_value(inner),
+                CdpEvent::MediaPlayerEventsAdded(inner) => serde_json::to_value(inner),
+                CdpEvent::MediaPlayerMessagesLogged(inner) => serde_json::to_value(inner),
+                CdpEvent::MediaPlayerErrorsRaised(inner) => serde_json::to_value(inner),
+                CdpEvent::MediaPlayerCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDataReceived(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkEventSourceMessageReceived(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkLoadingFailed(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkLoadingFinished(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkRequestServedFromCache(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkRequestWillBeSent(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkResourceChangedPriority(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkSignedExchangeReceived(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkResponseReceived(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkWebSocketClosed(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkWebSocketCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkWebSocketFrameError(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkWebSocketFrameReceived(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkWebSocketFrameSent(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkWebSocketHandshakeResponseReceived(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::NetworkWebSocketWillSendHandshakeRequest(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::NetworkWebTransportCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkWebTransportConnectionEstablished(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::NetworkWebTransportClosed(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectTcpSocketCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectTcpSocketOpened(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectTcpSocketAborted(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectTcpSocketClosed(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectTcpSocketChunkSent(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectTcpSocketChunkReceived(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectUdpSocketJoinedMulticastGroup(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::NetworkDirectUdpSocketLeftMulticastGroup(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::NetworkDirectUdpSocketCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectUdpSocketOpened(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectUdpSocketAborted(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectUdpSocketClosed(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectUdpSocketChunkSent(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDirectUdpSocketChunkReceived(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkRequestWillBeSentExtraInfo(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkResponseReceivedExtraInfo(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkResponseReceivedEarlyHints(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkTrustTokenOperationDone(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkPolicyUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkReportingApiReportAdded(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkReportingApiReportUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkReportingApiEndpointsChangedForOrigin(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::NetworkDeviceBoundSessionsAdded(inner) => serde_json::to_value(inner),
+                CdpEvent::NetworkDeviceBoundSessionEventOccurred(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::OverlayInspectNodeRequested(inner) => serde_json::to_value(inner),
+                CdpEvent::OverlayNodeHighlightRequested(inner) => serde_json::to_value(inner),
+                CdpEvent::OverlayScreenshotRequested(inner) => serde_json::to_value(inner),
+                CdpEvent::OverlayInspectModeCanceled(inner) => serde_json::to_value(inner),
+                CdpEvent::PageDomContentEventFired(inner) => serde_json::to_value(inner),
+                CdpEvent::PageFileChooserOpened(inner) => serde_json::to_value(inner),
+                CdpEvent::PageFrameAttached(inner) => serde_json::to_value(inner),
+                CdpEvent::PageFrameDetached(inner) => serde_json::to_value(inner),
+                CdpEvent::PageFrameSubtreeWillBeDetached(inner) => serde_json::to_value(inner),
+                CdpEvent::PageFrameNavigated(inner) => serde_json::to_value(inner),
+                CdpEvent::PageDocumentOpened(inner) => serde_json::to_value(inner),
+                CdpEvent::PageFrameResized(inner) => serde_json::to_value(inner),
+                CdpEvent::PageFrameStartedNavigating(inner) => serde_json::to_value(inner),
+                CdpEvent::PageFrameRequestedNavigation(inner) => serde_json::to_value(inner),
+                CdpEvent::PageFrameStartedLoading(inner) => serde_json::to_value(inner),
+                CdpEvent::PageFrameStoppedLoading(inner) => serde_json::to_value(inner),
+                CdpEvent::PageInterstitialHidden(inner) => serde_json::to_value(inner),
+                CdpEvent::PageInterstitialShown(inner) => serde_json::to_value(inner),
+                CdpEvent::PageJavascriptDialogClosed(inner) => serde_json::to_value(inner),
+                CdpEvent::PageJavascriptDialogOpening(inner) => serde_json::to_value(inner),
+                CdpEvent::PageLifecycleEvent(inner) => serde_json::to_value(inner),
+                CdpEvent::PageBackForwardCacheNotUsed(inner) => serde_json::to_value(inner),
+                CdpEvent::PageLoadEventFired(inner) => serde_json::to_value(inner),
+                CdpEvent::PageNavigatedWithinDocument(inner) => serde_json::to_value(inner),
+                CdpEvent::PageScreencastFrame(inner) => serde_json::to_value(inner),
+                CdpEvent::PageScreencastVisibilityChanged(inner) => serde_json::to_value(inner),
+                CdpEvent::PageWindowOpen(inner) => serde_json::to_value(inner),
+                CdpEvent::PageCompilationCacheProduced(inner) => serde_json::to_value(inner),
+                CdpEvent::PerformanceMetrics(inner) => serde_json::to_value(inner),
+                CdpEvent::PerformanceTimelineTimelineEventAdded(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::PreloadRuleSetUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::PreloadRuleSetRemoved(inner) => serde_json::to_value(inner),
+                CdpEvent::PreloadPreloadEnabledStateUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::PreloadPrefetchStatusUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::PreloadPrerenderStatusUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::PreloadPreloadingAttemptSourcesUpdated(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::SecurityVisibleSecurityStateChanged(inner) => serde_json::to_value(inner),
+                CdpEvent::ServiceWorkerWorkerErrorReported(inner) => serde_json::to_value(inner),
+                CdpEvent::ServiceWorkerWorkerRegistrationUpdated(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::ServiceWorkerWorkerVersionUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::StorageCacheStorageContentUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::StorageCacheStorageListUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::StorageIndexedDbContentUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::StorageIndexedDbListUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::StorageInterestGroupAccessed(inner) => serde_json::to_value(inner),
+                CdpEvent::StorageInterestGroupAuctionEventOccurred(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::StorageInterestGroupAuctionNetworkRequestCreated(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::StorageSharedStorageAccessed(inner) => serde_json::to_value(inner),
+                CdpEvent::StorageSharedStorageWorkletOperationExecutionFinished(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::StorageStorageBucketCreatedOrUpdated(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::StorageStorageBucketDeleted(inner) => serde_json::to_value(inner),
+                CdpEvent::StorageAttributionReportingSourceRegistered(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::StorageAttributionReportingTriggerRegistered(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::StorageAttributionReportingReportSent(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::StorageAttributionReportingVerboseDebugReportSent(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::TargetAttachedToTarget(inner) => serde_json::to_value(inner),
+                CdpEvent::TargetDetachedFromTarget(inner) => serde_json::to_value(inner),
+                CdpEvent::TargetReceivedMessageFromTarget(inner) => serde_json::to_value(inner),
+                CdpEvent::TargetTargetCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::TargetTargetDestroyed(inner) => serde_json::to_value(inner),
+                CdpEvent::TargetTargetCrashed(inner) => serde_json::to_value(inner),
+                CdpEvent::TargetTargetInfoChanged(inner) => serde_json::to_value(inner),
+                CdpEvent::TetheringAccepted(inner) => serde_json::to_value(inner),
+                CdpEvent::TracingBufferUsage(inner) => serde_json::to_value(inner),
+                CdpEvent::TracingDataCollected(inner) => serde_json::to_value(inner),
+                CdpEvent::TracingTracingComplete(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioContextCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioContextWillBeDestroyed(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioContextChanged(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioAudioListenerCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioAudioListenerWillBeDestroyed(inner) => {
+                    serde_json::to_value(inner)
+                }
+                CdpEvent::WebAudioAudioNodeCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioAudioNodeWillBeDestroyed(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioAudioParamCreated(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioAudioParamWillBeDestroyed(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioNodesConnected(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioNodesDisconnected(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioNodeParamConnected(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAudioNodeParamDisconnected(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAuthnCredentialAdded(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAuthnCredentialDeleted(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAuthnCredentialUpdated(inner) => serde_json::to_value(inner),
+                CdpEvent::WebAuthnCredentialAsserted(inner) => serde_json::to_value(inner),
+                CdpEvent::Other(val) => Ok(val),
+            }
+        }
+        pub fn into_event(self) -> ::std::result::Result<Box<dyn super::Event>, serde_json::Value> {
+            match self {
+                CdpEvent::DebuggerPaused(event) => Ok(Box::new(event)),
+                CdpEvent::DebuggerResumed(event) => Ok(Box::new(event)),
+                CdpEvent::DebuggerScriptFailedToParse(event) => Ok(Box::new(*event)),
+                CdpEvent::DebuggerScriptParsed(event) => Ok(Box::new(*event)),
+                CdpEvent::HeapProfilerAddHeapSnapshotChunk(event) => Ok(Box::new(event)),
+                CdpEvent::HeapProfilerHeapStatsUpdate(event) => Ok(Box::new(event)),
+                CdpEvent::HeapProfilerLastSeenObjectId(event) => Ok(Box::new(event)),
+                CdpEvent::HeapProfilerReportHeapSnapshotProgress(event) => Ok(Box::new(event)),
+                CdpEvent::HeapProfilerResetProfiles(event) => Ok(Box::new(event)),
+                CdpEvent::ProfilerConsoleProfileFinished(event) => Ok(Box::new(event)),
+                CdpEvent::ProfilerConsoleProfileStarted(event) => Ok(Box::new(event)),
+                CdpEvent::ProfilerPreciseCoverageDeltaUpdate(event) => Ok(Box::new(event)),
+                CdpEvent::RuntimeBindingCalled(event) => Ok(Box::new(event)),
+                CdpEvent::RuntimeConsoleApiCalled(event) => Ok(Box::new(event)),
+                CdpEvent::RuntimeExceptionRevoked(event) => Ok(Box::new(event)),
+                CdpEvent::RuntimeExceptionThrown(event) => Ok(Box::new(*event)),
+                CdpEvent::RuntimeExecutionContextCreated(event) => Ok(Box::new(event)),
+                CdpEvent::RuntimeExecutionContextDestroyed(event) => Ok(Box::new(event)),
+                CdpEvent::RuntimeExecutionContextsCleared(event) => Ok(Box::new(event)),
+                CdpEvent::RuntimeInspectRequested(event) => Ok(Box::new(*event)),
+                CdpEvent::AccessibilityLoadComplete(event) => Ok(Box::new(*event)),
+                CdpEvent::AccessibilityNodesUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::AnimationAnimationCanceled(event) => Ok(Box::new(event)),
+                CdpEvent::AnimationAnimationCreated(event) => Ok(Box::new(event)),
+                CdpEvent::AnimationAnimationStarted(event) => Ok(Box::new(*event)),
+                CdpEvent::AnimationAnimationUpdated(event) => Ok(Box::new(*event)),
+                CdpEvent::AuditsIssueAdded(event) => Ok(Box::new(*event)),
+                CdpEvent::AutofillAddressFormFilled(event) => Ok(Box::new(event)),
+                CdpEvent::BackgroundServiceRecordingStateChanged(event) => Ok(Box::new(event)),
+                CdpEvent::BackgroundServiceBackgroundServiceEventReceived(event) => {
+                    Ok(Box::new(event))
+                }
+                CdpEvent::BluetoothEmulationGattOperationReceived(event) => Ok(Box::new(event)),
+                CdpEvent::BluetoothEmulationCharacteristicOperationReceived(event) => {
+                    Ok(Box::new(event))
+                }
+                CdpEvent::BluetoothEmulationDescriptorOperationReceived(event) => {
+                    Ok(Box::new(event))
+                }
+                CdpEvent::BrowserDownloadWillBegin(event) => Ok(Box::new(event)),
+                CdpEvent::BrowserDownloadProgress(event) => Ok(Box::new(event)),
+                CdpEvent::CssFontsUpdated(event) => Ok(Box::new(*event)),
+                CdpEvent::CssMediaQueryResultChanged(event) => Ok(Box::new(event)),
+                CdpEvent::CssStyleSheetAdded(event) => Ok(Box::new(event)),
+                CdpEvent::CssStyleSheetChanged(event) => Ok(Box::new(event)),
+                CdpEvent::CssStyleSheetRemoved(event) => Ok(Box::new(event)),
+                CdpEvent::CssComputedStyleUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::CastSinksUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::CastIssueUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::DomAttributeModified(event) => Ok(Box::new(event)),
+                CdpEvent::DomAdoptedStyleSheetsModified(event) => Ok(Box::new(event)),
+                CdpEvent::DomAttributeRemoved(event) => Ok(Box::new(event)),
+                CdpEvent::DomCharacterDataModified(event) => Ok(Box::new(event)),
+                CdpEvent::DomChildNodeCountUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::DomChildNodeInserted(event) => Ok(Box::new(*event)),
+                CdpEvent::DomChildNodeRemoved(event) => Ok(Box::new(event)),
+                CdpEvent::DomDistributedNodesUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::DomDocumentUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::DomInlineStyleInvalidated(event) => Ok(Box::new(event)),
+                CdpEvent::DomPseudoElementAdded(event) => Ok(Box::new(*event)),
+                CdpEvent::DomTopLayerElementsUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::DomScrollableFlagUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::DomAffectedByStartingStylesFlagUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::DomPseudoElementRemoved(event) => Ok(Box::new(event)),
+                CdpEvent::DomSetChildNodes(event) => Ok(Box::new(event)),
+                CdpEvent::DomShadowRootPopped(event) => Ok(Box::new(event)),
+                CdpEvent::DomShadowRootPushed(event) => Ok(Box::new(*event)),
+                CdpEvent::DomStorageDomStorageItemAdded(event) => Ok(Box::new(event)),
+                CdpEvent::DomStorageDomStorageItemRemoved(event) => Ok(Box::new(event)),
+                CdpEvent::DomStorageDomStorageItemUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::DomStorageDomStorageItemsCleared(event) => Ok(Box::new(event)),
+                CdpEvent::DeviceAccessDeviceRequestPrompted(event) => Ok(Box::new(event)),
+                CdpEvent::EmulationVirtualTimeBudgetExpired(event) => Ok(Box::new(event)),
+                CdpEvent::FedCmDialogShown(event) => Ok(Box::new(event)),
+                CdpEvent::FedCmDialogClosed(event) => Ok(Box::new(event)),
+                CdpEvent::FetchRequestPaused(event) => Ok(Box::new(*event)),
+                CdpEvent::FetchAuthRequired(event) => Ok(Box::new(*event)),
+                CdpEvent::InputDragIntercepted(event) => Ok(Box::new(event)),
+                CdpEvent::InspectorDetached(event) => Ok(Box::new(event)),
+                CdpEvent::InspectorTargetCrashed(event) => Ok(Box::new(event)),
+                CdpEvent::InspectorTargetReloadedAfterCrash(event) => Ok(Box::new(event)),
+                CdpEvent::InspectorWorkerScriptLoaded(event) => Ok(Box::new(event)),
+                CdpEvent::LayerTreeLayerPainted(event) => Ok(Box::new(event)),
+                CdpEvent::LayerTreeLayerTreeDidChange(event) => Ok(Box::new(event)),
+                CdpEvent::LogEntryAdded(event) => Ok(Box::new(*event)),
+                CdpEvent::MediaPlayerPropertiesChanged(event) => Ok(Box::new(event)),
+                CdpEvent::MediaPlayerEventsAdded(event) => Ok(Box::new(event)),
+                CdpEvent::MediaPlayerMessagesLogged(event) => Ok(Box::new(event)),
+                CdpEvent::MediaPlayerErrorsRaised(event) => Ok(Box::new(event)),
+                CdpEvent::MediaPlayerCreated(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDataReceived(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkEventSourceMessageReceived(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkLoadingFailed(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkLoadingFinished(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkRequestServedFromCache(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkRequestWillBeSent(event) => Ok(Box::new(*event)),
+                CdpEvent::NetworkResourceChangedPriority(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkSignedExchangeReceived(event) => Ok(Box::new(*event)),
+                CdpEvent::NetworkResponseReceived(event) => Ok(Box::new(*event)),
+                CdpEvent::NetworkWebSocketClosed(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkWebSocketCreated(event) => Ok(Box::new(*event)),
+                CdpEvent::NetworkWebSocketFrameError(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkWebSocketFrameReceived(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkWebSocketFrameSent(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkWebSocketHandshakeResponseReceived(event) => Ok(Box::new(*event)),
+                CdpEvent::NetworkWebSocketWillSendHandshakeRequest(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkWebTransportCreated(event) => Ok(Box::new(*event)),
+                CdpEvent::NetworkWebTransportConnectionEstablished(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkWebTransportClosed(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectTcpSocketCreated(event) => Ok(Box::new(*event)),
+                CdpEvent::NetworkDirectTcpSocketOpened(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectTcpSocketAborted(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectTcpSocketClosed(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectTcpSocketChunkSent(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectTcpSocketChunkReceived(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectUdpSocketJoinedMulticastGroup(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectUdpSocketLeftMulticastGroup(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectUdpSocketCreated(event) => Ok(Box::new(*event)),
+                CdpEvent::NetworkDirectUdpSocketOpened(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectUdpSocketAborted(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectUdpSocketClosed(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectUdpSocketChunkSent(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDirectUdpSocketChunkReceived(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkRequestWillBeSentExtraInfo(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkResponseReceivedExtraInfo(event) => Ok(Box::new(*event)),
+                CdpEvent::NetworkResponseReceivedEarlyHints(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkTrustTokenOperationDone(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkPolicyUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkReportingApiReportAdded(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkReportingApiReportUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkReportingApiEndpointsChangedForOrigin(event) => {
+                    Ok(Box::new(event))
+                }
+                CdpEvent::NetworkDeviceBoundSessionsAdded(event) => Ok(Box::new(event)),
+                CdpEvent::NetworkDeviceBoundSessionEventOccurred(event) => Ok(Box::new(*event)),
+                CdpEvent::OverlayInspectNodeRequested(event) => Ok(Box::new(event)),
+                CdpEvent::OverlayNodeHighlightRequested(event) => Ok(Box::new(event)),
+                CdpEvent::OverlayScreenshotRequested(event) => Ok(Box::new(event)),
+                CdpEvent::OverlayInspectModeCanceled(event) => Ok(Box::new(event)),
+                CdpEvent::PageDomContentEventFired(event) => Ok(Box::new(event)),
+                CdpEvent::PageFileChooserOpened(event) => Ok(Box::new(event)),
+                CdpEvent::PageFrameAttached(event) => Ok(Box::new(event)),
+                CdpEvent::PageFrameDetached(event) => Ok(Box::new(event)),
+                CdpEvent::PageFrameSubtreeWillBeDetached(event) => Ok(Box::new(event)),
+                CdpEvent::PageFrameNavigated(event) => Ok(Box::new(*event)),
+                CdpEvent::PageDocumentOpened(event) => Ok(Box::new(*event)),
+                CdpEvent::PageFrameResized(event) => Ok(Box::new(event)),
+                CdpEvent::PageFrameStartedNavigating(event) => Ok(Box::new(event)),
+                CdpEvent::PageFrameRequestedNavigation(event) => Ok(Box::new(event)),
+                CdpEvent::PageFrameStartedLoading(event) => Ok(Box::new(event)),
+                CdpEvent::PageFrameStoppedLoading(event) => Ok(Box::new(event)),
+                CdpEvent::PageInterstitialHidden(event) => Ok(Box::new(event)),
+                CdpEvent::PageInterstitialShown(event) => Ok(Box::new(event)),
+                CdpEvent::PageJavascriptDialogClosed(event) => Ok(Box::new(event)),
+                CdpEvent::PageJavascriptDialogOpening(event) => Ok(Box::new(event)),
+                CdpEvent::PageLifecycleEvent(event) => Ok(Box::new(event)),
+                CdpEvent::PageBackForwardCacheNotUsed(event) => Ok(Box::new(event)),
+                CdpEvent::PageLoadEventFired(event) => Ok(Box::new(event)),
+                CdpEvent::PageNavigatedWithinDocument(event) => Ok(Box::new(event)),
+                CdpEvent::PageScreencastFrame(event) => Ok(Box::new(event)),
+                CdpEvent::PageScreencastVisibilityChanged(event) => Ok(Box::new(event)),
+                CdpEvent::PageWindowOpen(event) => Ok(Box::new(event)),
+                CdpEvent::PageCompilationCacheProduced(event) => Ok(Box::new(event)),
+                CdpEvent::PerformanceMetrics(event) => Ok(Box::new(event)),
+                CdpEvent::PerformanceTimelineTimelineEventAdded(event) => Ok(Box::new(*event)),
+                CdpEvent::PreloadRuleSetUpdated(event) => Ok(Box::new(*event)),
+                CdpEvent::PreloadRuleSetRemoved(event) => Ok(Box::new(event)),
+                CdpEvent::PreloadPreloadEnabledStateUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::PreloadPrefetchStatusUpdated(event) => Ok(Box::new(*event)),
+                CdpEvent::PreloadPrerenderStatusUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::PreloadPreloadingAttemptSourcesUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::SecurityVisibleSecurityStateChanged(event) => Ok(Box::new(*event)),
+                CdpEvent::ServiceWorkerWorkerErrorReported(event) => Ok(Box::new(event)),
+                CdpEvent::ServiceWorkerWorkerRegistrationUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::ServiceWorkerWorkerVersionUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::StorageCacheStorageContentUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::StorageCacheStorageListUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::StorageIndexedDbContentUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::StorageIndexedDbListUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::StorageInterestGroupAccessed(event) => Ok(Box::new(event)),
+                CdpEvent::StorageInterestGroupAuctionEventOccurred(event) => Ok(Box::new(event)),
+                CdpEvent::StorageInterestGroupAuctionNetworkRequestCreated(event) => {
+                    Ok(Box::new(event))
+                }
+                CdpEvent::StorageSharedStorageAccessed(event) => Ok(Box::new(*event)),
+                CdpEvent::StorageSharedStorageWorkletOperationExecutionFinished(event) => {
+                    Ok(Box::new(event))
+                }
+                CdpEvent::StorageStorageBucketCreatedOrUpdated(event) => Ok(Box::new(event)),
+                CdpEvent::StorageStorageBucketDeleted(event) => Ok(Box::new(event)),
+                CdpEvent::StorageAttributionReportingSourceRegistered(event) => {
+                    Ok(Box::new(*event))
+                }
+                CdpEvent::StorageAttributionReportingTriggerRegistered(event) => {
+                    Ok(Box::new(*event))
+                }
+                CdpEvent::StorageAttributionReportingReportSent(event) => Ok(Box::new(event)),
+                CdpEvent::StorageAttributionReportingVerboseDebugReportSent(event) => {
+                    Ok(Box::new(event))
+                }
+                CdpEvent::TargetAttachedToTarget(event) => Ok(Box::new(*event)),
+                CdpEvent::TargetDetachedFromTarget(event) => Ok(Box::new(event)),
+                CdpEvent::TargetReceivedMessageFromTarget(event) => Ok(Box::new(event)),
+                CdpEvent::TargetTargetCreated(event) => Ok(Box::new(*event)),
+                CdpEvent::TargetTargetDestroyed(event) => Ok(Box::new(event)),
+                CdpEvent::TargetTargetCrashed(event) => Ok(Box::new(event)),
+                CdpEvent::TargetTargetInfoChanged(event) => Ok(Box::new(*event)),
+                CdpEvent::TetheringAccepted(event) => Ok(Box::new(event)),
+                CdpEvent::TracingBufferUsage(event) => Ok(Box::new(event)),
+                CdpEvent::TracingDataCollected(event) => Ok(Box::new(event)),
+                CdpEvent::TracingTracingComplete(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioContextCreated(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioContextWillBeDestroyed(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioContextChanged(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioAudioListenerCreated(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioAudioListenerWillBeDestroyed(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioAudioNodeCreated(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioAudioNodeWillBeDestroyed(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioAudioParamCreated(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioAudioParamWillBeDestroyed(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioNodesConnected(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioNodesDisconnected(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioNodeParamConnected(event) => Ok(Box::new(event)),
+                CdpEvent::WebAudioNodeParamDisconnected(event) => Ok(Box::new(event)),
+                CdpEvent::WebAuthnCredentialAdded(event) => Ok(Box::new(*event)),
+                CdpEvent::WebAuthnCredentialDeleted(event) => Ok(Box::new(event)),
+                CdpEvent::WebAuthnCredentialUpdated(event) => Ok(Box::new(*event)),
+                CdpEvent::WebAuthnCredentialAsserted(event) => Ok(Box::new(*event)),
+                CdpEvent::Other(other) => Err(other),
+            }
+        }
+    }
+    use serde::de::{self, Deserializer, MapAccess, Visitor};
+    use std::fmt;
+    impl<'de> Deserialize<'de> for CdpEventMessage {
+        fn deserialize<D>(deserializer: D) -> Result<Self, <D as Deserializer<'de>>::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            enum Field {
+                Method,
+                Session,
+                Params,
+            }
+            impl<'de> Deserialize<'de> for Field {
+                fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
+                where
+                    D: Deserializer<'de>,
+                {
+                    struct FieldVisitor;
+                    impl<'de> Visitor<'de> for FieldVisitor {
+                        type Value = Field;
+                        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                            formatter.write_str("`method` or `sessionId` or `params`")
+                        }
+                        fn visit_str<E>(self, value: &str) -> Result<Field, E>
+                        where
+                            E: de::Error,
+                        {
+                            match value {
+                                "method" => Ok(Field::Method),
+                                "sessionId" => Ok(Field::Session),
+                                "params" => Ok(Field::Params),
+                                _ => Err(de::Error::unknown_field(value, FIELDS)),
+                            }
+                        }
+                    }
+                    deserializer.deserialize_identifier(FieldVisitor)
+                }
+            }
+            struct MessageVisitor;
+            impl<'de> Visitor<'de> for MessageVisitor {
+                type Value = CdpEventMessage;
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("struct CdpEventMessage")
+                }
+                fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+                where
+                    A: MapAccess<'de>,
+                {
+                    let mut method = None;
+                    let mut session_id = None;
+                    let mut params = None;
+                    while let Some(key) = map.next_key()? {
+                        match key {
+                            Field::Method => {
+                                if method.is_some() {
+                                    return Err(de::Error::duplicate_field("method"));
+                                }
+                                method = Some(map.next_value::<String>()?);
+                            }
+                            Field::Session => {
+                                if session_id.is_some() {
+                                    return Err(de::Error::duplicate_field("sessionId"));
+                                }
+                                session_id = Some(map.next_value::<String>()?);
+                            }
+                            Field::Params => {
+                                if params.is_some() {
+                                    return Err(de::Error::duplicate_field("params"));
+                                }
+                                params = Some (match method . as_ref () . ok_or_else (|| de :: Error :: missing_field ("params")) ? . as_str () { super :: js_protocol :: debugger :: EventPaused :: IDENTIFIER => CdpEvent :: DebuggerPaused (map . next_value :: < super :: js_protocol :: debugger :: EventPaused > () ?) , super :: js_protocol :: debugger :: EventResumed :: IDENTIFIER => CdpEvent :: DebuggerResumed (map . next_value :: < super :: js_protocol :: debugger :: EventResumed > () ?) , super :: js_protocol :: debugger :: EventScriptFailedToParse :: IDENTIFIER => CdpEvent :: DebuggerScriptFailedToParse (Box :: new (map . next_value :: < super :: js_protocol :: debugger :: EventScriptFailedToParse > () ?)) , super :: js_protocol :: debugger :: EventScriptParsed :: IDENTIFIER => CdpEvent :: DebuggerScriptParsed (Box :: new (map . next_value :: < super :: js_protocol :: debugger :: EventScriptParsed > () ?)) , super :: js_protocol :: heap_profiler :: EventAddHeapSnapshotChunk :: IDENTIFIER => CdpEvent :: HeapProfilerAddHeapSnapshotChunk (map . next_value :: < super :: js_protocol :: heap_profiler :: EventAddHeapSnapshotChunk > () ?) , super :: js_protocol :: heap_profiler :: EventHeapStatsUpdate :: IDENTIFIER => CdpEvent :: HeapProfilerHeapStatsUpdate (map . next_value :: < super :: js_protocol :: heap_profiler :: EventHeapStatsUpdate > () ?) , super :: js_protocol :: heap_profiler :: EventLastSeenObjectId :: IDENTIFIER => CdpEvent :: HeapProfilerLastSeenObjectId (map . next_value :: < super :: js_protocol :: heap_profiler :: EventLastSeenObjectId > () ?) , super :: js_protocol :: heap_profiler :: EventReportHeapSnapshotProgress :: IDENTIFIER => CdpEvent :: HeapProfilerReportHeapSnapshotProgress (map . next_value :: < super :: js_protocol :: heap_profiler :: EventReportHeapSnapshotProgress > () ?) , super :: js_protocol :: heap_profiler :: EventResetProfiles :: IDENTIFIER => CdpEvent :: HeapProfilerResetProfiles (map . next_value :: < super :: js_protocol :: heap_profiler :: EventResetProfiles > () ?) , super :: js_protocol :: profiler :: EventConsoleProfileFinished :: IDENTIFIER => CdpEvent :: ProfilerConsoleProfileFinished (map . next_value :: < super :: js_protocol :: profiler :: EventConsoleProfileFinished > () ?) , super :: js_protocol :: profiler :: EventConsoleProfileStarted :: IDENTIFIER => CdpEvent :: ProfilerConsoleProfileStarted (map . next_value :: < super :: js_protocol :: profiler :: EventConsoleProfileStarted > () ?) , super :: js_protocol :: profiler :: EventPreciseCoverageDeltaUpdate :: IDENTIFIER => CdpEvent :: ProfilerPreciseCoverageDeltaUpdate (map . next_value :: < super :: js_protocol :: profiler :: EventPreciseCoverageDeltaUpdate > () ?) , super :: js_protocol :: runtime :: EventBindingCalled :: IDENTIFIER => CdpEvent :: RuntimeBindingCalled (map . next_value :: < super :: js_protocol :: runtime :: EventBindingCalled > () ?) , super :: js_protocol :: runtime :: EventConsoleApiCalled :: IDENTIFIER => CdpEvent :: RuntimeConsoleApiCalled (map . next_value :: < super :: js_protocol :: runtime :: EventConsoleApiCalled > () ?) , super :: js_protocol :: runtime :: EventExceptionRevoked :: IDENTIFIER => CdpEvent :: RuntimeExceptionRevoked (map . next_value :: < super :: js_protocol :: runtime :: EventExceptionRevoked > () ?) , super :: js_protocol :: runtime :: EventExceptionThrown :: IDENTIFIER => CdpEvent :: RuntimeExceptionThrown (Box :: new (map . next_value :: < super :: js_protocol :: runtime :: EventExceptionThrown > () ?)) , super :: js_protocol :: runtime :: EventExecutionContextCreated :: IDENTIFIER => CdpEvent :: RuntimeExecutionContextCreated (map . next_value :: < super :: js_protocol :: runtime :: EventExecutionContextCreated > () ?) , super :: js_protocol :: runtime :: EventExecutionContextDestroyed :: IDENTIFIER => CdpEvent :: RuntimeExecutionContextDestroyed (map . next_value :: < super :: js_protocol :: runtime :: EventExecutionContextDestroyed > () ?) , super :: js_protocol :: runtime :: EventExecutionContextsCleared :: IDENTIFIER => CdpEvent :: RuntimeExecutionContextsCleared (map . next_value :: < super :: js_protocol :: runtime :: EventExecutionContextsCleared > () ?) , super :: js_protocol :: runtime :: EventInspectRequested :: IDENTIFIER => CdpEvent :: RuntimeInspectRequested (Box :: new (map . next_value :: < super :: js_protocol :: runtime :: EventInspectRequested > () ?)) , super :: browser_protocol :: accessibility :: EventLoadComplete :: IDENTIFIER => CdpEvent :: AccessibilityLoadComplete (Box :: new (map . next_value :: < super :: browser_protocol :: accessibility :: EventLoadComplete > () ?)) , super :: browser_protocol :: accessibility :: EventNodesUpdated :: IDENTIFIER => CdpEvent :: AccessibilityNodesUpdated (map . next_value :: < super :: browser_protocol :: accessibility :: EventNodesUpdated > () ?) , super :: browser_protocol :: animation :: EventAnimationCanceled :: IDENTIFIER => CdpEvent :: AnimationAnimationCanceled (map . next_value :: < super :: browser_protocol :: animation :: EventAnimationCanceled > () ?) , super :: browser_protocol :: animation :: EventAnimationCreated :: IDENTIFIER => CdpEvent :: AnimationAnimationCreated (map . next_value :: < super :: browser_protocol :: animation :: EventAnimationCreated > () ?) , super :: browser_protocol :: animation :: EventAnimationStarted :: IDENTIFIER => CdpEvent :: AnimationAnimationStarted (Box :: new (map . next_value :: < super :: browser_protocol :: animation :: EventAnimationStarted > () ?)) , super :: browser_protocol :: animation :: EventAnimationUpdated :: IDENTIFIER => CdpEvent :: AnimationAnimationUpdated (Box :: new (map . next_value :: < super :: browser_protocol :: animation :: EventAnimationUpdated > () ?)) , super :: browser_protocol :: audits :: EventIssueAdded :: IDENTIFIER => CdpEvent :: AuditsIssueAdded (Box :: new (map . next_value :: < super :: browser_protocol :: audits :: EventIssueAdded > () ?)) , super :: browser_protocol :: autofill :: EventAddressFormFilled :: IDENTIFIER => CdpEvent :: AutofillAddressFormFilled (map . next_value :: < super :: browser_protocol :: autofill :: EventAddressFormFilled > () ?) , super :: browser_protocol :: background_service :: EventRecordingStateChanged :: IDENTIFIER => CdpEvent :: BackgroundServiceRecordingStateChanged (map . next_value :: < super :: browser_protocol :: background_service :: EventRecordingStateChanged > () ?) , super :: browser_protocol :: background_service :: EventBackgroundServiceEventReceived :: IDENTIFIER => CdpEvent :: BackgroundServiceBackgroundServiceEventReceived (map . next_value :: < super :: browser_protocol :: background_service :: EventBackgroundServiceEventReceived > () ?) , super :: browser_protocol :: bluetooth_emulation :: EventGattOperationReceived :: IDENTIFIER => CdpEvent :: BluetoothEmulationGattOperationReceived (map . next_value :: < super :: browser_protocol :: bluetooth_emulation :: EventGattOperationReceived > () ?) , super :: browser_protocol :: bluetooth_emulation :: EventCharacteristicOperationReceived :: IDENTIFIER => CdpEvent :: BluetoothEmulationCharacteristicOperationReceived (map . next_value :: < super :: browser_protocol :: bluetooth_emulation :: EventCharacteristicOperationReceived > () ?) , super :: browser_protocol :: bluetooth_emulation :: EventDescriptorOperationReceived :: IDENTIFIER => CdpEvent :: BluetoothEmulationDescriptorOperationReceived (map . next_value :: < super :: browser_protocol :: bluetooth_emulation :: EventDescriptorOperationReceived > () ?) , super :: browser_protocol :: browser :: EventDownloadWillBegin :: IDENTIFIER => CdpEvent :: BrowserDownloadWillBegin (map . next_value :: < super :: browser_protocol :: browser :: EventDownloadWillBegin > () ?) , super :: browser_protocol :: browser :: EventDownloadProgress :: IDENTIFIER => CdpEvent :: BrowserDownloadProgress (map . next_value :: < super :: browser_protocol :: browser :: EventDownloadProgress > () ?) , super :: browser_protocol :: css :: EventFontsUpdated :: IDENTIFIER => CdpEvent :: CssFontsUpdated (Box :: new (map . next_value :: < super :: browser_protocol :: css :: EventFontsUpdated > () ?)) , super :: browser_protocol :: css :: EventMediaQueryResultChanged :: IDENTIFIER => CdpEvent :: CssMediaQueryResultChanged (map . next_value :: < super :: browser_protocol :: css :: EventMediaQueryResultChanged > () ?) , super :: browser_protocol :: css :: EventStyleSheetAdded :: IDENTIFIER => CdpEvent :: CssStyleSheetAdded (map . next_value :: < super :: browser_protocol :: css :: EventStyleSheetAdded > () ?) , super :: browser_protocol :: css :: EventStyleSheetChanged :: IDENTIFIER => CdpEvent :: CssStyleSheetChanged (map . next_value :: < super :: browser_protocol :: css :: EventStyleSheetChanged > () ?) , super :: browser_protocol :: css :: EventStyleSheetRemoved :: IDENTIFIER => CdpEvent :: CssStyleSheetRemoved (map . next_value :: < super :: browser_protocol :: css :: EventStyleSheetRemoved > () ?) , super :: browser_protocol :: css :: EventComputedStyleUpdated :: IDENTIFIER => CdpEvent :: CssComputedStyleUpdated (map . next_value :: < super :: browser_protocol :: css :: EventComputedStyleUpdated > () ?) , super :: browser_protocol :: cast :: EventSinksUpdated :: IDENTIFIER => CdpEvent :: CastSinksUpdated (map . next_value :: < super :: browser_protocol :: cast :: EventSinksUpdated > () ?) , super :: browser_protocol :: cast :: EventIssueUpdated :: IDENTIFIER => CdpEvent :: CastIssueUpdated (map . next_value :: < super :: browser_protocol :: cast :: EventIssueUpdated > () ?) , super :: browser_protocol :: dom :: EventAttributeModified :: IDENTIFIER => CdpEvent :: DomAttributeModified (map . next_value :: < super :: browser_protocol :: dom :: EventAttributeModified > () ?) , super :: browser_protocol :: dom :: EventAdoptedStyleSheetsModified :: IDENTIFIER => CdpEvent :: DomAdoptedStyleSheetsModified (map . next_value :: < super :: browser_protocol :: dom :: EventAdoptedStyleSheetsModified > () ?) , super :: browser_protocol :: dom :: EventAttributeRemoved :: IDENTIFIER => CdpEvent :: DomAttributeRemoved (map . next_value :: < super :: browser_protocol :: dom :: EventAttributeRemoved > () ?) , super :: browser_protocol :: dom :: EventCharacterDataModified :: IDENTIFIER => CdpEvent :: DomCharacterDataModified (map . next_value :: < super :: browser_protocol :: dom :: EventCharacterDataModified > () ?) , super :: browser_protocol :: dom :: EventChildNodeCountUpdated :: IDENTIFIER => CdpEvent :: DomChildNodeCountUpdated (map . next_value :: < super :: browser_protocol :: dom :: EventChildNodeCountUpdated > () ?) , super :: browser_protocol :: dom :: EventChildNodeInserted :: IDENTIFIER => CdpEvent :: DomChildNodeInserted (Box :: new (map . next_value :: < super :: browser_protocol :: dom :: EventChildNodeInserted > () ?)) , super :: browser_protocol :: dom :: EventChildNodeRemoved :: IDENTIFIER => CdpEvent :: DomChildNodeRemoved (map . next_value :: < super :: browser_protocol :: dom :: EventChildNodeRemoved > () ?) , super :: browser_protocol :: dom :: EventDistributedNodesUpdated :: IDENTIFIER => CdpEvent :: DomDistributedNodesUpdated (map . next_value :: < super :: browser_protocol :: dom :: EventDistributedNodesUpdated > () ?) , super :: browser_protocol :: dom :: EventDocumentUpdated :: IDENTIFIER => CdpEvent :: DomDocumentUpdated (map . next_value :: < super :: browser_protocol :: dom :: EventDocumentUpdated > () ?) , super :: browser_protocol :: dom :: EventInlineStyleInvalidated :: IDENTIFIER => CdpEvent :: DomInlineStyleInvalidated (map . next_value :: < super :: browser_protocol :: dom :: EventInlineStyleInvalidated > () ?) , super :: browser_protocol :: dom :: EventPseudoElementAdded :: IDENTIFIER => CdpEvent :: DomPseudoElementAdded (Box :: new (map . next_value :: < super :: browser_protocol :: dom :: EventPseudoElementAdded > () ?)) , super :: browser_protocol :: dom :: EventTopLayerElementsUpdated :: IDENTIFIER => CdpEvent :: DomTopLayerElementsUpdated (map . next_value :: < super :: browser_protocol :: dom :: EventTopLayerElementsUpdated > () ?) , super :: browser_protocol :: dom :: EventScrollableFlagUpdated :: IDENTIFIER => CdpEvent :: DomScrollableFlagUpdated (map . next_value :: < super :: browser_protocol :: dom :: EventScrollableFlagUpdated > () ?) , super :: browser_protocol :: dom :: EventAffectedByStartingStylesFlagUpdated :: IDENTIFIER => CdpEvent :: DomAffectedByStartingStylesFlagUpdated (map . next_value :: < super :: browser_protocol :: dom :: EventAffectedByStartingStylesFlagUpdated > () ?) , super :: browser_protocol :: dom :: EventPseudoElementRemoved :: IDENTIFIER => CdpEvent :: DomPseudoElementRemoved (map . next_value :: < super :: browser_protocol :: dom :: EventPseudoElementRemoved > () ?) , super :: browser_protocol :: dom :: EventSetChildNodes :: IDENTIFIER => CdpEvent :: DomSetChildNodes (map . next_value :: < super :: browser_protocol :: dom :: EventSetChildNodes > () ?) , super :: browser_protocol :: dom :: EventShadowRootPopped :: IDENTIFIER => CdpEvent :: DomShadowRootPopped (map . next_value :: < super :: browser_protocol :: dom :: EventShadowRootPopped > () ?) , super :: browser_protocol :: dom :: EventShadowRootPushed :: IDENTIFIER => CdpEvent :: DomShadowRootPushed (Box :: new (map . next_value :: < super :: browser_protocol :: dom :: EventShadowRootPushed > () ?)) , super :: browser_protocol :: dom_storage :: EventDomStorageItemAdded :: IDENTIFIER => CdpEvent :: DomStorageDomStorageItemAdded (map . next_value :: < super :: browser_protocol :: dom_storage :: EventDomStorageItemAdded > () ?) , super :: browser_protocol :: dom_storage :: EventDomStorageItemRemoved :: IDENTIFIER => CdpEvent :: DomStorageDomStorageItemRemoved (map . next_value :: < super :: browser_protocol :: dom_storage :: EventDomStorageItemRemoved > () ?) , super :: browser_protocol :: dom_storage :: EventDomStorageItemUpdated :: IDENTIFIER => CdpEvent :: DomStorageDomStorageItemUpdated (map . next_value :: < super :: browser_protocol :: dom_storage :: EventDomStorageItemUpdated > () ?) , super :: browser_protocol :: dom_storage :: EventDomStorageItemsCleared :: IDENTIFIER => CdpEvent :: DomStorageDomStorageItemsCleared (map . next_value :: < super :: browser_protocol :: dom_storage :: EventDomStorageItemsCleared > () ?) , super :: browser_protocol :: device_access :: EventDeviceRequestPrompted :: IDENTIFIER => CdpEvent :: DeviceAccessDeviceRequestPrompted (map . next_value :: < super :: browser_protocol :: device_access :: EventDeviceRequestPrompted > () ?) , super :: browser_protocol :: emulation :: EventVirtualTimeBudgetExpired :: IDENTIFIER => CdpEvent :: EmulationVirtualTimeBudgetExpired (map . next_value :: < super :: browser_protocol :: emulation :: EventVirtualTimeBudgetExpired > () ?) , super :: browser_protocol :: fed_cm :: EventDialogShown :: IDENTIFIER => CdpEvent :: FedCmDialogShown (map . next_value :: < super :: browser_protocol :: fed_cm :: EventDialogShown > () ?) , super :: browser_protocol :: fed_cm :: EventDialogClosed :: IDENTIFIER => CdpEvent :: FedCmDialogClosed (map . next_value :: < super :: browser_protocol :: fed_cm :: EventDialogClosed > () ?) , super :: browser_protocol :: fetch :: EventRequestPaused :: IDENTIFIER => CdpEvent :: FetchRequestPaused (Box :: new (map . next_value :: < super :: browser_protocol :: fetch :: EventRequestPaused > () ?)) , super :: browser_protocol :: fetch :: EventAuthRequired :: IDENTIFIER => CdpEvent :: FetchAuthRequired (Box :: new (map . next_value :: < super :: browser_protocol :: fetch :: EventAuthRequired > () ?)) , super :: browser_protocol :: input :: EventDragIntercepted :: IDENTIFIER => CdpEvent :: InputDragIntercepted (map . next_value :: < super :: browser_protocol :: input :: EventDragIntercepted > () ?) , super :: browser_protocol :: inspector :: EventDetached :: IDENTIFIER => CdpEvent :: InspectorDetached (map . next_value :: < super :: browser_protocol :: inspector :: EventDetached > () ?) , super :: browser_protocol :: inspector :: EventTargetCrashed :: IDENTIFIER => CdpEvent :: InspectorTargetCrashed (map . next_value :: < super :: browser_protocol :: inspector :: EventTargetCrashed > () ?) , super :: browser_protocol :: inspector :: EventTargetReloadedAfterCrash :: IDENTIFIER => CdpEvent :: InspectorTargetReloadedAfterCrash (map . next_value :: < super :: browser_protocol :: inspector :: EventTargetReloadedAfterCrash > () ?) , super :: browser_protocol :: inspector :: EventWorkerScriptLoaded :: IDENTIFIER => CdpEvent :: InspectorWorkerScriptLoaded (map . next_value :: < super :: browser_protocol :: inspector :: EventWorkerScriptLoaded > () ?) , super :: browser_protocol :: layer_tree :: EventLayerPainted :: IDENTIFIER => CdpEvent :: LayerTreeLayerPainted (map . next_value :: < super :: browser_protocol :: layer_tree :: EventLayerPainted > () ?) , super :: browser_protocol :: layer_tree :: EventLayerTreeDidChange :: IDENTIFIER => CdpEvent :: LayerTreeLayerTreeDidChange (map . next_value :: < super :: browser_protocol :: layer_tree :: EventLayerTreeDidChange > () ?) , super :: browser_protocol :: log :: EventEntryAdded :: IDENTIFIER => CdpEvent :: LogEntryAdded (Box :: new (map . next_value :: < super :: browser_protocol :: log :: EventEntryAdded > () ?)) , super :: browser_protocol :: media :: EventPlayerPropertiesChanged :: IDENTIFIER => CdpEvent :: MediaPlayerPropertiesChanged (map . next_value :: < super :: browser_protocol :: media :: EventPlayerPropertiesChanged > () ?) , super :: browser_protocol :: media :: EventPlayerEventsAdded :: IDENTIFIER => CdpEvent :: MediaPlayerEventsAdded (map . next_value :: < super :: browser_protocol :: media :: EventPlayerEventsAdded > () ?) , super :: browser_protocol :: media :: EventPlayerMessagesLogged :: IDENTIFIER => CdpEvent :: MediaPlayerMessagesLogged (map . next_value :: < super :: browser_protocol :: media :: EventPlayerMessagesLogged > () ?) , super :: browser_protocol :: media :: EventPlayerErrorsRaised :: IDENTIFIER => CdpEvent :: MediaPlayerErrorsRaised (map . next_value :: < super :: browser_protocol :: media :: EventPlayerErrorsRaised > () ?) , super :: browser_protocol :: media :: EventPlayerCreated :: IDENTIFIER => CdpEvent :: MediaPlayerCreated (map . next_value :: < super :: browser_protocol :: media :: EventPlayerCreated > () ?) , super :: browser_protocol :: network :: EventDataReceived :: IDENTIFIER => CdpEvent :: NetworkDataReceived (map . next_value :: < super :: browser_protocol :: network :: EventDataReceived > () ?) , super :: browser_protocol :: network :: EventEventSourceMessageReceived :: IDENTIFIER => CdpEvent :: NetworkEventSourceMessageReceived (map . next_value :: < super :: browser_protocol :: network :: EventEventSourceMessageReceived > () ?) , super :: browser_protocol :: network :: EventLoadingFailed :: IDENTIFIER => CdpEvent :: NetworkLoadingFailed (map . next_value :: < super :: browser_protocol :: network :: EventLoadingFailed > () ?) , super :: browser_protocol :: network :: EventLoadingFinished :: IDENTIFIER => CdpEvent :: NetworkLoadingFinished (map . next_value :: < super :: browser_protocol :: network :: EventLoadingFinished > () ?) , super :: browser_protocol :: network :: EventRequestServedFromCache :: IDENTIFIER => CdpEvent :: NetworkRequestServedFromCache (map . next_value :: < super :: browser_protocol :: network :: EventRequestServedFromCache > () ?) , super :: browser_protocol :: network :: EventRequestWillBeSent :: IDENTIFIER => CdpEvent :: NetworkRequestWillBeSent (Box :: new (map . next_value :: < super :: browser_protocol :: network :: EventRequestWillBeSent > () ?)) , super :: browser_protocol :: network :: EventResourceChangedPriority :: IDENTIFIER => CdpEvent :: NetworkResourceChangedPriority (map . next_value :: < super :: browser_protocol :: network :: EventResourceChangedPriority > () ?) , super :: browser_protocol :: network :: EventSignedExchangeReceived :: IDENTIFIER => CdpEvent :: NetworkSignedExchangeReceived (Box :: new (map . next_value :: < super :: browser_protocol :: network :: EventSignedExchangeReceived > () ?)) , super :: browser_protocol :: network :: EventResponseReceived :: IDENTIFIER => CdpEvent :: NetworkResponseReceived (Box :: new (map . next_value :: < super :: browser_protocol :: network :: EventResponseReceived > () ?)) , super :: browser_protocol :: network :: EventWebSocketClosed :: IDENTIFIER => CdpEvent :: NetworkWebSocketClosed (map . next_value :: < super :: browser_protocol :: network :: EventWebSocketClosed > () ?) , super :: browser_protocol :: network :: EventWebSocketCreated :: IDENTIFIER => CdpEvent :: NetworkWebSocketCreated (Box :: new (map . next_value :: < super :: browser_protocol :: network :: EventWebSocketCreated > () ?)) , super :: browser_protocol :: network :: EventWebSocketFrameError :: IDENTIFIER => CdpEvent :: NetworkWebSocketFrameError (map . next_value :: < super :: browser_protocol :: network :: EventWebSocketFrameError > () ?) , super :: browser_protocol :: network :: EventWebSocketFrameReceived :: IDENTIFIER => CdpEvent :: NetworkWebSocketFrameReceived (map . next_value :: < super :: browser_protocol :: network :: EventWebSocketFrameReceived > () ?) , super :: browser_protocol :: network :: EventWebSocketFrameSent :: IDENTIFIER => CdpEvent :: NetworkWebSocketFrameSent (map . next_value :: < super :: browser_protocol :: network :: EventWebSocketFrameSent > () ?) , super :: browser_protocol :: network :: EventWebSocketHandshakeResponseReceived :: IDENTIFIER => CdpEvent :: NetworkWebSocketHandshakeResponseReceived (Box :: new (map . next_value :: < super :: browser_protocol :: network :: EventWebSocketHandshakeResponseReceived > () ?)) , super :: browser_protocol :: network :: EventWebSocketWillSendHandshakeRequest :: IDENTIFIER => CdpEvent :: NetworkWebSocketWillSendHandshakeRequest (map . next_value :: < super :: browser_protocol :: network :: EventWebSocketWillSendHandshakeRequest > () ?) , super :: browser_protocol :: network :: EventWebTransportCreated :: IDENTIFIER => CdpEvent :: NetworkWebTransportCreated (Box :: new (map . next_value :: < super :: browser_protocol :: network :: EventWebTransportCreated > () ?)) , super :: browser_protocol :: network :: EventWebTransportConnectionEstablished :: IDENTIFIER => CdpEvent :: NetworkWebTransportConnectionEstablished (map . next_value :: < super :: browser_protocol :: network :: EventWebTransportConnectionEstablished > () ?) , super :: browser_protocol :: network :: EventWebTransportClosed :: IDENTIFIER => CdpEvent :: NetworkWebTransportClosed (map . next_value :: < super :: browser_protocol :: network :: EventWebTransportClosed > () ?) , super :: browser_protocol :: network :: EventDirectTcpSocketCreated :: IDENTIFIER => CdpEvent :: NetworkDirectTcpSocketCreated (Box :: new (map . next_value :: < super :: browser_protocol :: network :: EventDirectTcpSocketCreated > () ?)) , super :: browser_protocol :: network :: EventDirectTcpSocketOpened :: IDENTIFIER => CdpEvent :: NetworkDirectTcpSocketOpened (map . next_value :: < super :: browser_protocol :: network :: EventDirectTcpSocketOpened > () ?) , super :: browser_protocol :: network :: EventDirectTcpSocketAborted :: IDENTIFIER => CdpEvent :: NetworkDirectTcpSocketAborted (map . next_value :: < super :: browser_protocol :: network :: EventDirectTcpSocketAborted > () ?) , super :: browser_protocol :: network :: EventDirectTcpSocketClosed :: IDENTIFIER => CdpEvent :: NetworkDirectTcpSocketClosed (map . next_value :: < super :: browser_protocol :: network :: EventDirectTcpSocketClosed > () ?) , super :: browser_protocol :: network :: EventDirectTcpSocketChunkSent :: IDENTIFIER => CdpEvent :: NetworkDirectTcpSocketChunkSent (map . next_value :: < super :: browser_protocol :: network :: EventDirectTcpSocketChunkSent > () ?) , super :: browser_protocol :: network :: EventDirectTcpSocketChunkReceived :: IDENTIFIER => CdpEvent :: NetworkDirectTcpSocketChunkReceived (map . next_value :: < super :: browser_protocol :: network :: EventDirectTcpSocketChunkReceived > () ?) , super :: browser_protocol :: network :: EventDirectUdpSocketJoinedMulticastGroup :: IDENTIFIER => CdpEvent :: NetworkDirectUdpSocketJoinedMulticastGroup (map . next_value :: < super :: browser_protocol :: network :: EventDirectUdpSocketJoinedMulticastGroup > () ?) , super :: browser_protocol :: network :: EventDirectUdpSocketLeftMulticastGroup :: IDENTIFIER => CdpEvent :: NetworkDirectUdpSocketLeftMulticastGroup (map . next_value :: < super :: browser_protocol :: network :: EventDirectUdpSocketLeftMulticastGroup > () ?) , super :: browser_protocol :: network :: EventDirectUdpSocketCreated :: IDENTIFIER => CdpEvent :: NetworkDirectUdpSocketCreated (Box :: new (map . next_value :: < super :: browser_protocol :: network :: EventDirectUdpSocketCreated > () ?)) , super :: browser_protocol :: network :: EventDirectUdpSocketOpened :: IDENTIFIER => CdpEvent :: NetworkDirectUdpSocketOpened (map . next_value :: < super :: browser_protocol :: network :: EventDirectUdpSocketOpened > () ?) , super :: browser_protocol :: network :: EventDirectUdpSocketAborted :: IDENTIFIER => CdpEvent :: NetworkDirectUdpSocketAborted (map . next_value :: < super :: browser_protocol :: network :: EventDirectUdpSocketAborted > () ?) , super :: browser_protocol :: network :: EventDirectUdpSocketClosed :: IDENTIFIER => CdpEvent :: NetworkDirectUdpSocketClosed (map . next_value :: < super :: browser_protocol :: network :: EventDirectUdpSocketClosed > () ?) , super :: browser_protocol :: network :: EventDirectUdpSocketChunkSent :: IDENTIFIER => CdpEvent :: NetworkDirectUdpSocketChunkSent (map . next_value :: < super :: browser_protocol :: network :: EventDirectUdpSocketChunkSent > () ?) , super :: browser_protocol :: network :: EventDirectUdpSocketChunkReceived :: IDENTIFIER => CdpEvent :: NetworkDirectUdpSocketChunkReceived (map . next_value :: < super :: browser_protocol :: network :: EventDirectUdpSocketChunkReceived > () ?) , super :: browser_protocol :: network :: EventRequestWillBeSentExtraInfo :: IDENTIFIER => CdpEvent :: NetworkRequestWillBeSentExtraInfo (map . next_value :: < super :: browser_protocol :: network :: EventRequestWillBeSentExtraInfo > () ?) , super :: browser_protocol :: network :: EventResponseReceivedExtraInfo :: IDENTIFIER => CdpEvent :: NetworkResponseReceivedExtraInfo (Box :: new (map . next_value :: < super :: browser_protocol :: network :: EventResponseReceivedExtraInfo > () ?)) , super :: browser_protocol :: network :: EventResponseReceivedEarlyHints :: IDENTIFIER => CdpEvent :: NetworkResponseReceivedEarlyHints (map . next_value :: < super :: browser_protocol :: network :: EventResponseReceivedEarlyHints > () ?) , super :: browser_protocol :: network :: EventTrustTokenOperationDone :: IDENTIFIER => CdpEvent :: NetworkTrustTokenOperationDone (map . next_value :: < super :: browser_protocol :: network :: EventTrustTokenOperationDone > () ?) , super :: browser_protocol :: network :: EventPolicyUpdated :: IDENTIFIER => CdpEvent :: NetworkPolicyUpdated (map . next_value :: < super :: browser_protocol :: network :: EventPolicyUpdated > () ?) , super :: browser_protocol :: network :: EventReportingApiReportAdded :: IDENTIFIER => CdpEvent :: NetworkReportingApiReportAdded (map . next_value :: < super :: browser_protocol :: network :: EventReportingApiReportAdded > () ?) , super :: browser_protocol :: network :: EventReportingApiReportUpdated :: IDENTIFIER => CdpEvent :: NetworkReportingApiReportUpdated (map . next_value :: < super :: browser_protocol :: network :: EventReportingApiReportUpdated > () ?) , super :: browser_protocol :: network :: EventReportingApiEndpointsChangedForOrigin :: IDENTIFIER => CdpEvent :: NetworkReportingApiEndpointsChangedForOrigin (map . next_value :: < super :: browser_protocol :: network :: EventReportingApiEndpointsChangedForOrigin > () ?) , super :: browser_protocol :: network :: EventDeviceBoundSessionsAdded :: IDENTIFIER => CdpEvent :: NetworkDeviceBoundSessionsAdded (map . next_value :: < super :: browser_protocol :: network :: EventDeviceBoundSessionsAdded > () ?) , super :: browser_protocol :: network :: EventDeviceBoundSessionEventOccurred :: IDENTIFIER => CdpEvent :: NetworkDeviceBoundSessionEventOccurred (Box :: new (map . next_value :: < super :: browser_protocol :: network :: EventDeviceBoundSessionEventOccurred > () ?)) , super :: browser_protocol :: overlay :: EventInspectNodeRequested :: IDENTIFIER => CdpEvent :: OverlayInspectNodeRequested (map . next_value :: < super :: browser_protocol :: overlay :: EventInspectNodeRequested > () ?) , super :: browser_protocol :: overlay :: EventNodeHighlightRequested :: IDENTIFIER => CdpEvent :: OverlayNodeHighlightRequested (map . next_value :: < super :: browser_protocol :: overlay :: EventNodeHighlightRequested > () ?) , super :: browser_protocol :: overlay :: EventScreenshotRequested :: IDENTIFIER => CdpEvent :: OverlayScreenshotRequested (map . next_value :: < super :: browser_protocol :: overlay :: EventScreenshotRequested > () ?) , super :: browser_protocol :: overlay :: EventInspectModeCanceled :: IDENTIFIER => CdpEvent :: OverlayInspectModeCanceled (map . next_value :: < super :: browser_protocol :: overlay :: EventInspectModeCanceled > () ?) , super :: browser_protocol :: page :: EventDomContentEventFired :: IDENTIFIER => CdpEvent :: PageDomContentEventFired (map . next_value :: < super :: browser_protocol :: page :: EventDomContentEventFired > () ?) , super :: browser_protocol :: page :: EventFileChooserOpened :: IDENTIFIER => CdpEvent :: PageFileChooserOpened (map . next_value :: < super :: browser_protocol :: page :: EventFileChooserOpened > () ?) , super :: browser_protocol :: page :: EventFrameAttached :: IDENTIFIER => CdpEvent :: PageFrameAttached (map . next_value :: < super :: browser_protocol :: page :: EventFrameAttached > () ?) , super :: browser_protocol :: page :: EventFrameDetached :: IDENTIFIER => CdpEvent :: PageFrameDetached (map . next_value :: < super :: browser_protocol :: page :: EventFrameDetached > () ?) , super :: browser_protocol :: page :: EventFrameSubtreeWillBeDetached :: IDENTIFIER => CdpEvent :: PageFrameSubtreeWillBeDetached (map . next_value :: < super :: browser_protocol :: page :: EventFrameSubtreeWillBeDetached > () ?) , super :: browser_protocol :: page :: EventFrameNavigated :: IDENTIFIER => CdpEvent :: PageFrameNavigated (Box :: new (map . next_value :: < super :: browser_protocol :: page :: EventFrameNavigated > () ?)) , super :: browser_protocol :: page :: EventDocumentOpened :: IDENTIFIER => CdpEvent :: PageDocumentOpened (Box :: new (map . next_value :: < super :: browser_protocol :: page :: EventDocumentOpened > () ?)) , super :: browser_protocol :: page :: EventFrameResized :: IDENTIFIER => CdpEvent :: PageFrameResized (map . next_value :: < super :: browser_protocol :: page :: EventFrameResized > () ?) , super :: browser_protocol :: page :: EventFrameStartedNavigating :: IDENTIFIER => CdpEvent :: PageFrameStartedNavigating (map . next_value :: < super :: browser_protocol :: page :: EventFrameStartedNavigating > () ?) , super :: browser_protocol :: page :: EventFrameRequestedNavigation :: IDENTIFIER => CdpEvent :: PageFrameRequestedNavigation (map . next_value :: < super :: browser_protocol :: page :: EventFrameRequestedNavigation > () ?) , super :: browser_protocol :: page :: EventFrameStartedLoading :: IDENTIFIER => CdpEvent :: PageFrameStartedLoading (map . next_value :: < super :: browser_protocol :: page :: EventFrameStartedLoading > () ?) , super :: browser_protocol :: page :: EventFrameStoppedLoading :: IDENTIFIER => CdpEvent :: PageFrameStoppedLoading (map . next_value :: < super :: browser_protocol :: page :: EventFrameStoppedLoading > () ?) , super :: browser_protocol :: page :: EventInterstitialHidden :: IDENTIFIER => CdpEvent :: PageInterstitialHidden (map . next_value :: < super :: browser_protocol :: page :: EventInterstitialHidden > () ?) , super :: browser_protocol :: page :: EventInterstitialShown :: IDENTIFIER => CdpEvent :: PageInterstitialShown (map . next_value :: < super :: browser_protocol :: page :: EventInterstitialShown > () ?) , super :: browser_protocol :: page :: EventJavascriptDialogClosed :: IDENTIFIER => CdpEvent :: PageJavascriptDialogClosed (map . next_value :: < super :: browser_protocol :: page :: EventJavascriptDialogClosed > () ?) , super :: browser_protocol :: page :: EventJavascriptDialogOpening :: IDENTIFIER => CdpEvent :: PageJavascriptDialogOpening (map . next_value :: < super :: browser_protocol :: page :: EventJavascriptDialogOpening > () ?) , super :: browser_protocol :: page :: EventLifecycleEvent :: IDENTIFIER => CdpEvent :: PageLifecycleEvent (map . next_value :: < super :: browser_protocol :: page :: EventLifecycleEvent > () ?) , super :: browser_protocol :: page :: EventBackForwardCacheNotUsed :: IDENTIFIER => CdpEvent :: PageBackForwardCacheNotUsed (map . next_value :: < super :: browser_protocol :: page :: EventBackForwardCacheNotUsed > () ?) , super :: browser_protocol :: page :: EventLoadEventFired :: IDENTIFIER => CdpEvent :: PageLoadEventFired (map . next_value :: < super :: browser_protocol :: page :: EventLoadEventFired > () ?) , super :: browser_protocol :: page :: EventNavigatedWithinDocument :: IDENTIFIER => CdpEvent :: PageNavigatedWithinDocument (map . next_value :: < super :: browser_protocol :: page :: EventNavigatedWithinDocument > () ?) , super :: browser_protocol :: page :: EventScreencastFrame :: IDENTIFIER => CdpEvent :: PageScreencastFrame (map . next_value :: < super :: browser_protocol :: page :: EventScreencastFrame > () ?) , super :: browser_protocol :: page :: EventScreencastVisibilityChanged :: IDENTIFIER => CdpEvent :: PageScreencastVisibilityChanged (map . next_value :: < super :: browser_protocol :: page :: EventScreencastVisibilityChanged > () ?) , super :: browser_protocol :: page :: EventWindowOpen :: IDENTIFIER => CdpEvent :: PageWindowOpen (map . next_value :: < super :: browser_protocol :: page :: EventWindowOpen > () ?) , super :: browser_protocol :: page :: EventCompilationCacheProduced :: IDENTIFIER => CdpEvent :: PageCompilationCacheProduced (map . next_value :: < super :: browser_protocol :: page :: EventCompilationCacheProduced > () ?) , super :: browser_protocol :: performance :: EventMetrics :: IDENTIFIER => CdpEvent :: PerformanceMetrics (map . next_value :: < super :: browser_protocol :: performance :: EventMetrics > () ?) , super :: browser_protocol :: performance_timeline :: EventTimelineEventAdded :: IDENTIFIER => CdpEvent :: PerformanceTimelineTimelineEventAdded (Box :: new (map . next_value :: < super :: browser_protocol :: performance_timeline :: EventTimelineEventAdded > () ?)) , super :: browser_protocol :: preload :: EventRuleSetUpdated :: IDENTIFIER => CdpEvent :: PreloadRuleSetUpdated (Box :: new (map . next_value :: < super :: browser_protocol :: preload :: EventRuleSetUpdated > () ?)) , super :: browser_protocol :: preload :: EventRuleSetRemoved :: IDENTIFIER => CdpEvent :: PreloadRuleSetRemoved (map . next_value :: < super :: browser_protocol :: preload :: EventRuleSetRemoved > () ?) , super :: browser_protocol :: preload :: EventPreloadEnabledStateUpdated :: IDENTIFIER => CdpEvent :: PreloadPreloadEnabledStateUpdated (map . next_value :: < super :: browser_protocol :: preload :: EventPreloadEnabledStateUpdated > () ?) , super :: browser_protocol :: preload :: EventPrefetchStatusUpdated :: IDENTIFIER => CdpEvent :: PreloadPrefetchStatusUpdated (Box :: new (map . next_value :: < super :: browser_protocol :: preload :: EventPrefetchStatusUpdated > () ?)) , super :: browser_protocol :: preload :: EventPrerenderStatusUpdated :: IDENTIFIER => CdpEvent :: PreloadPrerenderStatusUpdated (map . next_value :: < super :: browser_protocol :: preload :: EventPrerenderStatusUpdated > () ?) , super :: browser_protocol :: preload :: EventPreloadingAttemptSourcesUpdated :: IDENTIFIER => CdpEvent :: PreloadPreloadingAttemptSourcesUpdated (map . next_value :: < super :: browser_protocol :: preload :: EventPreloadingAttemptSourcesUpdated > () ?) , super :: browser_protocol :: security :: EventVisibleSecurityStateChanged :: IDENTIFIER => CdpEvent :: SecurityVisibleSecurityStateChanged (Box :: new (map . next_value :: < super :: browser_protocol :: security :: EventVisibleSecurityStateChanged > () ?)) , super :: browser_protocol :: service_worker :: EventWorkerErrorReported :: IDENTIFIER => CdpEvent :: ServiceWorkerWorkerErrorReported (map . next_value :: < super :: browser_protocol :: service_worker :: EventWorkerErrorReported > () ?) , super :: browser_protocol :: service_worker :: EventWorkerRegistrationUpdated :: IDENTIFIER => CdpEvent :: ServiceWorkerWorkerRegistrationUpdated (map . next_value :: < super :: browser_protocol :: service_worker :: EventWorkerRegistrationUpdated > () ?) , super :: browser_protocol :: service_worker :: EventWorkerVersionUpdated :: IDENTIFIER => CdpEvent :: ServiceWorkerWorkerVersionUpdated (map . next_value :: < super :: browser_protocol :: service_worker :: EventWorkerVersionUpdated > () ?) , super :: browser_protocol :: storage :: EventCacheStorageContentUpdated :: IDENTIFIER => CdpEvent :: StorageCacheStorageContentUpdated (map . next_value :: < super :: browser_protocol :: storage :: EventCacheStorageContentUpdated > () ?) , super :: browser_protocol :: storage :: EventCacheStorageListUpdated :: IDENTIFIER => CdpEvent :: StorageCacheStorageListUpdated (map . next_value :: < super :: browser_protocol :: storage :: EventCacheStorageListUpdated > () ?) , super :: browser_protocol :: storage :: EventIndexedDbContentUpdated :: IDENTIFIER => CdpEvent :: StorageIndexedDbContentUpdated (map . next_value :: < super :: browser_protocol :: storage :: EventIndexedDbContentUpdated > () ?) , super :: browser_protocol :: storage :: EventIndexedDbListUpdated :: IDENTIFIER => CdpEvent :: StorageIndexedDbListUpdated (map . next_value :: < super :: browser_protocol :: storage :: EventIndexedDbListUpdated > () ?) , super :: browser_protocol :: storage :: EventInterestGroupAccessed :: IDENTIFIER => CdpEvent :: StorageInterestGroupAccessed (map . next_value :: < super :: browser_protocol :: storage :: EventInterestGroupAccessed > () ?) , super :: browser_protocol :: storage :: EventInterestGroupAuctionEventOccurred :: IDENTIFIER => CdpEvent :: StorageInterestGroupAuctionEventOccurred (map . next_value :: < super :: browser_protocol :: storage :: EventInterestGroupAuctionEventOccurred > () ?) , super :: browser_protocol :: storage :: EventInterestGroupAuctionNetworkRequestCreated :: IDENTIFIER => CdpEvent :: StorageInterestGroupAuctionNetworkRequestCreated (map . next_value :: < super :: browser_protocol :: storage :: EventInterestGroupAuctionNetworkRequestCreated > () ?) , super :: browser_protocol :: storage :: EventSharedStorageAccessed :: IDENTIFIER => CdpEvent :: StorageSharedStorageAccessed (Box :: new (map . next_value :: < super :: browser_protocol :: storage :: EventSharedStorageAccessed > () ?)) , super :: browser_protocol :: storage :: EventSharedStorageWorkletOperationExecutionFinished :: IDENTIFIER => CdpEvent :: StorageSharedStorageWorkletOperationExecutionFinished (map . next_value :: < super :: browser_protocol :: storage :: EventSharedStorageWorkletOperationExecutionFinished > () ?) , super :: browser_protocol :: storage :: EventStorageBucketCreatedOrUpdated :: IDENTIFIER => CdpEvent :: StorageStorageBucketCreatedOrUpdated (map . next_value :: < super :: browser_protocol :: storage :: EventStorageBucketCreatedOrUpdated > () ?) , super :: browser_protocol :: storage :: EventStorageBucketDeleted :: IDENTIFIER => CdpEvent :: StorageStorageBucketDeleted (map . next_value :: < super :: browser_protocol :: storage :: EventStorageBucketDeleted > () ?) , super :: browser_protocol :: storage :: EventAttributionReportingSourceRegistered :: IDENTIFIER => CdpEvent :: StorageAttributionReportingSourceRegistered (Box :: new (map . next_value :: < super :: browser_protocol :: storage :: EventAttributionReportingSourceRegistered > () ?)) , super :: browser_protocol :: storage :: EventAttributionReportingTriggerRegistered :: IDENTIFIER => CdpEvent :: StorageAttributionReportingTriggerRegistered (Box :: new (map . next_value :: < super :: browser_protocol :: storage :: EventAttributionReportingTriggerRegistered > () ?)) , super :: browser_protocol :: storage :: EventAttributionReportingReportSent :: IDENTIFIER => CdpEvent :: StorageAttributionReportingReportSent (map . next_value :: < super :: browser_protocol :: storage :: EventAttributionReportingReportSent > () ?) , super :: browser_protocol :: storage :: EventAttributionReportingVerboseDebugReportSent :: IDENTIFIER => CdpEvent :: StorageAttributionReportingVerboseDebugReportSent (map . next_value :: < super :: browser_protocol :: storage :: EventAttributionReportingVerboseDebugReportSent > () ?) , super :: browser_protocol :: target :: EventAttachedToTarget :: IDENTIFIER => CdpEvent :: TargetAttachedToTarget (Box :: new (map . next_value :: < super :: browser_protocol :: target :: EventAttachedToTarget > () ?)) , super :: browser_protocol :: target :: EventDetachedFromTarget :: IDENTIFIER => CdpEvent :: TargetDetachedFromTarget (map . next_value :: < super :: browser_protocol :: target :: EventDetachedFromTarget > () ?) , super :: browser_protocol :: target :: EventReceivedMessageFromTarget :: IDENTIFIER => CdpEvent :: TargetReceivedMessageFromTarget (map . next_value :: < super :: browser_protocol :: target :: EventReceivedMessageFromTarget > () ?) , super :: browser_protocol :: target :: EventTargetCreated :: IDENTIFIER => CdpEvent :: TargetTargetCreated (Box :: new (map . next_value :: < super :: browser_protocol :: target :: EventTargetCreated > () ?)) , super :: browser_protocol :: target :: EventTargetDestroyed :: IDENTIFIER => CdpEvent :: TargetTargetDestroyed (map . next_value :: < super :: browser_protocol :: target :: EventTargetDestroyed > () ?) , super :: browser_protocol :: target :: EventTargetCrashed :: IDENTIFIER => CdpEvent :: TargetTargetCrashed (map . next_value :: < super :: browser_protocol :: target :: EventTargetCrashed > () ?) , super :: browser_protocol :: target :: EventTargetInfoChanged :: IDENTIFIER => CdpEvent :: TargetTargetInfoChanged (Box :: new (map . next_value :: < super :: browser_protocol :: target :: EventTargetInfoChanged > () ?)) , super :: browser_protocol :: tethering :: EventAccepted :: IDENTIFIER => CdpEvent :: TetheringAccepted (map . next_value :: < super :: browser_protocol :: tethering :: EventAccepted > () ?) , super :: browser_protocol :: tracing :: EventBufferUsage :: IDENTIFIER => CdpEvent :: TracingBufferUsage (map . next_value :: < super :: browser_protocol :: tracing :: EventBufferUsage > () ?) , super :: browser_protocol :: tracing :: EventDataCollected :: IDENTIFIER => CdpEvent :: TracingDataCollected (map . next_value :: < super :: browser_protocol :: tracing :: EventDataCollected > () ?) , super :: browser_protocol :: tracing :: EventTracingComplete :: IDENTIFIER => CdpEvent :: TracingTracingComplete (map . next_value :: < super :: browser_protocol :: tracing :: EventTracingComplete > () ?) , super :: browser_protocol :: web_audio :: EventContextCreated :: IDENTIFIER => CdpEvent :: WebAudioContextCreated (map . next_value :: < super :: browser_protocol :: web_audio :: EventContextCreated > () ?) , super :: browser_protocol :: web_audio :: EventContextWillBeDestroyed :: IDENTIFIER => CdpEvent :: WebAudioContextWillBeDestroyed (map . next_value :: < super :: browser_protocol :: web_audio :: EventContextWillBeDestroyed > () ?) , super :: browser_protocol :: web_audio :: EventContextChanged :: IDENTIFIER => CdpEvent :: WebAudioContextChanged (map . next_value :: < super :: browser_protocol :: web_audio :: EventContextChanged > () ?) , super :: browser_protocol :: web_audio :: EventAudioListenerCreated :: IDENTIFIER => CdpEvent :: WebAudioAudioListenerCreated (map . next_value :: < super :: browser_protocol :: web_audio :: EventAudioListenerCreated > () ?) , super :: browser_protocol :: web_audio :: EventAudioListenerWillBeDestroyed :: IDENTIFIER => CdpEvent :: WebAudioAudioListenerWillBeDestroyed (map . next_value :: < super :: browser_protocol :: web_audio :: EventAudioListenerWillBeDestroyed > () ?) , super :: browser_protocol :: web_audio :: EventAudioNodeCreated :: IDENTIFIER => CdpEvent :: WebAudioAudioNodeCreated (map . next_value :: < super :: browser_protocol :: web_audio :: EventAudioNodeCreated > () ?) , super :: browser_protocol :: web_audio :: EventAudioNodeWillBeDestroyed :: IDENTIFIER => CdpEvent :: WebAudioAudioNodeWillBeDestroyed (map . next_value :: < super :: browser_protocol :: web_audio :: EventAudioNodeWillBeDestroyed > () ?) , super :: browser_protocol :: web_audio :: EventAudioParamCreated :: IDENTIFIER => CdpEvent :: WebAudioAudioParamCreated (map . next_value :: < super :: browser_protocol :: web_audio :: EventAudioParamCreated > () ?) , super :: browser_protocol :: web_audio :: EventAudioParamWillBeDestroyed :: IDENTIFIER => CdpEvent :: WebAudioAudioParamWillBeDestroyed (map . next_value :: < super :: browser_protocol :: web_audio :: EventAudioParamWillBeDestroyed > () ?) , super :: browser_protocol :: web_audio :: EventNodesConnected :: IDENTIFIER => CdpEvent :: WebAudioNodesConnected (map . next_value :: < super :: browser_protocol :: web_audio :: EventNodesConnected > () ?) , super :: browser_protocol :: web_audio :: EventNodesDisconnected :: IDENTIFIER => CdpEvent :: WebAudioNodesDisconnected (map . next_value :: < super :: browser_protocol :: web_audio :: EventNodesDisconnected > () ?) , super :: browser_protocol :: web_audio :: EventNodeParamConnected :: IDENTIFIER => CdpEvent :: WebAudioNodeParamConnected (map . next_value :: < super :: browser_protocol :: web_audio :: EventNodeParamConnected > () ?) , super :: browser_protocol :: web_audio :: EventNodeParamDisconnected :: IDENTIFIER => CdpEvent :: WebAudioNodeParamDisconnected (map . next_value :: < super :: browser_protocol :: web_audio :: EventNodeParamDisconnected > () ?) , super :: browser_protocol :: web_authn :: EventCredentialAdded :: IDENTIFIER => CdpEvent :: WebAuthnCredentialAdded (Box :: new (map . next_value :: < super :: browser_protocol :: web_authn :: EventCredentialAdded > () ?)) , super :: browser_protocol :: web_authn :: EventCredentialDeleted :: IDENTIFIER => CdpEvent :: WebAuthnCredentialDeleted (map . next_value :: < super :: browser_protocol :: web_authn :: EventCredentialDeleted > () ?) , super :: browser_protocol :: web_authn :: EventCredentialUpdated :: IDENTIFIER => CdpEvent :: WebAuthnCredentialUpdated (Box :: new (map . next_value :: < super :: browser_protocol :: web_authn :: EventCredentialUpdated > () ?)) , super :: browser_protocol :: web_authn :: EventCredentialAsserted :: IDENTIFIER => CdpEvent :: WebAuthnCredentialAsserted (Box :: new (map . next_value :: < super :: browser_protocol :: web_authn :: EventCredentialAsserted > () ?)) , _ => CdpEvent :: Other (map . next_value :: < serde_json :: Value > () ?) }) ;
+                            }
+                        }
+                    }
+                    let method = method.ok_or_else(|| de::Error::missing_field("method"))?;
+                    let params = params.ok_or_else(|| de::Error::missing_field("params"))?;
+                    Ok(CdpEventMessage {
+                        method: ::std::borrow::Cow::Owned(method),
+                        session_id,
+                        params,
+                    })
+                }
+            }
+            const FIELDS: &[&str] = &["method", "sessionId", "params"];
+            deserializer.deserialize_struct("CdpEventMessage", FIELDS, MessageVisitor)
+        }
+    }
+    impl std::convert::TryInto<chromiumoxide_types::CdpJsonEventMessage> for CdpEventMessage {
+        type Error = serde_json::Error;
+        fn try_into(self) -> Result<chromiumoxide_types::CdpJsonEventMessage, Self::Error> {
+            use chromiumoxide_types::Method;
+            Ok(chromiumoxide_types::CdpJsonEventMessage {
+                method: self.identifier(),
+                session_id: self.session_id,
+                params: self.params.into_json()?,
+            })
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::debugger::EventPaused {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DebuggerPaused(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::debugger::EventPaused> for CdpEvent {
+        fn from(el: super::js_protocol::debugger::EventPaused) -> CdpEvent {
+            CdpEvent::DebuggerPaused(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::debugger::EventResumed {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DebuggerResumed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::debugger::EventResumed> for CdpEvent {
+        fn from(el: super::js_protocol::debugger::EventResumed) -> CdpEvent {
+            CdpEvent::DebuggerResumed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::debugger::EventScriptFailedToParse {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DebuggerScriptFailedToParse(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::debugger::EventScriptFailedToParse> for CdpEvent {
+        fn from(el: super::js_protocol::debugger::EventScriptFailedToParse) -> CdpEvent {
+            CdpEvent::DebuggerScriptFailedToParse(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::debugger::EventScriptParsed {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DebuggerScriptParsed(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::debugger::EventScriptParsed> for CdpEvent {
+        fn from(el: super::js_protocol::debugger::EventScriptParsed) -> CdpEvent {
+            CdpEvent::DebuggerScriptParsed(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::js_protocol::heap_profiler::EventAddHeapSnapshotChunk
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::HeapProfilerAddHeapSnapshotChunk(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::heap_profiler::EventAddHeapSnapshotChunk> for CdpEvent {
+        fn from(el: super::js_protocol::heap_profiler::EventAddHeapSnapshotChunk) -> CdpEvent {
+            CdpEvent::HeapProfilerAddHeapSnapshotChunk(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::heap_profiler::EventHeapStatsUpdate {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::HeapProfilerHeapStatsUpdate(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::heap_profiler::EventHeapStatsUpdate> for CdpEvent {
+        fn from(el: super::js_protocol::heap_profiler::EventHeapStatsUpdate) -> CdpEvent {
+            CdpEvent::HeapProfilerHeapStatsUpdate(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::heap_profiler::EventLastSeenObjectId {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::HeapProfilerLastSeenObjectId(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::heap_profiler::EventLastSeenObjectId> for CdpEvent {
+        fn from(el: super::js_protocol::heap_profiler::EventLastSeenObjectId) -> CdpEvent {
+            CdpEvent::HeapProfilerLastSeenObjectId(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::js_protocol::heap_profiler::EventReportHeapSnapshotProgress
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::HeapProfilerReportHeapSnapshotProgress(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::heap_profiler::EventReportHeapSnapshotProgress> for CdpEvent {
+        fn from(
+            el: super::js_protocol::heap_profiler::EventReportHeapSnapshotProgress,
+        ) -> CdpEvent {
+            CdpEvent::HeapProfilerReportHeapSnapshotProgress(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::heap_profiler::EventResetProfiles {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::HeapProfilerResetProfiles(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::heap_profiler::EventResetProfiles> for CdpEvent {
+        fn from(el: super::js_protocol::heap_profiler::EventResetProfiles) -> CdpEvent {
+            CdpEvent::HeapProfilerResetProfiles(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::profiler::EventConsoleProfileFinished {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::ProfilerConsoleProfileFinished(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::profiler::EventConsoleProfileFinished> for CdpEvent {
+        fn from(el: super::js_protocol::profiler::EventConsoleProfileFinished) -> CdpEvent {
+            CdpEvent::ProfilerConsoleProfileFinished(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::profiler::EventConsoleProfileStarted {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::ProfilerConsoleProfileStarted(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::profiler::EventConsoleProfileStarted> for CdpEvent {
+        fn from(el: super::js_protocol::profiler::EventConsoleProfileStarted) -> CdpEvent {
+            CdpEvent::ProfilerConsoleProfileStarted(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::js_protocol::profiler::EventPreciseCoverageDeltaUpdate
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::ProfilerPreciseCoverageDeltaUpdate(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::profiler::EventPreciseCoverageDeltaUpdate> for CdpEvent {
+        fn from(el: super::js_protocol::profiler::EventPreciseCoverageDeltaUpdate) -> CdpEvent {
+            CdpEvent::ProfilerPreciseCoverageDeltaUpdate(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::runtime::EventBindingCalled {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::RuntimeBindingCalled(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::runtime::EventBindingCalled> for CdpEvent {
+        fn from(el: super::js_protocol::runtime::EventBindingCalled) -> CdpEvent {
+            CdpEvent::RuntimeBindingCalled(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::runtime::EventConsoleApiCalled {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::RuntimeConsoleApiCalled(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::runtime::EventConsoleApiCalled> for CdpEvent {
+        fn from(el: super::js_protocol::runtime::EventConsoleApiCalled) -> CdpEvent {
+            CdpEvent::RuntimeConsoleApiCalled(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::runtime::EventExceptionRevoked {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::RuntimeExceptionRevoked(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::runtime::EventExceptionRevoked> for CdpEvent {
+        fn from(el: super::js_protocol::runtime::EventExceptionRevoked) -> CdpEvent {
+            CdpEvent::RuntimeExceptionRevoked(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::runtime::EventExceptionThrown {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::RuntimeExceptionThrown(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::runtime::EventExceptionThrown> for CdpEvent {
+        fn from(el: super::js_protocol::runtime::EventExceptionThrown) -> CdpEvent {
+            CdpEvent::RuntimeExceptionThrown(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::runtime::EventExecutionContextCreated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::RuntimeExecutionContextCreated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::runtime::EventExecutionContextCreated> for CdpEvent {
+        fn from(el: super::js_protocol::runtime::EventExecutionContextCreated) -> CdpEvent {
+            CdpEvent::RuntimeExecutionContextCreated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::js_protocol::runtime::EventExecutionContextDestroyed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::RuntimeExecutionContextDestroyed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::runtime::EventExecutionContextDestroyed> for CdpEvent {
+        fn from(el: super::js_protocol::runtime::EventExecutionContextDestroyed) -> CdpEvent {
+            CdpEvent::RuntimeExecutionContextDestroyed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::js_protocol::runtime::EventExecutionContextsCleared
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::RuntimeExecutionContextsCleared(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::runtime::EventExecutionContextsCleared> for CdpEvent {
+        fn from(el: super::js_protocol::runtime::EventExecutionContextsCleared) -> CdpEvent {
+            CdpEvent::RuntimeExecutionContextsCleared(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::js_protocol::runtime::EventInspectRequested {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::RuntimeInspectRequested(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::js_protocol::runtime::EventInspectRequested> for CdpEvent {
+        fn from(el: super::js_protocol::runtime::EventInspectRequested) -> CdpEvent {
+            CdpEvent::RuntimeInspectRequested(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::accessibility::EventLoadComplete {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::AccessibilityLoadComplete(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::accessibility::EventLoadComplete> for CdpEvent {
+        fn from(el: super::browser_protocol::accessibility::EventLoadComplete) -> CdpEvent {
+            CdpEvent::AccessibilityLoadComplete(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::accessibility::EventNodesUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::AccessibilityNodesUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::accessibility::EventNodesUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::accessibility::EventNodesUpdated) -> CdpEvent {
+            CdpEvent::AccessibilityNodesUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::animation::EventAnimationCanceled
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::AnimationAnimationCanceled(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::animation::EventAnimationCanceled> for CdpEvent {
+        fn from(el: super::browser_protocol::animation::EventAnimationCanceled) -> CdpEvent {
+            CdpEvent::AnimationAnimationCanceled(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::animation::EventAnimationCreated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::AnimationAnimationCreated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::animation::EventAnimationCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::animation::EventAnimationCreated) -> CdpEvent {
+            CdpEvent::AnimationAnimationCreated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::animation::EventAnimationStarted {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::AnimationAnimationStarted(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::animation::EventAnimationStarted> for CdpEvent {
+        fn from(el: super::browser_protocol::animation::EventAnimationStarted) -> CdpEvent {
+            CdpEvent::AnimationAnimationStarted(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::animation::EventAnimationUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::AnimationAnimationUpdated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::animation::EventAnimationUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::animation::EventAnimationUpdated) -> CdpEvent {
+            CdpEvent::AnimationAnimationUpdated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::audits::EventIssueAdded {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::AuditsIssueAdded(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::audits::EventIssueAdded> for CdpEvent {
+        fn from(el: super::browser_protocol::audits::EventIssueAdded) -> CdpEvent {
+            CdpEvent::AuditsIssueAdded(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::autofill::EventAddressFormFilled {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::AutofillAddressFormFilled(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::autofill::EventAddressFormFilled> for CdpEvent {
+        fn from(el: super::browser_protocol::autofill::EventAddressFormFilled) -> CdpEvent {
+            CdpEvent::AutofillAddressFormFilled(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::background_service::EventRecordingStateChanged
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::BackgroundServiceRecordingStateChanged(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::background_service::EventRecordingStateChanged> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::background_service::EventRecordingStateChanged,
+        ) -> CdpEvent {
+            CdpEvent::BackgroundServiceRecordingStateChanged(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::background_service::EventBackgroundServiceEventReceived
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::BackgroundServiceBackgroundServiceEventReceived(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::background_service::EventBackgroundServiceEventReceived>
+        for CdpEvent
+    {
+        fn from(
+            el: super::browser_protocol::background_service::EventBackgroundServiceEventReceived,
+        ) -> CdpEvent {
+            CdpEvent::BackgroundServiceBackgroundServiceEventReceived(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::bluetooth_emulation::EventGattOperationReceived
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::BluetoothEmulationGattOperationReceived(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::bluetooth_emulation::EventGattOperationReceived> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::bluetooth_emulation::EventGattOperationReceived,
+        ) -> CdpEvent {
+            CdpEvent::BluetoothEmulationGattOperationReceived(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::bluetooth_emulation::EventCharacteristicOperationReceived
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::BluetoothEmulationCharacteristicOperationReceived(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::bluetooth_emulation::EventCharacteristicOperationReceived>
+        for CdpEvent
+    {
+        fn from(
+            el: super::browser_protocol::bluetooth_emulation::EventCharacteristicOperationReceived,
+        ) -> CdpEvent {
+            CdpEvent::BluetoothEmulationCharacteristicOperationReceived(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::bluetooth_emulation::EventDescriptorOperationReceived
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::BluetoothEmulationDescriptorOperationReceived(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::bluetooth_emulation::EventDescriptorOperationReceived>
+        for CdpEvent
+    {
+        fn from(
+            el: super::browser_protocol::bluetooth_emulation::EventDescriptorOperationReceived,
+        ) -> CdpEvent {
+            CdpEvent::BluetoothEmulationDescriptorOperationReceived(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::browser::EventDownloadWillBegin {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::BrowserDownloadWillBegin(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::browser::EventDownloadWillBegin> for CdpEvent {
+        fn from(el: super::browser_protocol::browser::EventDownloadWillBegin) -> CdpEvent {
+            CdpEvent::BrowserDownloadWillBegin(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::browser::EventDownloadProgress {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::BrowserDownloadProgress(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::browser::EventDownloadProgress> for CdpEvent {
+        fn from(el: super::browser_protocol::browser::EventDownloadProgress) -> CdpEvent {
+            CdpEvent::BrowserDownloadProgress(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::css::EventFontsUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::CssFontsUpdated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::css::EventFontsUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::css::EventFontsUpdated) -> CdpEvent {
+            CdpEvent::CssFontsUpdated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::css::EventMediaQueryResultChanged
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::CssMediaQueryResultChanged(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::css::EventMediaQueryResultChanged> for CdpEvent {
+        fn from(el: super::browser_protocol::css::EventMediaQueryResultChanged) -> CdpEvent {
+            CdpEvent::CssMediaQueryResultChanged(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::css::EventStyleSheetAdded {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::CssStyleSheetAdded(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::css::EventStyleSheetAdded> for CdpEvent {
+        fn from(el: super::browser_protocol::css::EventStyleSheetAdded) -> CdpEvent {
+            CdpEvent::CssStyleSheetAdded(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::css::EventStyleSheetChanged {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::CssStyleSheetChanged(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::css::EventStyleSheetChanged> for CdpEvent {
+        fn from(el: super::browser_protocol::css::EventStyleSheetChanged) -> CdpEvent {
+            CdpEvent::CssStyleSheetChanged(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::css::EventStyleSheetRemoved {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::CssStyleSheetRemoved(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::css::EventStyleSheetRemoved> for CdpEvent {
+        fn from(el: super::browser_protocol::css::EventStyleSheetRemoved) -> CdpEvent {
+            CdpEvent::CssStyleSheetRemoved(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::css::EventComputedStyleUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::CssComputedStyleUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::css::EventComputedStyleUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::css::EventComputedStyleUpdated) -> CdpEvent {
+            CdpEvent::CssComputedStyleUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::cast::EventSinksUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::CastSinksUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::cast::EventSinksUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::cast::EventSinksUpdated) -> CdpEvent {
+            CdpEvent::CastSinksUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::cast::EventIssueUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::CastIssueUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::cast::EventIssueUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::cast::EventIssueUpdated) -> CdpEvent {
+            CdpEvent::CastIssueUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventAttributeModified {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomAttributeModified(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventAttributeModified> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventAttributeModified) -> CdpEvent {
+            CdpEvent::DomAttributeModified(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::dom::EventAdoptedStyleSheetsModified
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomAdoptedStyleSheetsModified(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventAdoptedStyleSheetsModified> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventAdoptedStyleSheetsModified) -> CdpEvent {
+            CdpEvent::DomAdoptedStyleSheetsModified(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventAttributeRemoved {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomAttributeRemoved(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventAttributeRemoved> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventAttributeRemoved) -> CdpEvent {
+            CdpEvent::DomAttributeRemoved(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventCharacterDataModified {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomCharacterDataModified(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventCharacterDataModified> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventCharacterDataModified) -> CdpEvent {
+            CdpEvent::DomCharacterDataModified(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventChildNodeCountUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomChildNodeCountUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventChildNodeCountUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventChildNodeCountUpdated) -> CdpEvent {
+            CdpEvent::DomChildNodeCountUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventChildNodeInserted {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomChildNodeInserted(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventChildNodeInserted> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventChildNodeInserted) -> CdpEvent {
+            CdpEvent::DomChildNodeInserted(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventChildNodeRemoved {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomChildNodeRemoved(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventChildNodeRemoved> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventChildNodeRemoved) -> CdpEvent {
+            CdpEvent::DomChildNodeRemoved(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::dom::EventDistributedNodesUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomDistributedNodesUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventDistributedNodesUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventDistributedNodesUpdated) -> CdpEvent {
+            CdpEvent::DomDistributedNodesUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventDocumentUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomDocumentUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventDocumentUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventDocumentUpdated) -> CdpEvent {
+            CdpEvent::DomDocumentUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventInlineStyleInvalidated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomInlineStyleInvalidated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventInlineStyleInvalidated> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventInlineStyleInvalidated) -> CdpEvent {
+            CdpEvent::DomInlineStyleInvalidated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventPseudoElementAdded {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomPseudoElementAdded(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventPseudoElementAdded> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventPseudoElementAdded) -> CdpEvent {
+            CdpEvent::DomPseudoElementAdded(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::dom::EventTopLayerElementsUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomTopLayerElementsUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventTopLayerElementsUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventTopLayerElementsUpdated) -> CdpEvent {
+            CdpEvent::DomTopLayerElementsUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventScrollableFlagUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomScrollableFlagUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventScrollableFlagUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventScrollableFlagUpdated) -> CdpEvent {
+            CdpEvent::DomScrollableFlagUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::dom::EventAffectedByStartingStylesFlagUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomAffectedByStartingStylesFlagUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventAffectedByStartingStylesFlagUpdated> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::dom::EventAffectedByStartingStylesFlagUpdated,
+        ) -> CdpEvent {
+            CdpEvent::DomAffectedByStartingStylesFlagUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventPseudoElementRemoved {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomPseudoElementRemoved(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventPseudoElementRemoved> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventPseudoElementRemoved) -> CdpEvent {
+            CdpEvent::DomPseudoElementRemoved(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventSetChildNodes {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomSetChildNodes(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventSetChildNodes> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventSetChildNodes) -> CdpEvent {
+            CdpEvent::DomSetChildNodes(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventShadowRootPopped {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomShadowRootPopped(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventShadowRootPopped> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventShadowRootPopped) -> CdpEvent {
+            CdpEvent::DomShadowRootPopped(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::dom::EventShadowRootPushed {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomShadowRootPushed(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom::EventShadowRootPushed> for CdpEvent {
+        fn from(el: super::browser_protocol::dom::EventShadowRootPushed) -> CdpEvent {
+            CdpEvent::DomShadowRootPushed(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::dom_storage::EventDomStorageItemAdded
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomStorageDomStorageItemAdded(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom_storage::EventDomStorageItemAdded> for CdpEvent {
+        fn from(el: super::browser_protocol::dom_storage::EventDomStorageItemAdded) -> CdpEvent {
+            CdpEvent::DomStorageDomStorageItemAdded(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::dom_storage::EventDomStorageItemRemoved
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomStorageDomStorageItemRemoved(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom_storage::EventDomStorageItemRemoved> for CdpEvent {
+        fn from(el: super::browser_protocol::dom_storage::EventDomStorageItemRemoved) -> CdpEvent {
+            CdpEvent::DomStorageDomStorageItemRemoved(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::dom_storage::EventDomStorageItemUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomStorageDomStorageItemUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom_storage::EventDomStorageItemUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::dom_storage::EventDomStorageItemUpdated) -> CdpEvent {
+            CdpEvent::DomStorageDomStorageItemUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::dom_storage::EventDomStorageItemsCleared
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DomStorageDomStorageItemsCleared(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::dom_storage::EventDomStorageItemsCleared> for CdpEvent {
+        fn from(el: super::browser_protocol::dom_storage::EventDomStorageItemsCleared) -> CdpEvent {
+            CdpEvent::DomStorageDomStorageItemsCleared(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::device_access::EventDeviceRequestPrompted
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::DeviceAccessDeviceRequestPrompted(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::device_access::EventDeviceRequestPrompted> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::device_access::EventDeviceRequestPrompted,
+        ) -> CdpEvent {
+            CdpEvent::DeviceAccessDeviceRequestPrompted(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::emulation::EventVirtualTimeBudgetExpired
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::EmulationVirtualTimeBudgetExpired(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::emulation::EventVirtualTimeBudgetExpired> for CdpEvent {
+        fn from(el: super::browser_protocol::emulation::EventVirtualTimeBudgetExpired) -> CdpEvent {
+            CdpEvent::EmulationVirtualTimeBudgetExpired(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::fed_cm::EventDialogShown {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::FedCmDialogShown(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::fed_cm::EventDialogShown> for CdpEvent {
+        fn from(el: super::browser_protocol::fed_cm::EventDialogShown) -> CdpEvent {
+            CdpEvent::FedCmDialogShown(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::fed_cm::EventDialogClosed {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::FedCmDialogClosed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::fed_cm::EventDialogClosed> for CdpEvent {
+        fn from(el: super::browser_protocol::fed_cm::EventDialogClosed) -> CdpEvent {
+            CdpEvent::FedCmDialogClosed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::fetch::EventRequestPaused {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::FetchRequestPaused(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::fetch::EventRequestPaused> for CdpEvent {
+        fn from(el: super::browser_protocol::fetch::EventRequestPaused) -> CdpEvent {
+            CdpEvent::FetchRequestPaused(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::fetch::EventAuthRequired {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::FetchAuthRequired(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::fetch::EventAuthRequired> for CdpEvent {
+        fn from(el: super::browser_protocol::fetch::EventAuthRequired) -> CdpEvent {
+            CdpEvent::FetchAuthRequired(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::input::EventDragIntercepted {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::InputDragIntercepted(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::input::EventDragIntercepted> for CdpEvent {
+        fn from(el: super::browser_protocol::input::EventDragIntercepted) -> CdpEvent {
+            CdpEvent::InputDragIntercepted(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::inspector::EventDetached {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::InspectorDetached(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::inspector::EventDetached> for CdpEvent {
+        fn from(el: super::browser_protocol::inspector::EventDetached) -> CdpEvent {
+            CdpEvent::InspectorDetached(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::inspector::EventTargetCrashed {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::InspectorTargetCrashed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::inspector::EventTargetCrashed> for CdpEvent {
+        fn from(el: super::browser_protocol::inspector::EventTargetCrashed) -> CdpEvent {
+            CdpEvent::InspectorTargetCrashed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::inspector::EventTargetReloadedAfterCrash
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::InspectorTargetReloadedAfterCrash(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::inspector::EventTargetReloadedAfterCrash> for CdpEvent {
+        fn from(el: super::browser_protocol::inspector::EventTargetReloadedAfterCrash) -> CdpEvent {
+            CdpEvent::InspectorTargetReloadedAfterCrash(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::inspector::EventWorkerScriptLoaded
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::InspectorWorkerScriptLoaded(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::inspector::EventWorkerScriptLoaded> for CdpEvent {
+        fn from(el: super::browser_protocol::inspector::EventWorkerScriptLoaded) -> CdpEvent {
+            CdpEvent::InspectorWorkerScriptLoaded(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::layer_tree::EventLayerPainted {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::LayerTreeLayerPainted(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::layer_tree::EventLayerPainted> for CdpEvent {
+        fn from(el: super::browser_protocol::layer_tree::EventLayerPainted) -> CdpEvent {
+            CdpEvent::LayerTreeLayerPainted(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::layer_tree::EventLayerTreeDidChange
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::LayerTreeLayerTreeDidChange(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::layer_tree::EventLayerTreeDidChange> for CdpEvent {
+        fn from(el: super::browser_protocol::layer_tree::EventLayerTreeDidChange) -> CdpEvent {
+            CdpEvent::LayerTreeLayerTreeDidChange(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::log::EventEntryAdded {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::LogEntryAdded(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::log::EventEntryAdded> for CdpEvent {
+        fn from(el: super::browser_protocol::log::EventEntryAdded) -> CdpEvent {
+            CdpEvent::LogEntryAdded(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::media::EventPlayerPropertiesChanged
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::MediaPlayerPropertiesChanged(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::media::EventPlayerPropertiesChanged> for CdpEvent {
+        fn from(el: super::browser_protocol::media::EventPlayerPropertiesChanged) -> CdpEvent {
+            CdpEvent::MediaPlayerPropertiesChanged(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::media::EventPlayerEventsAdded {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::MediaPlayerEventsAdded(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::media::EventPlayerEventsAdded> for CdpEvent {
+        fn from(el: super::browser_protocol::media::EventPlayerEventsAdded) -> CdpEvent {
+            CdpEvent::MediaPlayerEventsAdded(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::media::EventPlayerMessagesLogged {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::MediaPlayerMessagesLogged(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::media::EventPlayerMessagesLogged> for CdpEvent {
+        fn from(el: super::browser_protocol::media::EventPlayerMessagesLogged) -> CdpEvent {
+            CdpEvent::MediaPlayerMessagesLogged(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::media::EventPlayerErrorsRaised {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::MediaPlayerErrorsRaised(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::media::EventPlayerErrorsRaised> for CdpEvent {
+        fn from(el: super::browser_protocol::media::EventPlayerErrorsRaised) -> CdpEvent {
+            CdpEvent::MediaPlayerErrorsRaised(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::media::EventPlayerCreated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::MediaPlayerCreated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::media::EventPlayerCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::media::EventPlayerCreated) -> CdpEvent {
+            CdpEvent::MediaPlayerCreated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::network::EventDataReceived {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDataReceived(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDataReceived> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDataReceived) -> CdpEvent {
+            CdpEvent::NetworkDataReceived(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventEventSourceMessageReceived
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkEventSourceMessageReceived(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventEventSourceMessageReceived> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventEventSourceMessageReceived) -> CdpEvent {
+            CdpEvent::NetworkEventSourceMessageReceived(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::network::EventLoadingFailed {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkLoadingFailed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventLoadingFailed> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventLoadingFailed) -> CdpEvent {
+            CdpEvent::NetworkLoadingFailed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::network::EventLoadingFinished {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkLoadingFinished(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventLoadingFinished> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventLoadingFinished) -> CdpEvent {
+            CdpEvent::NetworkLoadingFinished(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventRequestServedFromCache
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkRequestServedFromCache(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventRequestServedFromCache> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventRequestServedFromCache) -> CdpEvent {
+            CdpEvent::NetworkRequestServedFromCache(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::network::EventRequestWillBeSent {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkRequestWillBeSent(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventRequestWillBeSent> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventRequestWillBeSent) -> CdpEvent {
+            CdpEvent::NetworkRequestWillBeSent(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventResourceChangedPriority
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkResourceChangedPriority(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventResourceChangedPriority> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventResourceChangedPriority) -> CdpEvent {
+            CdpEvent::NetworkResourceChangedPriority(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventSignedExchangeReceived
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkSignedExchangeReceived(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventSignedExchangeReceived> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventSignedExchangeReceived) -> CdpEvent {
+            CdpEvent::NetworkSignedExchangeReceived(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::network::EventResponseReceived {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkResponseReceived(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventResponseReceived> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventResponseReceived) -> CdpEvent {
+            CdpEvent::NetworkResponseReceived(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::network::EventWebSocketClosed {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkWebSocketClosed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventWebSocketClosed> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventWebSocketClosed) -> CdpEvent {
+            CdpEvent::NetworkWebSocketClosed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::network::EventWebSocketCreated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkWebSocketCreated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventWebSocketCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventWebSocketCreated) -> CdpEvent {
+            CdpEvent::NetworkWebSocketCreated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventWebSocketFrameError
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkWebSocketFrameError(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventWebSocketFrameError> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventWebSocketFrameError) -> CdpEvent {
+            CdpEvent::NetworkWebSocketFrameError(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventWebSocketFrameReceived
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkWebSocketFrameReceived(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventWebSocketFrameReceived> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventWebSocketFrameReceived) -> CdpEvent {
+            CdpEvent::NetworkWebSocketFrameReceived(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::network::EventWebSocketFrameSent {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkWebSocketFrameSent(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventWebSocketFrameSent> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventWebSocketFrameSent) -> CdpEvent {
+            CdpEvent::NetworkWebSocketFrameSent(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventWebSocketHandshakeResponseReceived
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkWebSocketHandshakeResponseReceived(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventWebSocketHandshakeResponseReceived> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::network::EventWebSocketHandshakeResponseReceived,
+        ) -> CdpEvent {
+            CdpEvent::NetworkWebSocketHandshakeResponseReceived(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventWebSocketWillSendHandshakeRequest
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkWebSocketWillSendHandshakeRequest(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventWebSocketWillSendHandshakeRequest> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::network::EventWebSocketWillSendHandshakeRequest,
+        ) -> CdpEvent {
+            CdpEvent::NetworkWebSocketWillSendHandshakeRequest(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventWebTransportCreated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkWebTransportCreated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventWebTransportCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventWebTransportCreated) -> CdpEvent {
+            CdpEvent::NetworkWebTransportCreated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventWebTransportConnectionEstablished
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkWebTransportConnectionEstablished(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventWebTransportConnectionEstablished> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::network::EventWebTransportConnectionEstablished,
+        ) -> CdpEvent {
+            CdpEvent::NetworkWebTransportConnectionEstablished(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::network::EventWebTransportClosed {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkWebTransportClosed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventWebTransportClosed> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventWebTransportClosed) -> CdpEvent {
+            CdpEvent::NetworkWebTransportClosed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectTcpSocketCreated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectTcpSocketCreated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectTcpSocketCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDirectTcpSocketCreated) -> CdpEvent {
+            CdpEvent::NetworkDirectTcpSocketCreated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectTcpSocketOpened
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectTcpSocketOpened(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectTcpSocketOpened> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDirectTcpSocketOpened) -> CdpEvent {
+            CdpEvent::NetworkDirectTcpSocketOpened(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectTcpSocketAborted
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectTcpSocketAborted(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectTcpSocketAborted> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDirectTcpSocketAborted) -> CdpEvent {
+            CdpEvent::NetworkDirectTcpSocketAborted(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectTcpSocketClosed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectTcpSocketClosed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectTcpSocketClosed> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDirectTcpSocketClosed) -> CdpEvent {
+            CdpEvent::NetworkDirectTcpSocketClosed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectTcpSocketChunkSent
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectTcpSocketChunkSent(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectTcpSocketChunkSent> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDirectTcpSocketChunkSent) -> CdpEvent {
+            CdpEvent::NetworkDirectTcpSocketChunkSent(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectTcpSocketChunkReceived
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectTcpSocketChunkReceived(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectTcpSocketChunkReceived> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::network::EventDirectTcpSocketChunkReceived,
+        ) -> CdpEvent {
+            CdpEvent::NetworkDirectTcpSocketChunkReceived(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectUdpSocketJoinedMulticastGroup
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectUdpSocketJoinedMulticastGroup(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectUdpSocketJoinedMulticastGroup> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::network::EventDirectUdpSocketJoinedMulticastGroup,
+        ) -> CdpEvent {
+            CdpEvent::NetworkDirectUdpSocketJoinedMulticastGroup(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectUdpSocketLeftMulticastGroup
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectUdpSocketLeftMulticastGroup(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectUdpSocketLeftMulticastGroup> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::network::EventDirectUdpSocketLeftMulticastGroup,
+        ) -> CdpEvent {
+            CdpEvent::NetworkDirectUdpSocketLeftMulticastGroup(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectUdpSocketCreated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectUdpSocketCreated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectUdpSocketCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDirectUdpSocketCreated) -> CdpEvent {
+            CdpEvent::NetworkDirectUdpSocketCreated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectUdpSocketOpened
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectUdpSocketOpened(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectUdpSocketOpened> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDirectUdpSocketOpened) -> CdpEvent {
+            CdpEvent::NetworkDirectUdpSocketOpened(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectUdpSocketAborted
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectUdpSocketAborted(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectUdpSocketAborted> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDirectUdpSocketAborted) -> CdpEvent {
+            CdpEvent::NetworkDirectUdpSocketAborted(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectUdpSocketClosed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectUdpSocketClosed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectUdpSocketClosed> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDirectUdpSocketClosed) -> CdpEvent {
+            CdpEvent::NetworkDirectUdpSocketClosed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectUdpSocketChunkSent
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectUdpSocketChunkSent(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectUdpSocketChunkSent> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDirectUdpSocketChunkSent) -> CdpEvent {
+            CdpEvent::NetworkDirectUdpSocketChunkSent(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDirectUdpSocketChunkReceived
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDirectUdpSocketChunkReceived(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDirectUdpSocketChunkReceived> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::network::EventDirectUdpSocketChunkReceived,
+        ) -> CdpEvent {
+            CdpEvent::NetworkDirectUdpSocketChunkReceived(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventRequestWillBeSentExtraInfo
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkRequestWillBeSentExtraInfo(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventRequestWillBeSentExtraInfo> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventRequestWillBeSentExtraInfo) -> CdpEvent {
+            CdpEvent::NetworkRequestWillBeSentExtraInfo(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventResponseReceivedExtraInfo
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkResponseReceivedExtraInfo(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventResponseReceivedExtraInfo> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventResponseReceivedExtraInfo) -> CdpEvent {
+            CdpEvent::NetworkResponseReceivedExtraInfo(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventResponseReceivedEarlyHints
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkResponseReceivedEarlyHints(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventResponseReceivedEarlyHints> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventResponseReceivedEarlyHints) -> CdpEvent {
+            CdpEvent::NetworkResponseReceivedEarlyHints(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventTrustTokenOperationDone
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkTrustTokenOperationDone(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventTrustTokenOperationDone> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventTrustTokenOperationDone) -> CdpEvent {
+            CdpEvent::NetworkTrustTokenOperationDone(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::network::EventPolicyUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkPolicyUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventPolicyUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventPolicyUpdated) -> CdpEvent {
+            CdpEvent::NetworkPolicyUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventReportingApiReportAdded
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkReportingApiReportAdded(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventReportingApiReportAdded> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventReportingApiReportAdded) -> CdpEvent {
+            CdpEvent::NetworkReportingApiReportAdded(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventReportingApiReportUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkReportingApiReportUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventReportingApiReportUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventReportingApiReportUpdated) -> CdpEvent {
+            CdpEvent::NetworkReportingApiReportUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventReportingApiEndpointsChangedForOrigin
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkReportingApiEndpointsChangedForOrigin(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventReportingApiEndpointsChangedForOrigin>
+        for CdpEvent
+    {
+        fn from(
+            el: super::browser_protocol::network::EventReportingApiEndpointsChangedForOrigin,
+        ) -> CdpEvent {
+            CdpEvent::NetworkReportingApiEndpointsChangedForOrigin(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDeviceBoundSessionsAdded
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDeviceBoundSessionsAdded(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDeviceBoundSessionsAdded> for CdpEvent {
+        fn from(el: super::browser_protocol::network::EventDeviceBoundSessionsAdded) -> CdpEvent {
+            CdpEvent::NetworkDeviceBoundSessionsAdded(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::network::EventDeviceBoundSessionEventOccurred
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::NetworkDeviceBoundSessionEventOccurred(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::network::EventDeviceBoundSessionEventOccurred> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::network::EventDeviceBoundSessionEventOccurred,
+        ) -> CdpEvent {
+            CdpEvent::NetworkDeviceBoundSessionEventOccurred(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::overlay::EventInspectNodeRequested
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::OverlayInspectNodeRequested(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::overlay::EventInspectNodeRequested> for CdpEvent {
+        fn from(el: super::browser_protocol::overlay::EventInspectNodeRequested) -> CdpEvent {
+            CdpEvent::OverlayInspectNodeRequested(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::overlay::EventNodeHighlightRequested
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::OverlayNodeHighlightRequested(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::overlay::EventNodeHighlightRequested> for CdpEvent {
+        fn from(el: super::browser_protocol::overlay::EventNodeHighlightRequested) -> CdpEvent {
+            CdpEvent::OverlayNodeHighlightRequested(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::overlay::EventScreenshotRequested
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::OverlayScreenshotRequested(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::overlay::EventScreenshotRequested> for CdpEvent {
+        fn from(el: super::browser_protocol::overlay::EventScreenshotRequested) -> CdpEvent {
+            CdpEvent::OverlayScreenshotRequested(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::overlay::EventInspectModeCanceled
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::OverlayInspectModeCanceled(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::overlay::EventInspectModeCanceled> for CdpEvent {
+        fn from(el: super::browser_protocol::overlay::EventInspectModeCanceled) -> CdpEvent {
+            CdpEvent::OverlayInspectModeCanceled(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventDomContentEventFired {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageDomContentEventFired(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventDomContentEventFired> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventDomContentEventFired) -> CdpEvent {
+            CdpEvent::PageDomContentEventFired(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventFileChooserOpened {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageFileChooserOpened(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventFileChooserOpened> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventFileChooserOpened) -> CdpEvent {
+            CdpEvent::PageFileChooserOpened(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventFrameAttached {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageFrameAttached(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventFrameAttached> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventFrameAttached) -> CdpEvent {
+            CdpEvent::PageFrameAttached(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventFrameDetached {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageFrameDetached(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventFrameDetached> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventFrameDetached) -> CdpEvent {
+            CdpEvent::PageFrameDetached(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::page::EventFrameSubtreeWillBeDetached
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageFrameSubtreeWillBeDetached(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventFrameSubtreeWillBeDetached> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventFrameSubtreeWillBeDetached) -> CdpEvent {
+            CdpEvent::PageFrameSubtreeWillBeDetached(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventFrameNavigated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageFrameNavigated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventFrameNavigated> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventFrameNavigated) -> CdpEvent {
+            CdpEvent::PageFrameNavigated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventDocumentOpened {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageDocumentOpened(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventDocumentOpened> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventDocumentOpened) -> CdpEvent {
+            CdpEvent::PageDocumentOpened(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventFrameResized {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageFrameResized(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventFrameResized> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventFrameResized) -> CdpEvent {
+            CdpEvent::PageFrameResized(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::page::EventFrameStartedNavigating
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageFrameStartedNavigating(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventFrameStartedNavigating> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventFrameStartedNavigating) -> CdpEvent {
+            CdpEvent::PageFrameStartedNavigating(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::page::EventFrameRequestedNavigation
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageFrameRequestedNavigation(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventFrameRequestedNavigation> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventFrameRequestedNavigation) -> CdpEvent {
+            CdpEvent::PageFrameRequestedNavigation(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventFrameStartedLoading {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageFrameStartedLoading(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventFrameStartedLoading> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventFrameStartedLoading) -> CdpEvent {
+            CdpEvent::PageFrameStartedLoading(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventFrameStoppedLoading {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageFrameStoppedLoading(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventFrameStoppedLoading> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventFrameStoppedLoading) -> CdpEvent {
+            CdpEvent::PageFrameStoppedLoading(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventInterstitialHidden {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageInterstitialHidden(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventInterstitialHidden> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventInterstitialHidden) -> CdpEvent {
+            CdpEvent::PageInterstitialHidden(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventInterstitialShown {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageInterstitialShown(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventInterstitialShown> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventInterstitialShown) -> CdpEvent {
+            CdpEvent::PageInterstitialShown(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::page::EventJavascriptDialogClosed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageJavascriptDialogClosed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventJavascriptDialogClosed> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventJavascriptDialogClosed) -> CdpEvent {
+            CdpEvent::PageJavascriptDialogClosed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::page::EventJavascriptDialogOpening
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageJavascriptDialogOpening(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventJavascriptDialogOpening> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventJavascriptDialogOpening) -> CdpEvent {
+            CdpEvent::PageJavascriptDialogOpening(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventLifecycleEvent {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageLifecycleEvent(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventLifecycleEvent> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventLifecycleEvent) -> CdpEvent {
+            CdpEvent::PageLifecycleEvent(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::page::EventBackForwardCacheNotUsed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageBackForwardCacheNotUsed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventBackForwardCacheNotUsed> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventBackForwardCacheNotUsed) -> CdpEvent {
+            CdpEvent::PageBackForwardCacheNotUsed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventLoadEventFired {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageLoadEventFired(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventLoadEventFired> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventLoadEventFired) -> CdpEvent {
+            CdpEvent::PageLoadEventFired(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::page::EventNavigatedWithinDocument
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageNavigatedWithinDocument(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventNavigatedWithinDocument> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventNavigatedWithinDocument) -> CdpEvent {
+            CdpEvent::PageNavigatedWithinDocument(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventScreencastFrame {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageScreencastFrame(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventScreencastFrame> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventScreencastFrame) -> CdpEvent {
+            CdpEvent::PageScreencastFrame(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::page::EventScreencastVisibilityChanged
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageScreencastVisibilityChanged(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventScreencastVisibilityChanged> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventScreencastVisibilityChanged) -> CdpEvent {
+            CdpEvent::PageScreencastVisibilityChanged(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::page::EventWindowOpen {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageWindowOpen(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventWindowOpen> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventWindowOpen) -> CdpEvent {
+            CdpEvent::PageWindowOpen(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::page::EventCompilationCacheProduced
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PageCompilationCacheProduced(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::page::EventCompilationCacheProduced> for CdpEvent {
+        fn from(el: super::browser_protocol::page::EventCompilationCacheProduced) -> CdpEvent {
+            CdpEvent::PageCompilationCacheProduced(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::performance::EventMetrics {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PerformanceMetrics(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::performance::EventMetrics> for CdpEvent {
+        fn from(el: super::browser_protocol::performance::EventMetrics) -> CdpEvent {
+            CdpEvent::PerformanceMetrics(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::performance_timeline::EventTimelineEventAdded
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PerformanceTimelineTimelineEventAdded(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::performance_timeline::EventTimelineEventAdded> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::performance_timeline::EventTimelineEventAdded,
+        ) -> CdpEvent {
+            CdpEvent::PerformanceTimelineTimelineEventAdded(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::preload::EventRuleSetUpdated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PreloadRuleSetUpdated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::preload::EventRuleSetUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::preload::EventRuleSetUpdated) -> CdpEvent {
+            CdpEvent::PreloadRuleSetUpdated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::preload::EventRuleSetRemoved {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PreloadRuleSetRemoved(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::preload::EventRuleSetRemoved> for CdpEvent {
+        fn from(el: super::browser_protocol::preload::EventRuleSetRemoved) -> CdpEvent {
+            CdpEvent::PreloadRuleSetRemoved(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::preload::EventPreloadEnabledStateUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PreloadPreloadEnabledStateUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::preload::EventPreloadEnabledStateUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::preload::EventPreloadEnabledStateUpdated) -> CdpEvent {
+            CdpEvent::PreloadPreloadEnabledStateUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::preload::EventPrefetchStatusUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PreloadPrefetchStatusUpdated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::preload::EventPrefetchStatusUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::preload::EventPrefetchStatusUpdated) -> CdpEvent {
+            CdpEvent::PreloadPrefetchStatusUpdated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::preload::EventPrerenderStatusUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PreloadPrerenderStatusUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::preload::EventPrerenderStatusUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::preload::EventPrerenderStatusUpdated) -> CdpEvent {
+            CdpEvent::PreloadPrerenderStatusUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::preload::EventPreloadingAttemptSourcesUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::PreloadPreloadingAttemptSourcesUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::preload::EventPreloadingAttemptSourcesUpdated> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::preload::EventPreloadingAttemptSourcesUpdated,
+        ) -> CdpEvent {
+            CdpEvent::PreloadPreloadingAttemptSourcesUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::security::EventVisibleSecurityStateChanged
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::SecurityVisibleSecurityStateChanged(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::security::EventVisibleSecurityStateChanged> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::security::EventVisibleSecurityStateChanged,
+        ) -> CdpEvent {
+            CdpEvent::SecurityVisibleSecurityStateChanged(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::service_worker::EventWorkerErrorReported
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::ServiceWorkerWorkerErrorReported(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::service_worker::EventWorkerErrorReported> for CdpEvent {
+        fn from(el: super::browser_protocol::service_worker::EventWorkerErrorReported) -> CdpEvent {
+            CdpEvent::ServiceWorkerWorkerErrorReported(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::service_worker::EventWorkerRegistrationUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::ServiceWorkerWorkerRegistrationUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::service_worker::EventWorkerRegistrationUpdated> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::service_worker::EventWorkerRegistrationUpdated,
+        ) -> CdpEvent {
+            CdpEvent::ServiceWorkerWorkerRegistrationUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::service_worker::EventWorkerVersionUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::ServiceWorkerWorkerVersionUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::service_worker::EventWorkerVersionUpdated> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::service_worker::EventWorkerVersionUpdated,
+        ) -> CdpEvent {
+            CdpEvent::ServiceWorkerWorkerVersionUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventCacheStorageContentUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageCacheStorageContentUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventCacheStorageContentUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::storage::EventCacheStorageContentUpdated) -> CdpEvent {
+            CdpEvent::StorageCacheStorageContentUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventCacheStorageListUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageCacheStorageListUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventCacheStorageListUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::storage::EventCacheStorageListUpdated) -> CdpEvent {
+            CdpEvent::StorageCacheStorageListUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventIndexedDbContentUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageIndexedDbContentUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventIndexedDbContentUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::storage::EventIndexedDbContentUpdated) -> CdpEvent {
+            CdpEvent::StorageIndexedDbContentUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventIndexedDbListUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageIndexedDbListUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventIndexedDbListUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::storage::EventIndexedDbListUpdated) -> CdpEvent {
+            CdpEvent::StorageIndexedDbListUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventInterestGroupAccessed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageInterestGroupAccessed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventInterestGroupAccessed> for CdpEvent {
+        fn from(el: super::browser_protocol::storage::EventInterestGroupAccessed) -> CdpEvent {
+            CdpEvent::StorageInterestGroupAccessed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventInterestGroupAuctionEventOccurred
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageInterestGroupAuctionEventOccurred(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventInterestGroupAuctionEventOccurred> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::storage::EventInterestGroupAuctionEventOccurred,
+        ) -> CdpEvent {
+            CdpEvent::StorageInterestGroupAuctionEventOccurred(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventInterestGroupAuctionNetworkRequestCreated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageInterestGroupAuctionNetworkRequestCreated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventInterestGroupAuctionNetworkRequestCreated>
+        for CdpEvent
+    {
+        fn from(
+            el: super::browser_protocol::storage::EventInterestGroupAuctionNetworkRequestCreated,
+        ) -> CdpEvent {
+            CdpEvent::StorageInterestGroupAuctionNetworkRequestCreated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventSharedStorageAccessed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageSharedStorageAccessed(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventSharedStorageAccessed> for CdpEvent {
+        fn from(el: super::browser_protocol::storage::EventSharedStorageAccessed) -> CdpEvent {
+            CdpEvent::StorageSharedStorageAccessed(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventSharedStorageWorkletOperationExecutionFinished
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageSharedStorageWorkletOperationExecutionFinished(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventSharedStorageWorkletOperationExecutionFinished>
+        for CdpEvent
+    {
+        fn from(
+            el : super :: browser_protocol :: storage :: EventSharedStorageWorkletOperationExecutionFinished,
+        ) -> CdpEvent {
+            CdpEvent::StorageSharedStorageWorkletOperationExecutionFinished(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventStorageBucketCreatedOrUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageStorageBucketCreatedOrUpdated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventStorageBucketCreatedOrUpdated> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::storage::EventStorageBucketCreatedOrUpdated,
+        ) -> CdpEvent {
+            CdpEvent::StorageStorageBucketCreatedOrUpdated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventStorageBucketDeleted
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageStorageBucketDeleted(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventStorageBucketDeleted> for CdpEvent {
+        fn from(el: super::browser_protocol::storage::EventStorageBucketDeleted) -> CdpEvent {
+            CdpEvent::StorageStorageBucketDeleted(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventAttributionReportingSourceRegistered
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageAttributionReportingSourceRegistered(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventAttributionReportingSourceRegistered>
+        for CdpEvent
+    {
+        fn from(
+            el: super::browser_protocol::storage::EventAttributionReportingSourceRegistered,
+        ) -> CdpEvent {
+            CdpEvent::StorageAttributionReportingSourceRegistered(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventAttributionReportingTriggerRegistered
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageAttributionReportingTriggerRegistered(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventAttributionReportingTriggerRegistered>
+        for CdpEvent
+    {
+        fn from(
+            el: super::browser_protocol::storage::EventAttributionReportingTriggerRegistered,
+        ) -> CdpEvent {
+            CdpEvent::StorageAttributionReportingTriggerRegistered(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventAttributionReportingReportSent
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageAttributionReportingReportSent(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventAttributionReportingReportSent> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::storage::EventAttributionReportingReportSent,
+        ) -> CdpEvent {
+            CdpEvent::StorageAttributionReportingReportSent(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::storage::EventAttributionReportingVerboseDebugReportSent
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::StorageAttributionReportingVerboseDebugReportSent(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::storage::EventAttributionReportingVerboseDebugReportSent>
+        for CdpEvent
+    {
+        fn from(
+            el: super::browser_protocol::storage::EventAttributionReportingVerboseDebugReportSent,
+        ) -> CdpEvent {
+            CdpEvent::StorageAttributionReportingVerboseDebugReportSent(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::target::EventAttachedToTarget {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TargetAttachedToTarget(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::target::EventAttachedToTarget> for CdpEvent {
+        fn from(el: super::browser_protocol::target::EventAttachedToTarget) -> CdpEvent {
+            CdpEvent::TargetAttachedToTarget(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::target::EventDetachedFromTarget {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TargetDetachedFromTarget(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::target::EventDetachedFromTarget> for CdpEvent {
+        fn from(el: super::browser_protocol::target::EventDetachedFromTarget) -> CdpEvent {
+            CdpEvent::TargetDetachedFromTarget(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::target::EventReceivedMessageFromTarget
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TargetReceivedMessageFromTarget(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::target::EventReceivedMessageFromTarget> for CdpEvent {
+        fn from(el: super::browser_protocol::target::EventReceivedMessageFromTarget) -> CdpEvent {
+            CdpEvent::TargetReceivedMessageFromTarget(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::target::EventTargetCreated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TargetTargetCreated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::target::EventTargetCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::target::EventTargetCreated) -> CdpEvent {
+            CdpEvent::TargetTargetCreated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::target::EventTargetDestroyed {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TargetTargetDestroyed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::target::EventTargetDestroyed> for CdpEvent {
+        fn from(el: super::browser_protocol::target::EventTargetDestroyed) -> CdpEvent {
+            CdpEvent::TargetTargetDestroyed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::target::EventTargetCrashed {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TargetTargetCrashed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::target::EventTargetCrashed> for CdpEvent {
+        fn from(el: super::browser_protocol::target::EventTargetCrashed) -> CdpEvent {
+            CdpEvent::TargetTargetCrashed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::target::EventTargetInfoChanged {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TargetTargetInfoChanged(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::target::EventTargetInfoChanged> for CdpEvent {
+        fn from(el: super::browser_protocol::target::EventTargetInfoChanged) -> CdpEvent {
+            CdpEvent::TargetTargetInfoChanged(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::tethering::EventAccepted {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TetheringAccepted(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::tethering::EventAccepted> for CdpEvent {
+        fn from(el: super::browser_protocol::tethering::EventAccepted) -> CdpEvent {
+            CdpEvent::TetheringAccepted(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::tracing::EventBufferUsage {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TracingBufferUsage(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::tracing::EventBufferUsage> for CdpEvent {
+        fn from(el: super::browser_protocol::tracing::EventBufferUsage) -> CdpEvent {
+            CdpEvent::TracingBufferUsage(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::tracing::EventDataCollected {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TracingDataCollected(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::tracing::EventDataCollected> for CdpEvent {
+        fn from(el: super::browser_protocol::tracing::EventDataCollected) -> CdpEvent {
+            CdpEvent::TracingDataCollected(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::tracing::EventTracingComplete {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::TracingTracingComplete(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::tracing::EventTracingComplete> for CdpEvent {
+        fn from(el: super::browser_protocol::tracing::EventTracingComplete) -> CdpEvent {
+            CdpEvent::TracingTracingComplete(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::web_audio::EventContextCreated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioContextCreated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventContextCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventContextCreated) -> CdpEvent {
+            CdpEvent::WebAudioContextCreated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_audio::EventContextWillBeDestroyed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioContextWillBeDestroyed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventContextWillBeDestroyed> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventContextWillBeDestroyed) -> CdpEvent {
+            CdpEvent::WebAudioContextWillBeDestroyed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::web_audio::EventContextChanged {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioContextChanged(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventContextChanged> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventContextChanged) -> CdpEvent {
+            CdpEvent::WebAudioContextChanged(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_audio::EventAudioListenerCreated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioAudioListenerCreated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventAudioListenerCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventAudioListenerCreated) -> CdpEvent {
+            CdpEvent::WebAudioAudioListenerCreated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_audio::EventAudioListenerWillBeDestroyed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioAudioListenerWillBeDestroyed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventAudioListenerWillBeDestroyed> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::web_audio::EventAudioListenerWillBeDestroyed,
+        ) -> CdpEvent {
+            CdpEvent::WebAudioAudioListenerWillBeDestroyed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::web_audio::EventAudioNodeCreated {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioAudioNodeCreated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventAudioNodeCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventAudioNodeCreated) -> CdpEvent {
+            CdpEvent::WebAudioAudioNodeCreated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_audio::EventAudioNodeWillBeDestroyed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioAudioNodeWillBeDestroyed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventAudioNodeWillBeDestroyed> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventAudioNodeWillBeDestroyed) -> CdpEvent {
+            CdpEvent::WebAudioAudioNodeWillBeDestroyed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_audio::EventAudioParamCreated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioAudioParamCreated(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventAudioParamCreated> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventAudioParamCreated) -> CdpEvent {
+            CdpEvent::WebAudioAudioParamCreated(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_audio::EventAudioParamWillBeDestroyed
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioAudioParamWillBeDestroyed(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventAudioParamWillBeDestroyed> for CdpEvent {
+        fn from(
+            el: super::browser_protocol::web_audio::EventAudioParamWillBeDestroyed,
+        ) -> CdpEvent {
+            CdpEvent::WebAudioAudioParamWillBeDestroyed(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::web_audio::EventNodesConnected {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioNodesConnected(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventNodesConnected> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventNodesConnected) -> CdpEvent {
+            CdpEvent::WebAudioNodesConnected(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_audio::EventNodesDisconnected
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioNodesDisconnected(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventNodesDisconnected> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventNodesDisconnected) -> CdpEvent {
+            CdpEvent::WebAudioNodesDisconnected(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_audio::EventNodeParamConnected
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioNodeParamConnected(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventNodeParamConnected> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventNodeParamConnected) -> CdpEvent {
+            CdpEvent::WebAudioNodeParamConnected(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_audio::EventNodeParamDisconnected
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAudioNodeParamDisconnected(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_audio::EventNodeParamDisconnected> for CdpEvent {
+        fn from(el: super::browser_protocol::web_audio::EventNodeParamDisconnected) -> CdpEvent {
+            CdpEvent::WebAudioNodeParamDisconnected(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent> for super::browser_protocol::web_authn::EventCredentialAdded {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAuthnCredentialAdded(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_authn::EventCredentialAdded> for CdpEvent {
+        fn from(el: super::browser_protocol::web_authn::EventCredentialAdded) -> CdpEvent {
+            CdpEvent::WebAuthnCredentialAdded(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_authn::EventCredentialDeleted
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAuthnCredentialDeleted(val) => Ok(val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_authn::EventCredentialDeleted> for CdpEvent {
+        fn from(el: super::browser_protocol::web_authn::EventCredentialDeleted) -> CdpEvent {
+            CdpEvent::WebAuthnCredentialDeleted(el)
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_authn::EventCredentialUpdated
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAuthnCredentialUpdated(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_authn::EventCredentialUpdated> for CdpEvent {
+        fn from(el: super::browser_protocol::web_authn::EventCredentialUpdated) -> CdpEvent {
+            CdpEvent::WebAuthnCredentialUpdated(Box::new(el))
+        }
+    }
+    impl std::convert::TryFrom<CdpEvent>
+        for super::browser_protocol::web_authn::EventCredentialAsserted
+    {
+        type Error = CdpEvent;
+        fn try_from(event: CdpEvent) -> Result<Self, Self::Error> {
+            match event {
+                CdpEvent::WebAuthnCredentialAsserted(val) => Ok(*val),
+                _ => Err(event),
+            }
+        }
+    }
+    impl From<super::browser_protocol::web_authn::EventCredentialAsserted> for CdpEvent {
+        fn from(el: super::browser_protocol::web_authn::EventCredentialAsserted) -> CdpEvent {
+            CdpEvent::WebAuthnCredentialAsserted(Box::new(el))
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::debugger::EventPaused {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::debugger::EventPaused {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::debugger::EventResumed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::debugger::EventResumed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::debugger::EventScriptFailedToParse {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::debugger::EventScriptFailedToParse {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::debugger::EventScriptParsed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::debugger::EventScriptParsed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::heap_profiler::EventAddHeapSnapshotChunk {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::heap_profiler::EventAddHeapSnapshotChunk {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::heap_profiler::EventHeapStatsUpdate {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::heap_profiler::EventHeapStatsUpdate {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::heap_profiler::EventLastSeenObjectId {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::heap_profiler::EventLastSeenObjectId {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::js_protocol::heap_profiler::EventReportHeapSnapshotProgress
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::heap_profiler::EventReportHeapSnapshotProgress {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::heap_profiler::EventResetProfiles {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::heap_profiler::EventResetProfiles {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::profiler::EventConsoleProfileFinished {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::profiler::EventConsoleProfileFinished {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::profiler::EventConsoleProfileStarted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::profiler::EventConsoleProfileStarted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::profiler::EventPreciseCoverageDeltaUpdate {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::profiler::EventPreciseCoverageDeltaUpdate {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::runtime::EventBindingCalled {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::runtime::EventBindingCalled {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::runtime::EventConsoleApiCalled {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::runtime::EventConsoleApiCalled {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::runtime::EventExceptionRevoked {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::runtime::EventExceptionRevoked {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::runtime::EventExceptionThrown {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::runtime::EventExceptionThrown {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::runtime::EventExecutionContextCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::runtime::EventExecutionContextCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::runtime::EventExecutionContextDestroyed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::runtime::EventExecutionContextDestroyed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::runtime::EventExecutionContextsCleared {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::runtime::EventExecutionContextsCleared {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::js_protocol::runtime::EventInspectRequested {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::js_protocol::runtime::EventInspectRequested {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::accessibility::EventLoadComplete {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::accessibility::EventLoadComplete {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::accessibility::EventNodesUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::accessibility::EventNodesUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::animation::EventAnimationCanceled {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::animation::EventAnimationCanceled {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::animation::EventAnimationCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::animation::EventAnimationCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::animation::EventAnimationStarted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::animation::EventAnimationStarted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::animation::EventAnimationUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::animation::EventAnimationUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::audits::EventIssueAdded {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::audits::EventIssueAdded {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::autofill::EventAddressFormFilled {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::autofill::EventAddressFormFilled {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::background_service::EventRecordingStateChanged
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::background_service::EventRecordingStateChanged
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::background_service::EventBackgroundServiceEventReceived
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::background_service::EventBackgroundServiceEventReceived
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::bluetooth_emulation::EventGattOperationReceived
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::bluetooth_emulation::EventGattOperationReceived
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::bluetooth_emulation::EventCharacteristicOperationReceived
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::bluetooth_emulation::EventCharacteristicOperationReceived
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::bluetooth_emulation::EventDescriptorOperationReceived
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::bluetooth_emulation::EventDescriptorOperationReceived
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::browser::EventDownloadWillBegin {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::browser::EventDownloadWillBegin {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::browser::EventDownloadProgress {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::browser::EventDownloadProgress {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::css::EventFontsUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::css::EventFontsUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::css::EventMediaQueryResultChanged {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::css::EventMediaQueryResultChanged {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::css::EventStyleSheetAdded {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::css::EventStyleSheetAdded {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::css::EventStyleSheetChanged {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::css::EventStyleSheetChanged {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::css::EventStyleSheetRemoved {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::css::EventStyleSheetRemoved {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::css::EventComputedStyleUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::css::EventComputedStyleUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::cast::EventSinksUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::cast::EventSinksUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::cast::EventIssueUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::cast::EventIssueUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventAttributeModified {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventAttributeModified {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventAdoptedStyleSheetsModified {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventAdoptedStyleSheetsModified {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventAttributeRemoved {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventAttributeRemoved {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventCharacterDataModified {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventCharacterDataModified {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventChildNodeCountUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventChildNodeCountUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventChildNodeInserted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventChildNodeInserted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventChildNodeRemoved {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventChildNodeRemoved {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventDistributedNodesUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventDistributedNodesUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventDocumentUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventDocumentUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventInlineStyleInvalidated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventInlineStyleInvalidated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventPseudoElementAdded {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventPseudoElementAdded {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventTopLayerElementsUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventTopLayerElementsUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventScrollableFlagUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventScrollableFlagUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::dom::EventAffectedByStartingStylesFlagUpdated
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::dom::EventAffectedByStartingStylesFlagUpdated
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventPseudoElementRemoved {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventPseudoElementRemoved {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventSetChildNodes {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventSetChildNodes {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventShadowRootPopped {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventShadowRootPopped {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom::EventShadowRootPushed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom::EventShadowRootPushed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::dom_storage::EventDomStorageItemAdded {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom_storage::EventDomStorageItemAdded {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::dom_storage::EventDomStorageItemRemoved
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom_storage::EventDomStorageItemRemoved {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::dom_storage::EventDomStorageItemUpdated
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom_storage::EventDomStorageItemUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::dom_storage::EventDomStorageItemsCleared
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::dom_storage::EventDomStorageItemsCleared {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::device_access::EventDeviceRequestPrompted
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::device_access::EventDeviceRequestPrompted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::emulation::EventVirtualTimeBudgetExpired
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::emulation::EventVirtualTimeBudgetExpired {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::fed_cm::EventDialogShown {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::fed_cm::EventDialogShown {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::fed_cm::EventDialogClosed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::fed_cm::EventDialogClosed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::fetch::EventRequestPaused {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::fetch::EventRequestPaused {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::fetch::EventAuthRequired {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::fetch::EventAuthRequired {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::input::EventDragIntercepted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::input::EventDragIntercepted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::inspector::EventDetached {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::inspector::EventDetached {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::inspector::EventTargetCrashed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::inspector::EventTargetCrashed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::inspector::EventTargetReloadedAfterCrash
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::inspector::EventTargetReloadedAfterCrash {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::inspector::EventWorkerScriptLoaded {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::inspector::EventWorkerScriptLoaded {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::layer_tree::EventLayerPainted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::layer_tree::EventLayerPainted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::layer_tree::EventLayerTreeDidChange {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::layer_tree::EventLayerTreeDidChange {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::log::EventEntryAdded {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::log::EventEntryAdded {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::media::EventPlayerPropertiesChanged {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::media::EventPlayerPropertiesChanged {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::media::EventPlayerEventsAdded {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::media::EventPlayerEventsAdded {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::media::EventPlayerMessagesLogged {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::media::EventPlayerMessagesLogged {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::media::EventPlayerErrorsRaised {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::media::EventPlayerErrorsRaised {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::media::EventPlayerCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::media::EventPlayerCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventDataReceived {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDataReceived {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventEventSourceMessageReceived
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventEventSourceMessageReceived {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventLoadingFailed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventLoadingFailed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventLoadingFinished {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventLoadingFinished {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventRequestServedFromCache {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventRequestServedFromCache {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventRequestWillBeSent {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventRequestWillBeSent {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventResourceChangedPriority {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventResourceChangedPriority {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventSignedExchangeReceived {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventSignedExchangeReceived {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventResponseReceived {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventResponseReceived {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventWebSocketClosed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventWebSocketClosed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventWebSocketCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventWebSocketCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventWebSocketFrameError {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventWebSocketFrameError {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventWebSocketFrameReceived {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventWebSocketFrameReceived {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventWebSocketFrameSent {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventWebSocketFrameSent {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventWebSocketHandshakeResponseReceived
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::network::EventWebSocketHandshakeResponseReceived
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventWebSocketWillSendHandshakeRequest
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::network::EventWebSocketWillSendHandshakeRequest
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventWebTransportCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventWebTransportCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventWebTransportConnectionEstablished
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::network::EventWebTransportConnectionEstablished
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventWebTransportClosed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventWebTransportClosed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventDirectTcpSocketCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectTcpSocketCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventDirectTcpSocketOpened {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectTcpSocketOpened {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventDirectTcpSocketAborted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectTcpSocketAborted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventDirectTcpSocketClosed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectTcpSocketClosed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventDirectTcpSocketChunkSent
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectTcpSocketChunkSent {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventDirectTcpSocketChunkReceived
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectTcpSocketChunkReceived {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventDirectUdpSocketJoinedMulticastGroup
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::network::EventDirectUdpSocketJoinedMulticastGroup
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventDirectUdpSocketLeftMulticastGroup
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::network::EventDirectUdpSocketLeftMulticastGroup
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventDirectUdpSocketCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectUdpSocketCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventDirectUdpSocketOpened {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectUdpSocketOpened {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventDirectUdpSocketAborted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectUdpSocketAborted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventDirectUdpSocketClosed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectUdpSocketClosed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventDirectUdpSocketChunkSent
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectUdpSocketChunkSent {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventDirectUdpSocketChunkReceived
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDirectUdpSocketChunkReceived {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventRequestWillBeSentExtraInfo
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventRequestWillBeSentExtraInfo {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventResponseReceivedExtraInfo
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventResponseReceivedExtraInfo {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventResponseReceivedEarlyHints
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventResponseReceivedEarlyHints {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventTrustTokenOperationDone {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventTrustTokenOperationDone {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventPolicyUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventPolicyUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::network::EventReportingApiReportAdded {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventReportingApiReportAdded {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventReportingApiReportUpdated
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventReportingApiReportUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventReportingApiEndpointsChangedForOrigin
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::network::EventReportingApiEndpointsChangedForOrigin
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventDeviceBoundSessionsAdded
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::network::EventDeviceBoundSessionsAdded {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::network::EventDeviceBoundSessionEventOccurred
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::network::EventDeviceBoundSessionEventOccurred
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::overlay::EventInspectNodeRequested {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::overlay::EventInspectNodeRequested {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::overlay::EventNodeHighlightRequested {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::overlay::EventNodeHighlightRequested {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::overlay::EventScreenshotRequested {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::overlay::EventScreenshotRequested {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::overlay::EventInspectModeCanceled {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::overlay::EventInspectModeCanceled {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventDomContentEventFired {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventDomContentEventFired {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventFileChooserOpened {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventFileChooserOpened {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventFrameAttached {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventFrameAttached {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventFrameDetached {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventFrameDetached {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventFrameSubtreeWillBeDetached {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventFrameSubtreeWillBeDetached {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventFrameNavigated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventFrameNavigated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventDocumentOpened {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventDocumentOpened {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventFrameResized {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventFrameResized {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventFrameStartedNavigating {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventFrameStartedNavigating {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventFrameRequestedNavigation {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventFrameRequestedNavigation {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventFrameStartedLoading {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventFrameStartedLoading {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventFrameStoppedLoading {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventFrameStoppedLoading {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventInterstitialHidden {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventInterstitialHidden {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventInterstitialShown {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventInterstitialShown {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventJavascriptDialogClosed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventJavascriptDialogClosed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventJavascriptDialogOpening {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventJavascriptDialogOpening {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventLifecycleEvent {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventLifecycleEvent {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventBackForwardCacheNotUsed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventBackForwardCacheNotUsed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventLoadEventFired {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventLoadEventFired {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventNavigatedWithinDocument {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventNavigatedWithinDocument {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventScreencastFrame {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventScreencastFrame {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::page::EventScreencastVisibilityChanged
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventScreencastVisibilityChanged {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventWindowOpen {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventWindowOpen {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::page::EventCompilationCacheProduced {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::page::EventCompilationCacheProduced {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::performance::EventMetrics {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::performance::EventMetrics {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::performance_timeline::EventTimelineEventAdded
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::performance_timeline::EventTimelineEventAdded
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::preload::EventRuleSetUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::preload::EventRuleSetUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::preload::EventRuleSetRemoved {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::preload::EventRuleSetRemoved {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::preload::EventPreloadEnabledStateUpdated
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::preload::EventPreloadEnabledStateUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::preload::EventPrefetchStatusUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::preload::EventPrefetchStatusUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::preload::EventPrerenderStatusUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::preload::EventPrerenderStatusUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::preload::EventPreloadingAttemptSourcesUpdated
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::preload::EventPreloadingAttemptSourcesUpdated
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::security::EventVisibleSecurityStateChanged
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::security::EventVisibleSecurityStateChanged {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::service_worker::EventWorkerErrorReported
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::service_worker::EventWorkerErrorReported {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::service_worker::EventWorkerRegistrationUpdated
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::service_worker::EventWorkerRegistrationUpdated
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::service_worker::EventWorkerVersionUpdated
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::service_worker::EventWorkerVersionUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::storage::EventCacheStorageContentUpdated
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::storage::EventCacheStorageContentUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::storage::EventCacheStorageListUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::storage::EventCacheStorageListUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::storage::EventIndexedDbContentUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::storage::EventIndexedDbContentUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::storage::EventIndexedDbListUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::storage::EventIndexedDbListUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::storage::EventInterestGroupAccessed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::storage::EventInterestGroupAccessed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::storage::EventInterestGroupAuctionEventOccurred
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::storage::EventInterestGroupAuctionEventOccurred
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::storage::EventInterestGroupAuctionNetworkRequestCreated
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::storage::EventInterestGroupAuctionNetworkRequestCreated
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::storage::EventSharedStorageAccessed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::storage::EventSharedStorageAccessed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::storage::EventSharedStorageWorkletOperationExecutionFinished
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::storage::EventSharedStorageWorkletOperationExecutionFinished
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::storage::EventStorageBucketCreatedOrUpdated
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::storage::EventStorageBucketCreatedOrUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::storage::EventStorageBucketDeleted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::storage::EventStorageBucketDeleted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::storage::EventAttributionReportingSourceRegistered
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::storage::EventAttributionReportingSourceRegistered
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::storage::EventAttributionReportingTriggerRegistered
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::storage::EventAttributionReportingTriggerRegistered
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::storage::EventAttributionReportingReportSent
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::storage::EventAttributionReportingReportSent
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::storage::EventAttributionReportingVerboseDebugReportSent
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::storage::EventAttributionReportingVerboseDebugReportSent
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::target::EventAttachedToTarget {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::target::EventAttachedToTarget {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::target::EventDetachedFromTarget {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::target::EventDetachedFromTarget {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::target::EventReceivedMessageFromTarget
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::target::EventReceivedMessageFromTarget {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::target::EventTargetCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::target::EventTargetCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::target::EventTargetDestroyed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::target::EventTargetDestroyed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::target::EventTargetCrashed {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::target::EventTargetCrashed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::target::EventTargetInfoChanged {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::target::EventTargetInfoChanged {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::tethering::EventAccepted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::tethering::EventAccepted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::tracing::EventBufferUsage {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::tracing::EventBufferUsage {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::tracing::EventDataCollected {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::tracing::EventDataCollected {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::tracing::EventTracingComplete {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::tracing::EventTracingComplete {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_audio::EventContextCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventContextCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::web_audio::EventContextWillBeDestroyed
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventContextWillBeDestroyed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_audio::EventContextChanged {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventContextChanged {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_audio::EventAudioListenerCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventAudioListenerCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::web_audio::EventAudioListenerWillBeDestroyed
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind
+        for super::browser_protocol::web_audio::EventAudioListenerWillBeDestroyed
+    {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_audio::EventAudioNodeCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventAudioNodeCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::web_audio::EventAudioNodeWillBeDestroyed
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventAudioNodeWillBeDestroyed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_audio::EventAudioParamCreated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventAudioParamCreated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent
+        for super::browser_protocol::web_audio::EventAudioParamWillBeDestroyed
+    {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventAudioParamWillBeDestroyed {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_audio::EventNodesConnected {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventNodesConnected {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_audio::EventNodesDisconnected {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventNodesDisconnected {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_audio::EventNodeParamConnected {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventNodeParamConnected {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_audio::EventNodeParamDisconnected {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_audio::EventNodeParamDisconnected {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_authn::EventCredentialAdded {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_authn::EventCredentialAdded {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_authn::EventCredentialDeleted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_authn::EventCredentialDeleted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_authn::EventCredentialUpdated {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_authn::EventCredentialUpdated {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    impl super::sealed::SealedEvent for super::browser_protocol::web_authn::EventCredentialAsserted {
+        fn as_any(&self) -> &dyn ::std::any::Any {
+            self
+        }
+    }
+    impl super::IntoEventKind for super::browser_protocol::web_authn::EventCredentialAsserted {
+        fn event_kind() -> super::EventKind
+        where
+            Self: Sized + 'static,
+        {
+            super::EventKind::BuiltIn
+        }
+    }
+    #[macro_export]
+    #[doc(hidden)]
+    macro_rules! consume_event {
+        (match $ ev : ident { $ builtin : expr , $ custom : expr }) => {{
+            match $ev {
+                CdpEvent::DebuggerPaused(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DebuggerResumed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DebuggerScriptFailedToParse(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::DebuggerScriptParsed(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::HeapProfilerAddHeapSnapshotChunk(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::HeapProfilerHeapStatsUpdate(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::HeapProfilerLastSeenObjectId(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::HeapProfilerReportHeapSnapshotProgress(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::HeapProfilerResetProfiles(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::ProfilerConsoleProfileFinished(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::ProfilerConsoleProfileStarted(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::ProfilerPreciseCoverageDeltaUpdate(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::RuntimeBindingCalled(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::RuntimeConsoleApiCalled(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::RuntimeExceptionRevoked(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::RuntimeExceptionThrown(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::RuntimeExecutionContextCreated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::RuntimeExecutionContextDestroyed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::RuntimeExecutionContextsCleared(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::RuntimeInspectRequested(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::AccessibilityLoadComplete(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::AccessibilityNodesUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::AnimationAnimationCanceled(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::AnimationAnimationCreated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::AnimationAnimationStarted(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::AnimationAnimationUpdated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::AuditsIssueAdded(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::AutofillAddressFormFilled(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::BackgroundServiceRecordingStateChanged(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::BackgroundServiceBackgroundServiceEventReceived(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::BluetoothEmulationGattOperationReceived(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::BluetoothEmulationCharacteristicOperationReceived(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::BluetoothEmulationDescriptorOperationReceived(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::BrowserDownloadWillBegin(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::BrowserDownloadProgress(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::CssFontsUpdated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::CssMediaQueryResultChanged(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::CssStyleSheetAdded(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::CssStyleSheetChanged(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::CssStyleSheetRemoved(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::CssComputedStyleUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::CastSinksUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::CastIssueUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomAttributeModified(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomAdoptedStyleSheetsModified(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomAttributeRemoved(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomCharacterDataModified(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomChildNodeCountUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomChildNodeInserted(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::DomChildNodeRemoved(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomDistributedNodesUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomDocumentUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomInlineStyleInvalidated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomPseudoElementAdded(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::DomTopLayerElementsUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomScrollableFlagUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomAffectedByStartingStylesFlagUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomPseudoElementRemoved(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomSetChildNodes(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomShadowRootPopped(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomShadowRootPushed(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::DomStorageDomStorageItemAdded(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomStorageDomStorageItemRemoved(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomStorageDomStorageItemUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DomStorageDomStorageItemsCleared(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::DeviceAccessDeviceRequestPrompted(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::EmulationVirtualTimeBudgetExpired(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::FedCmDialogShown(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::FedCmDialogClosed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::FetchRequestPaused(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::FetchAuthRequired(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::InputDragIntercepted(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::InspectorDetached(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::InspectorTargetCrashed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::InspectorTargetReloadedAfterCrash(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::InspectorWorkerScriptLoaded(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::LayerTreeLayerPainted(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::LayerTreeLayerTreeDidChange(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::LogEntryAdded(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::MediaPlayerPropertiesChanged(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::MediaPlayerEventsAdded(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::MediaPlayerMessagesLogged(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::MediaPlayerErrorsRaised(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::MediaPlayerCreated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDataReceived(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkEventSourceMessageReceived(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkLoadingFailed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkLoadingFinished(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkRequestServedFromCache(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkRequestWillBeSent(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::NetworkResourceChangedPriority(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkSignedExchangeReceived(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::NetworkResponseReceived(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::NetworkWebSocketClosed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkWebSocketCreated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::NetworkWebSocketFrameError(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkWebSocketFrameReceived(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkWebSocketFrameSent(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkWebSocketHandshakeResponseReceived(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::NetworkWebSocketWillSendHandshakeRequest(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkWebTransportCreated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::NetworkWebTransportConnectionEstablished(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkWebTransportClosed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectTcpSocketCreated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::NetworkDirectTcpSocketOpened(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectTcpSocketAborted(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectTcpSocketClosed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectTcpSocketChunkSent(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectTcpSocketChunkReceived(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectUdpSocketJoinedMulticastGroup(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectUdpSocketLeftMulticastGroup(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectUdpSocketCreated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::NetworkDirectUdpSocketOpened(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectUdpSocketAborted(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectUdpSocketClosed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectUdpSocketChunkSent(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDirectUdpSocketChunkReceived(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkRequestWillBeSentExtraInfo(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkResponseReceivedExtraInfo(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::NetworkResponseReceivedEarlyHints(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkTrustTokenOperationDone(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkPolicyUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkReportingApiReportAdded(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkReportingApiReportUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkReportingApiEndpointsChangedForOrigin(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDeviceBoundSessionsAdded(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::NetworkDeviceBoundSessionEventOccurred(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::OverlayInspectNodeRequested(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::OverlayNodeHighlightRequested(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::OverlayScreenshotRequested(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::OverlayInspectModeCanceled(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageDomContentEventFired(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageFileChooserOpened(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageFrameAttached(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageFrameDetached(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageFrameSubtreeWillBeDetached(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageFrameNavigated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::PageDocumentOpened(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::PageFrameResized(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageFrameStartedNavigating(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageFrameRequestedNavigation(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageFrameStartedLoading(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageFrameStoppedLoading(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageInterstitialHidden(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageInterstitialShown(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageJavascriptDialogClosed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageJavascriptDialogOpening(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageLifecycleEvent(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageBackForwardCacheNotUsed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageLoadEventFired(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageNavigatedWithinDocument(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageScreencastFrame(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageScreencastVisibilityChanged(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageWindowOpen(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PageCompilationCacheProduced(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PerformanceMetrics(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PerformanceTimelineTimelineEventAdded(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::PreloadRuleSetUpdated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::PreloadRuleSetRemoved(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PreloadPreloadEnabledStateUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PreloadPrefetchStatusUpdated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::PreloadPrerenderStatusUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::PreloadPreloadingAttemptSourcesUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::SecurityVisibleSecurityStateChanged(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::ServiceWorkerWorkerErrorReported(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::ServiceWorkerWorkerRegistrationUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::ServiceWorkerWorkerVersionUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageCacheStorageContentUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageCacheStorageListUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageIndexedDbContentUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageIndexedDbListUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageInterestGroupAccessed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageInterestGroupAuctionEventOccurred(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageInterestGroupAuctionNetworkRequestCreated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageSharedStorageAccessed(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::StorageSharedStorageWorkletOperationExecutionFinished(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageStorageBucketCreatedOrUpdated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageStorageBucketDeleted(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageAttributionReportingSourceRegistered(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::StorageAttributionReportingTriggerRegistered(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::StorageAttributionReportingReportSent(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::StorageAttributionReportingVerboseDebugReportSent(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::TargetAttachedToTarget(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::TargetDetachedFromTarget(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::TargetReceivedMessageFromTarget(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::TargetTargetCreated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::TargetTargetDestroyed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::TargetTargetCrashed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::TargetTargetInfoChanged(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::TetheringAccepted(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::TracingBufferUsage(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::TracingDataCollected(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::TracingTracingComplete(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioContextCreated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioContextWillBeDestroyed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioContextChanged(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioAudioListenerCreated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioAudioListenerWillBeDestroyed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioAudioNodeCreated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioAudioNodeWillBeDestroyed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioAudioParamCreated(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioAudioParamWillBeDestroyed(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioNodesConnected(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioNodesDisconnected(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioNodeParamConnected(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAudioNodeParamDisconnected(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAuthnCredentialAdded(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::WebAuthnCredentialDeleted(event) => {
+                    $builtin(event);
+                }
+                CdpEvent::WebAuthnCredentialUpdated(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::WebAuthnCredentialAsserted(event) => {
+                    $builtin(*event);
+                }
+                CdpEvent::Other(json) => {
+                    $custom(json);
+                }
+            }
+        }};
+    }
+}
+#[allow(clippy::wrong_self_convention)]
+pub mod js_protocol {
+    #[doc = r" The version of this protocol definition"]
+    pub const VERSION: &str = "1.3";
+    #[doc = "Debugger domain exposes JavaScript debugging capabilities. It allows setting and removing\nbreakpoints, stepping through execution, exploring stack traces, etc."]
+    pub mod debugger {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Breakpoint identifier.\n[BreakpointId](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#type-BreakpointId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct BreakpointId(String);
+        impl BreakpointId {
+            pub fn new(val: impl Into<String>) -> Self {
+                BreakpointId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for BreakpointId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<BreakpointId> for String {
+            fn from(el: BreakpointId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for BreakpointId {
+            fn from(expr: String) -> Self {
+                BreakpointId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for BreakpointId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl BreakpointId {
+            pub const IDENTIFIER: &'static str = "Debugger.BreakpointId";
+        }
+        #[doc = "Call frame identifier.\n[CallFrameId](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#type-CallFrameId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct CallFrameId(String);
+        impl CallFrameId {
+            pub fn new(val: impl Into<String>) -> Self {
+                CallFrameId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for CallFrameId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<CallFrameId> for String {
+            fn from(el: CallFrameId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for CallFrameId {
+            fn from(expr: String) -> Self {
+                CallFrameId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for CallFrameId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl CallFrameId {
+            pub const IDENTIFIER: &'static str = "Debugger.CallFrameId";
+        }
+        #[doc = "Location in the source code.\n[Location](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#type-Location)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Location {
+            #[doc = "Script identifier as reported in the `Debugger.scriptParsed`."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+            #[doc = "Line number in the script (0-based)."]
+            #[serde(rename = "lineNumber")]
+            pub line_number: i64,
+            #[doc = "Column number in the script (0-based)."]
+            #[serde(rename = "columnNumber")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub column_number: Option<i64>,
+        }
+        impl Location {
+            pub fn new(
+                script_id: impl Into<super::runtime::ScriptId>,
+                line_number: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                    line_number: line_number.into(),
+                    column_number: None,
+                }
+            }
+        }
+        impl Location {
+            pub fn builder() -> LocationBuilder {
+                LocationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LocationBuilder {
+            script_id: Option<super::runtime::ScriptId>,
+            line_number: Option<i64>,
+            column_number: Option<i64>,
+        }
+        impl LocationBuilder {
+            pub fn script_id(mut self, script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<i64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn build(self) -> Result<Location, String> {
+                Ok(Location {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    column_number: self.column_number,
+                })
+            }
+        }
+        impl Location {
+            pub const IDENTIFIER: &'static str = "Debugger.Location";
+        }
+        #[doc = "Location in the source code.\n[ScriptPosition](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#type-ScriptPosition)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScriptPosition {
+            #[serde(rename = "lineNumber")]
+            pub line_number: i64,
+            #[serde(rename = "columnNumber")]
+            pub column_number: i64,
+        }
+        impl ScriptPosition {
+            pub fn new(line_number: impl Into<i64>, column_number: impl Into<i64>) -> Self {
+                Self {
+                    line_number: line_number.into(),
+                    column_number: column_number.into(),
+                }
+            }
+        }
+        impl ScriptPosition {
+            pub fn builder() -> ScriptPositionBuilder {
+                ScriptPositionBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScriptPositionBuilder {
+            line_number: Option<i64>,
+            column_number: Option<i64>,
+        }
+        impl ScriptPositionBuilder {
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<i64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn build(self) -> Result<ScriptPosition, String> {
+                Ok(ScriptPosition {
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    column_number: self.column_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(column_number))
+                    })?,
+                })
+            }
+        }
+        impl ScriptPosition {
+            pub const IDENTIFIER: &'static str = "Debugger.ScriptPosition";
+        }
+        #[doc = "Location range within one script.\n[LocationRange](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#type-LocationRange)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LocationRange {
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+            #[serde(rename = "start")]
+            pub start: ScriptPosition,
+            #[serde(rename = "end")]
+            pub end: ScriptPosition,
+        }
+        impl LocationRange {
+            pub fn new(
+                script_id: impl Into<super::runtime::ScriptId>,
+                start: impl Into<ScriptPosition>,
+                end: impl Into<ScriptPosition>,
+            ) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                    start: start.into(),
+                    end: end.into(),
+                }
+            }
+        }
+        impl LocationRange {
+            pub fn builder() -> LocationRangeBuilder {
+                LocationRangeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LocationRangeBuilder {
+            script_id: Option<super::runtime::ScriptId>,
+            start: Option<ScriptPosition>,
+            end: Option<ScriptPosition>,
+        }
+        impl LocationRangeBuilder {
+            pub fn script_id(mut self, script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn start(mut self, start: impl Into<ScriptPosition>) -> Self {
+                self.start = Some(start.into());
+                self
+            }
+            pub fn end(mut self, end: impl Into<ScriptPosition>) -> Self {
+                self.end = Some(end.into());
+                self
+            }
+            pub fn build(self) -> Result<LocationRange, String> {
+                Ok(LocationRange {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    start: self.start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start))
+                    })?,
+                    end: self
+                        .end
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(end)))?,
+                })
+            }
+        }
+        impl LocationRange {
+            pub const IDENTIFIER: &'static str = "Debugger.LocationRange";
+        }
+        #[doc = "JavaScript call frame. Array of call frames form the call stack.\n[CallFrame](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#type-CallFrame)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CallFrame {
+            #[doc = "Call frame identifier. This identifier is only valid while the virtual machine is paused."]
+            #[serde(rename = "callFrameId")]
+            pub call_frame_id: CallFrameId,
+            #[doc = "Name of the JavaScript function called on this call frame."]
+            #[serde(rename = "functionName")]
+            pub function_name: String,
+            #[doc = "Location in the source code."]
+            #[serde(rename = "functionLocation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub function_location: Option<Location>,
+            #[doc = "Location in the source code."]
+            #[serde(rename = "location")]
+            pub location: Location,
+            #[doc = "Scope chain for this call frame."]
+            #[serde(rename = "scopeChain")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub scope_chain: Vec<Scope>,
+            #[doc = "`this` object for this call frame."]
+            #[serde(rename = "this")]
+            pub this: super::runtime::RemoteObject,
+            #[doc = "The value being returned, if the function is at return point."]
+            #[serde(rename = "returnValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub return_value: Option<super::runtime::RemoteObject>,
+            #[doc = "Valid only while the VM is paused and indicates whether this frame\ncan be restarted or not. Note that a `true` value here does not\nguarantee that Debugger#restartFrame with this CallFrameId will be\nsuccessful, but it is very likely."]
+            #[serde(rename = "canBeRestarted")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub can_be_restarted: Option<bool>,
+        }
+        impl CallFrame {
+            pub fn builder() -> CallFrameBuilder {
+                CallFrameBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CallFrameBuilder {
+            call_frame_id: Option<CallFrameId>,
+            function_name: Option<String>,
+            function_location: Option<Location>,
+            location: Option<Location>,
+            scope_chain: Option<Vec<Scope>>,
+            this: Option<super::runtime::RemoteObject>,
+            return_value: Option<super::runtime::RemoteObject>,
+            can_be_restarted: Option<bool>,
+        }
+        impl CallFrameBuilder {
+            pub fn call_frame_id(mut self, call_frame_id: impl Into<CallFrameId>) -> Self {
+                self.call_frame_id = Some(call_frame_id.into());
+                self
+            }
+            pub fn function_name(mut self, function_name: impl Into<String>) -> Self {
+                self.function_name = Some(function_name.into());
+                self
+            }
+            pub fn function_location(mut self, function_location: impl Into<Location>) -> Self {
+                self.function_location = Some(function_location.into());
+                self
+            }
+            pub fn location(mut self, location: impl Into<Location>) -> Self {
+                self.location = Some(location.into());
+                self
+            }
+            pub fn scope_chain(mut self, scope_chain: impl Into<Scope>) -> Self {
+                let v = self.scope_chain.get_or_insert(Vec::new());
+                v.push(scope_chain.into());
+                self
+            }
+            pub fn scope_chains<I, S>(mut self, scope_chains: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Scope>,
+            {
+                let v = self.scope_chain.get_or_insert(Vec::new());
+                for val in scope_chains {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn this(mut self, this: impl Into<super::runtime::RemoteObject>) -> Self {
+                self.this = Some(this.into());
+                self
+            }
+            pub fn return_value(
+                mut self,
+                return_value: impl Into<super::runtime::RemoteObject>,
+            ) -> Self {
+                self.return_value = Some(return_value.into());
+                self
+            }
+            pub fn can_be_restarted(mut self, can_be_restarted: impl Into<bool>) -> Self {
+                self.can_be_restarted = Some(can_be_restarted.into());
+                self
+            }
+            pub fn build(self) -> Result<CallFrame, String> {
+                Ok(CallFrame {
+                    call_frame_id: self.call_frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(call_frame_id))
+                    })?,
+                    function_name: self.function_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(function_name))
+                    })?,
+                    function_location: self.function_location,
+                    location: self.location.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(location))
+                    })?,
+                    scope_chain: self.scope_chain.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scope_chain))
+                    })?,
+                    this: self.this.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(this))
+                    })?,
+                    return_value: self.return_value,
+                    can_be_restarted: self.can_be_restarted,
+                })
+            }
+        }
+        impl CallFrame {
+            pub const IDENTIFIER: &'static str = "Debugger.CallFrame";
+        }
+        #[doc = "Scope description.\n[Scope](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#type-Scope)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Scope {
+            #[doc = "Scope type."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: ScopeType,
+            #[doc = "Object representing the scope. For `global` and `with` scopes it represents the actual\nobject; for the rest of the scopes, it is artificial transient object enumerating scope\nvariables as its properties."]
+            #[serde(rename = "object")]
+            pub object: super::runtime::RemoteObject,
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[doc = "Location in the source code where scope starts"]
+            #[serde(rename = "startLocation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub start_location: Option<Location>,
+            #[doc = "Location in the source code where scope ends"]
+            #[serde(rename = "endLocation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub end_location: Option<Location>,
+        }
+        #[doc = "Scope type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ScopeType {
+            #[serde(rename = "global")]
+            Global,
+            #[serde(rename = "local")]
+            Local,
+            #[serde(rename = "with")]
+            With,
+            #[serde(rename = "closure")]
+            Closure,
+            #[serde(rename = "catch")]
+            Catch,
+            #[serde(rename = "block")]
+            Block,
+            #[serde(rename = "script")]
+            Script,
+            #[serde(rename = "eval")]
+            Eval,
+            #[serde(rename = "module")]
+            Module,
+            #[serde(rename = "wasm-expression-stack")]
+            WasmExpressionStack,
+        }
+        impl AsRef<str> for ScopeType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ScopeType::Global => "global",
+                    ScopeType::Local => "local",
+                    ScopeType::With => "with",
+                    ScopeType::Closure => "closure",
+                    ScopeType::Catch => "catch",
+                    ScopeType::Block => "block",
+                    ScopeType::Script => "script",
+                    ScopeType::Eval => "eval",
+                    ScopeType::Module => "module",
+                    ScopeType::WasmExpressionStack => "wasm-expression-stack",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ScopeType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "global" | "Global" => Ok(ScopeType::Global),
+                    "local" | "Local" => Ok(ScopeType::Local),
+                    "with" | "With" => Ok(ScopeType::With),
+                    "closure" | "Closure" => Ok(ScopeType::Closure),
+                    "catch" | "Catch" => Ok(ScopeType::Catch),
+                    "block" | "Block" => Ok(ScopeType::Block),
+                    "script" | "Script" => Ok(ScopeType::Script),
+                    "eval" | "Eval" => Ok(ScopeType::Eval),
+                    "module" | "Module" => Ok(ScopeType::Module),
+                    "wasm-expression-stack" | "WasmExpressionStack" => {
+                        Ok(ScopeType::WasmExpressionStack)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl Scope {
+            pub fn new(
+                r#type: impl Into<ScopeType>,
+                object: impl Into<super::runtime::RemoteObject>,
+            ) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    object: object.into(),
+                    name: None,
+                    start_location: None,
+                    end_location: None,
+                }
+            }
+        }
+        impl Scope {
+            pub fn builder() -> ScopeBuilder {
+                ScopeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScopeBuilder {
+            r#type: Option<ScopeType>,
+            object: Option<super::runtime::RemoteObject>,
+            name: Option<String>,
+            start_location: Option<Location>,
+            end_location: Option<Location>,
+        }
+        impl ScopeBuilder {
+            pub fn r#type(mut self, r#type: impl Into<ScopeType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn object(mut self, object: impl Into<super::runtime::RemoteObject>) -> Self {
+                self.object = Some(object.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn start_location(mut self, start_location: impl Into<Location>) -> Self {
+                self.start_location = Some(start_location.into());
+                self
+            }
+            pub fn end_location(mut self, end_location: impl Into<Location>) -> Self {
+                self.end_location = Some(end_location.into());
+                self
+            }
+            pub fn build(self) -> Result<Scope, String> {
+                Ok(Scope {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    object: self.object.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object))
+                    })?,
+                    name: self.name,
+                    start_location: self.start_location,
+                    end_location: self.end_location,
+                })
+            }
+        }
+        impl Scope {
+            pub const IDENTIFIER: &'static str = "Debugger.Scope";
+        }
+        #[doc = "Search match for resource.\n[SearchMatch](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#type-SearchMatch)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SearchMatch {
+            #[doc = "Line number in resource content."]
+            #[serde(rename = "lineNumber")]
+            pub line_number: f64,
+            #[doc = "Line with match content."]
+            #[serde(rename = "lineContent")]
+            pub line_content: String,
+        }
+        impl SearchMatch {
+            pub fn new(line_number: impl Into<f64>, line_content: impl Into<String>) -> Self {
+                Self {
+                    line_number: line_number.into(),
+                    line_content: line_content.into(),
+                }
+            }
+        }
+        impl SearchMatch {
+            pub fn builder() -> SearchMatchBuilder {
+                SearchMatchBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SearchMatchBuilder {
+            line_number: Option<f64>,
+            line_content: Option<String>,
+        }
+        impl SearchMatchBuilder {
+            pub fn line_number(mut self, line_number: impl Into<f64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn line_content(mut self, line_content: impl Into<String>) -> Self {
+                self.line_content = Some(line_content.into());
+                self
+            }
+            pub fn build(self) -> Result<SearchMatch, String> {
+                Ok(SearchMatch {
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    line_content: self.line_content.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_content))
+                    })?,
+                })
+            }
+        }
+        impl SearchMatch {
+            pub const IDENTIFIER: &'static str = "Debugger.SearchMatch";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BreakLocation {
+            #[doc = "Script identifier as reported in the `Debugger.scriptParsed`."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+            #[doc = "Line number in the script (0-based)."]
+            #[serde(rename = "lineNumber")]
+            pub line_number: i64,
+            #[doc = "Column number in the script (0-based)."]
+            #[serde(rename = "columnNumber")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub column_number: Option<i64>,
+            #[serde(rename = "type")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub r#type: Option<BreakLocationType>,
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum BreakLocationType {
+            #[serde(rename = "debuggerStatement")]
+            DebuggerStatement,
+            #[serde(rename = "call")]
+            Call,
+            #[serde(rename = "return")]
+            Return,
+        }
+        impl AsRef<str> for BreakLocationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    BreakLocationType::DebuggerStatement => "debuggerStatement",
+                    BreakLocationType::Call => "call",
+                    BreakLocationType::Return => "return",
+                }
+            }
+        }
+        impl ::std::str::FromStr for BreakLocationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "debuggerStatement" | "DebuggerStatement" | "debuggerstatement" => {
+                        Ok(BreakLocationType::DebuggerStatement)
+                    }
+                    "call" | "Call" => Ok(BreakLocationType::Call),
+                    "return" | "Return" => Ok(BreakLocationType::Return),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl BreakLocation {
+            pub fn new(
+                script_id: impl Into<super::runtime::ScriptId>,
+                line_number: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                    line_number: line_number.into(),
+                    column_number: None,
+                    r#type: None,
+                }
+            }
+        }
+        impl BreakLocation {
+            pub fn builder() -> BreakLocationBuilder {
+                BreakLocationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BreakLocationBuilder {
+            script_id: Option<super::runtime::ScriptId>,
+            line_number: Option<i64>,
+            column_number: Option<i64>,
+            r#type: Option<BreakLocationType>,
+        }
+        impl BreakLocationBuilder {
+            pub fn script_id(mut self, script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<i64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<BreakLocationType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<BreakLocation, String> {
+                Ok(BreakLocation {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    column_number: self.column_number,
+                    r#type: self.r#type,
+                })
+            }
+        }
+        impl BreakLocation {
+            pub const IDENTIFIER: &'static str = "Debugger.BreakLocation";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct WasmDisassemblyChunk {
+            #[doc = "The next chunk of disassembled lines."]
+            #[serde(rename = "lines")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub lines: Vec<String>,
+            #[doc = "The bytecode offsets describing the start of each line."]
+            #[serde(rename = "bytecodeOffsets")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub bytecode_offsets: Vec<i64>,
+        }
+        impl WasmDisassemblyChunk {
+            pub fn new(lines: Vec<String>, bytecode_offsets: Vec<i64>) -> Self {
+                Self {
+                    lines,
+                    bytecode_offsets,
+                }
+            }
+        }
+        impl WasmDisassemblyChunk {
+            pub fn builder() -> WasmDisassemblyChunkBuilder {
+                WasmDisassemblyChunkBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct WasmDisassemblyChunkBuilder {
+            lines: Option<Vec<String>>,
+            bytecode_offsets: Option<Vec<i64>>,
+        }
+        impl WasmDisassemblyChunkBuilder {
+            pub fn line(mut self, line: impl Into<String>) -> Self {
+                let v = self.lines.get_or_insert(Vec::new());
+                v.push(line.into());
+                self
+            }
+            pub fn lines<I, S>(mut self, lines: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.lines.get_or_insert(Vec::new());
+                for val in lines {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn bytecode_offset(mut self, bytecode_offset: impl Into<i64>) -> Self {
+                let v = self.bytecode_offsets.get_or_insert(Vec::new());
+                v.push(bytecode_offset.into());
+                self
+            }
+            pub fn bytecode_offsets<I, S>(mut self, bytecode_offsets: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.bytecode_offsets.get_or_insert(Vec::new());
+                for val in bytecode_offsets {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<WasmDisassemblyChunk, String> {
+                Ok(WasmDisassemblyChunk {
+                    lines: self.lines.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(lines))
+                    })?,
+                    bytecode_offsets: self.bytecode_offsets.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(bytecode_offsets)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl WasmDisassemblyChunk {
+            pub const IDENTIFIER: &'static str = "Debugger.WasmDisassemblyChunk";
+        }
+        #[doc = "Enum of possible script languages."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ScriptLanguage {
+            #[serde(rename = "JavaScript")]
+            JavaScript,
+            #[serde(rename = "WebAssembly")]
+            WebAssembly,
+        }
+        impl AsRef<str> for ScriptLanguage {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ScriptLanguage::JavaScript => "JavaScript",
+                    ScriptLanguage::WebAssembly => "WebAssembly",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ScriptLanguage {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "JavaScript" | "javascript" => Ok(ScriptLanguage::JavaScript),
+                    "WebAssembly" | "webassembly" => Ok(ScriptLanguage::WebAssembly),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Debug symbols available for a wasm script.\n[DebugSymbols](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#type-DebugSymbols)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DebugSymbols {
+            #[doc = "Type of the debug symbols."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DebugSymbolsType,
+            #[doc = "URL of the external symbol source."]
+            #[serde(rename = "externalURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub external_url: Option<String>,
+        }
+        #[doc = "Type of the debug symbols."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DebugSymbolsType {
+            #[serde(rename = "SourceMap")]
+            SourceMap,
+            #[serde(rename = "EmbeddedDWARF")]
+            EmbeddedDwarf,
+            #[serde(rename = "ExternalDWARF")]
+            ExternalDwarf,
+        }
+        impl AsRef<str> for DebugSymbolsType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DebugSymbolsType::SourceMap => "SourceMap",
+                    DebugSymbolsType::EmbeddedDwarf => "EmbeddedDWARF",
+                    DebugSymbolsType::ExternalDwarf => "ExternalDWARF",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DebugSymbolsType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "SourceMap" | "sourcemap" => Ok(DebugSymbolsType::SourceMap),
+                    "EmbeddedDWARF" | "EmbeddedDwarf" | "embeddeddwarf" => {
+                        Ok(DebugSymbolsType::EmbeddedDwarf)
+                    }
+                    "ExternalDWARF" | "ExternalDwarf" | "externaldwarf" => {
+                        Ok(DebugSymbolsType::ExternalDwarf)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl DebugSymbols {
+            pub fn new(r#type: impl Into<DebugSymbolsType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    external_url: None,
+                }
+            }
+        }
+        impl DebugSymbols {
+            pub fn builder() -> DebugSymbolsBuilder {
+                DebugSymbolsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DebugSymbolsBuilder {
+            r#type: Option<DebugSymbolsType>,
+            external_url: Option<String>,
+        }
+        impl DebugSymbolsBuilder {
+            pub fn r#type(mut self, r#type: impl Into<DebugSymbolsType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn external_url(mut self, external_url: impl Into<String>) -> Self {
+                self.external_url = Some(external_url.into());
+                self
+            }
+            pub fn build(self) -> Result<DebugSymbols, String> {
+                Ok(DebugSymbols {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    external_url: self.external_url,
+                })
+            }
+        }
+        impl DebugSymbols {
+            pub const IDENTIFIER: &'static str = "Debugger.DebugSymbols";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ResolvedBreakpoint {
+            #[doc = "Breakpoint unique identifier."]
+            #[serde(rename = "breakpointId")]
+            pub breakpoint_id: BreakpointId,
+            #[doc = "Actual breakpoint location."]
+            #[serde(rename = "location")]
+            pub location: Location,
+        }
+        impl ResolvedBreakpoint {
+            pub fn new(
+                breakpoint_id: impl Into<BreakpointId>,
+                location: impl Into<Location>,
+            ) -> Self {
+                Self {
+                    breakpoint_id: breakpoint_id.into(),
+                    location: location.into(),
+                }
+            }
+        }
+        impl ResolvedBreakpoint {
+            pub fn builder() -> ResolvedBreakpointBuilder {
+                ResolvedBreakpointBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResolvedBreakpointBuilder {
+            breakpoint_id: Option<BreakpointId>,
+            location: Option<Location>,
+        }
+        impl ResolvedBreakpointBuilder {
+            pub fn breakpoint_id(mut self, breakpoint_id: impl Into<BreakpointId>) -> Self {
+                self.breakpoint_id = Some(breakpoint_id.into());
+                self
+            }
+            pub fn location(mut self, location: impl Into<Location>) -> Self {
+                self.location = Some(location.into());
+                self
+            }
+            pub fn build(self) -> Result<ResolvedBreakpoint, String> {
+                Ok(ResolvedBreakpoint {
+                    breakpoint_id: self.breakpoint_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(breakpoint_id))
+                    })?,
+                    location: self.location.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(location))
+                    })?,
+                })
+            }
+        }
+        impl ResolvedBreakpoint {
+            pub const IDENTIFIER: &'static str = "Debugger.ResolvedBreakpoint";
+        }
+        #[doc = "Continues execution until specific location is reached.\n[continueToLocation](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-continueToLocation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ContinueToLocationParams {
+            #[doc = "Location to continue to."]
+            #[serde(rename = "location")]
+            pub location: Location,
+            #[serde(rename = "targetCallFrames")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub target_call_frames: Option<ContinueToLocationTargetCallFrames>,
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ContinueToLocationTargetCallFrames {
+            #[serde(rename = "any")]
+            Any,
+            #[serde(rename = "current")]
+            Current,
+        }
+        impl AsRef<str> for ContinueToLocationTargetCallFrames {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ContinueToLocationTargetCallFrames::Any => "any",
+                    ContinueToLocationTargetCallFrames::Current => "current",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ContinueToLocationTargetCallFrames {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "any" | "Any" => Ok(ContinueToLocationTargetCallFrames::Any),
+                    "current" | "Current" => Ok(ContinueToLocationTargetCallFrames::Current),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl ContinueToLocationParams {
+            pub fn new(location: impl Into<Location>) -> Self {
+                Self {
+                    location: location.into(),
+                    target_call_frames: None,
+                }
+            }
+        }
+        impl ContinueToLocationParams {
+            pub fn builder() -> ContinueToLocationParamsBuilder {
+                ContinueToLocationParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ContinueToLocationParamsBuilder {
+            location: Option<Location>,
+            target_call_frames: Option<ContinueToLocationTargetCallFrames>,
+        }
+        impl ContinueToLocationParamsBuilder {
+            pub fn location(mut self, location: impl Into<Location>) -> Self {
+                self.location = Some(location.into());
+                self
+            }
+            pub fn target_call_frames(
+                mut self,
+                target_call_frames: impl Into<ContinueToLocationTargetCallFrames>,
+            ) -> Self {
+                self.target_call_frames = Some(target_call_frames.into());
+                self
+            }
+            pub fn build(self) -> Result<ContinueToLocationParams, String> {
+                Ok(ContinueToLocationParams {
+                    location: self.location.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(location))
+                    })?,
+                    target_call_frames: self.target_call_frames,
+                })
+            }
+        }
+        impl ContinueToLocationParams {
+            pub const IDENTIFIER: &'static str = "Debugger.continueToLocation";
+        }
+        impl chromiumoxide_types::Method for ContinueToLocationParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ContinueToLocationParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Continues execution until specific location is reached.\n[continueToLocation](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-continueToLocation)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ContinueToLocationReturns {}
+        impl chromiumoxide_types::Command for ContinueToLocationParams {
+            type Response = ContinueToLocationReturns;
+        }
+        #[doc = "Disables debugger for given page.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Debugger.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables debugger for given page.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables debugger for the given page. Clients should not assume that the debugging has been\nenabled until the result for this command is received.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[doc = "The maximum size in bytes of collected scripts (not referenced by other heap objects)\nthe debugger can hold. Puts no limit if parameter is omitted."]
+            #[serde(rename = "maxScriptsCacheSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_scripts_cache_size: Option<f64>,
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            max_scripts_cache_size: Option<f64>,
+        }
+        impl EnableParamsBuilder {
+            pub fn max_scripts_cache_size(
+                mut self,
+                max_scripts_cache_size: impl Into<f64>,
+            ) -> Self {
+                self.max_scripts_cache_size = Some(max_scripts_cache_size.into());
+                self
+            }
+            pub fn build(self) -> EnableParams {
+                EnableParams {
+                    max_scripts_cache_size: self.max_scripts_cache_size,
+                }
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Debugger.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables debugger for the given page. Clients should not assume that the debugging has been\nenabled until the result for this command is received.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EnableReturns {
+            #[doc = "Unique identifier of the debugger."]
+            #[serde(rename = "debuggerId")]
+            pub debugger_id: super::runtime::UniqueDebuggerId,
+        }
+        impl EnableReturns {
+            pub fn new(debugger_id: impl Into<super::runtime::UniqueDebuggerId>) -> Self {
+                Self {
+                    debugger_id: debugger_id.into(),
+                }
+            }
+        }
+        impl EnableReturns {
+            pub fn builder() -> EnableReturnsBuilder {
+                EnableReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableReturnsBuilder {
+            debugger_id: Option<super::runtime::UniqueDebuggerId>,
+        }
+        impl EnableReturnsBuilder {
+            pub fn debugger_id(
+                mut self,
+                debugger_id: impl Into<super::runtime::UniqueDebuggerId>,
+            ) -> Self {
+                self.debugger_id = Some(debugger_id.into());
+                self
+            }
+            pub fn build(self) -> Result<EnableReturns, String> {
+                Ok(EnableReturns {
+                    debugger_id: self.debugger_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(debugger_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Evaluates expression on a given call frame.\n[evaluateOnCallFrame](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-evaluateOnCallFrame)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EvaluateOnCallFrameParams {
+            #[doc = "Call frame identifier to evaluate on."]
+            #[serde(rename = "callFrameId")]
+            pub call_frame_id: CallFrameId,
+            #[doc = "Expression to evaluate."]
+            #[serde(rename = "expression")]
+            pub expression: String,
+            #[doc = "String object group name to put result into (allows rapid releasing resulting object handles\nusing `releaseObjectGroup`)."]
+            #[serde(rename = "objectGroup")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_group: Option<String>,
+            #[doc = "Specifies whether command line API should be available to the evaluated expression, defaults\nto false."]
+            #[serde(rename = "includeCommandLineAPI")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_command_line_api: Option<bool>,
+            #[doc = "In silent mode exceptions thrown during evaluation are not reported and do not pause\nexecution. Overrides `setPauseOnException` state."]
+            #[serde(rename = "silent")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub silent: Option<bool>,
+            #[doc = "Whether the result is expected to be a JSON object that should be sent by value."]
+            #[serde(rename = "returnByValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub return_by_value: Option<bool>,
+            #[doc = "Whether preview should be generated for the result."]
+            #[serde(rename = "generatePreview")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub generate_preview: Option<bool>,
+            #[doc = "Whether to throw an exception if side effect cannot be ruled out during evaluation."]
+            #[serde(rename = "throwOnSideEffect")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub throw_on_side_effect: Option<bool>,
+            #[doc = "Terminate execution after timing out (number of milliseconds)."]
+            #[serde(rename = "timeout")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub timeout: Option<super::runtime::TimeDelta>,
+        }
+        impl EvaluateOnCallFrameParams {
+            pub fn new(
+                call_frame_id: impl Into<CallFrameId>,
+                expression: impl Into<String>,
+            ) -> Self {
+                Self {
+                    call_frame_id: call_frame_id.into(),
+                    expression: expression.into(),
+                    object_group: None,
+                    include_command_line_api: None,
+                    silent: None,
+                    return_by_value: None,
+                    generate_preview: None,
+                    throw_on_side_effect: None,
+                    timeout: None,
+                }
+            }
+        }
+        impl EvaluateOnCallFrameParams {
+            pub fn builder() -> EvaluateOnCallFrameParamsBuilder {
+                EvaluateOnCallFrameParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EvaluateOnCallFrameParamsBuilder {
+            call_frame_id: Option<CallFrameId>,
+            expression: Option<String>,
+            object_group: Option<String>,
+            include_command_line_api: Option<bool>,
+            silent: Option<bool>,
+            return_by_value: Option<bool>,
+            generate_preview: Option<bool>,
+            throw_on_side_effect: Option<bool>,
+            timeout: Option<super::runtime::TimeDelta>,
+        }
+        impl EvaluateOnCallFrameParamsBuilder {
+            pub fn call_frame_id(mut self, call_frame_id: impl Into<CallFrameId>) -> Self {
+                self.call_frame_id = Some(call_frame_id.into());
+                self
+            }
+            pub fn expression(mut self, expression: impl Into<String>) -> Self {
+                self.expression = Some(expression.into());
+                self
+            }
+            pub fn object_group(mut self, object_group: impl Into<String>) -> Self {
+                self.object_group = Some(object_group.into());
+                self
+            }
+            pub fn include_command_line_api(
+                mut self,
+                include_command_line_api: impl Into<bool>,
+            ) -> Self {
+                self.include_command_line_api = Some(include_command_line_api.into());
+                self
+            }
+            pub fn silent(mut self, silent: impl Into<bool>) -> Self {
+                self.silent = Some(silent.into());
+                self
+            }
+            pub fn return_by_value(mut self, return_by_value: impl Into<bool>) -> Self {
+                self.return_by_value = Some(return_by_value.into());
+                self
+            }
+            pub fn generate_preview(mut self, generate_preview: impl Into<bool>) -> Self {
+                self.generate_preview = Some(generate_preview.into());
+                self
+            }
+            pub fn throw_on_side_effect(mut self, throw_on_side_effect: impl Into<bool>) -> Self {
+                self.throw_on_side_effect = Some(throw_on_side_effect.into());
+                self
+            }
+            pub fn timeout(mut self, timeout: impl Into<super::runtime::TimeDelta>) -> Self {
+                self.timeout = Some(timeout.into());
+                self
+            }
+            pub fn build(self) -> Result<EvaluateOnCallFrameParams, String> {
+                Ok(EvaluateOnCallFrameParams {
+                    call_frame_id: self.call_frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(call_frame_id))
+                    })?,
+                    expression: self.expression.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expression))
+                    })?,
+                    object_group: self.object_group,
+                    include_command_line_api: self.include_command_line_api,
+                    silent: self.silent,
+                    return_by_value: self.return_by_value,
+                    generate_preview: self.generate_preview,
+                    throw_on_side_effect: self.throw_on_side_effect,
+                    timeout: self.timeout,
+                })
+            }
+        }
+        impl EvaluateOnCallFrameParams {
+            pub const IDENTIFIER: &'static str = "Debugger.evaluateOnCallFrame";
+        }
+        impl chromiumoxide_types::Method for EvaluateOnCallFrameParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EvaluateOnCallFrameParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Evaluates expression on a given call frame.\n[evaluateOnCallFrame](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-evaluateOnCallFrame)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EvaluateOnCallFrameReturns {
+            #[doc = "Object wrapper for the evaluation result."]
+            #[serde(rename = "result")]
+            pub result: super::runtime::RemoteObject,
+            #[doc = "Exception details."]
+            #[serde(rename = "exceptionDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception_details: Option<super::runtime::ExceptionDetails>,
+        }
+        impl EvaluateOnCallFrameReturns {
+            pub fn new(result: impl Into<super::runtime::RemoteObject>) -> Self {
+                Self {
+                    result: result.into(),
+                    exception_details: None,
+                }
+            }
+        }
+        impl EvaluateOnCallFrameReturns {
+            pub fn builder() -> EvaluateOnCallFrameReturnsBuilder {
+                EvaluateOnCallFrameReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EvaluateOnCallFrameReturnsBuilder {
+            result: Option<super::runtime::RemoteObject>,
+            exception_details: Option<super::runtime::ExceptionDetails>,
+        }
+        impl EvaluateOnCallFrameReturnsBuilder {
+            pub fn result(mut self, result: impl Into<super::runtime::RemoteObject>) -> Self {
+                self.result = Some(result.into());
+                self
+            }
+            pub fn exception_details(
+                mut self,
+                exception_details: impl Into<super::runtime::ExceptionDetails>,
+            ) -> Self {
+                self.exception_details = Some(exception_details.into());
+                self
+            }
+            pub fn build(self) -> Result<EvaluateOnCallFrameReturns, String> {
+                Ok(EvaluateOnCallFrameReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                    exception_details: self.exception_details,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for EvaluateOnCallFrameParams {
+            type Response = EvaluateOnCallFrameReturns;
+        }
+        #[doc = "Returns possible locations for breakpoint. scriptId in start and end range locations should be\nthe same.\n[getPossibleBreakpoints](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-getPossibleBreakpoints)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetPossibleBreakpointsParams {
+            #[doc = "Start of range to search possible breakpoint locations in."]
+            #[serde(rename = "start")]
+            pub start: Location,
+            #[doc = "End of range to search possible breakpoint locations in (excluding). When not specified, end\nof scripts is used as end of range."]
+            #[serde(rename = "end")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub end: Option<Location>,
+            #[doc = "Only consider locations which are in the same (non-nested) function as start."]
+            #[serde(rename = "restrictToFunction")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub restrict_to_function: Option<bool>,
+        }
+        impl GetPossibleBreakpointsParams {
+            pub fn new(start: impl Into<Location>) -> Self {
+                Self {
+                    start: start.into(),
+                    end: None,
+                    restrict_to_function: None,
+                }
+            }
+        }
+        impl GetPossibleBreakpointsParams {
+            pub fn builder() -> GetPossibleBreakpointsParamsBuilder {
+                GetPossibleBreakpointsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPossibleBreakpointsParamsBuilder {
+            start: Option<Location>,
+            end: Option<Location>,
+            restrict_to_function: Option<bool>,
+        }
+        impl GetPossibleBreakpointsParamsBuilder {
+            pub fn start(mut self, start: impl Into<Location>) -> Self {
+                self.start = Some(start.into());
+                self
+            }
+            pub fn end(mut self, end: impl Into<Location>) -> Self {
+                self.end = Some(end.into());
+                self
+            }
+            pub fn restrict_to_function(mut self, restrict_to_function: impl Into<bool>) -> Self {
+                self.restrict_to_function = Some(restrict_to_function.into());
+                self
+            }
+            pub fn build(self) -> Result<GetPossibleBreakpointsParams, String> {
+                Ok(GetPossibleBreakpointsParams {
+                    start: self.start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start))
+                    })?,
+                    end: self.end,
+                    restrict_to_function: self.restrict_to_function,
+                })
+            }
+        }
+        impl GetPossibleBreakpointsParams {
+            pub const IDENTIFIER: &'static str = "Debugger.getPossibleBreakpoints";
+        }
+        impl chromiumoxide_types::Method for GetPossibleBreakpointsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetPossibleBreakpointsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns possible locations for breakpoint. scriptId in start and end range locations should be\nthe same.\n[getPossibleBreakpoints](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-getPossibleBreakpoints)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetPossibleBreakpointsReturns {
+            #[doc = "List of the possible breakpoint locations."]
+            #[serde(rename = "locations")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub locations: Vec<BreakLocation>,
+        }
+        impl GetPossibleBreakpointsReturns {
+            pub fn new(locations: Vec<BreakLocation>) -> Self {
+                Self { locations }
+            }
+        }
+        impl GetPossibleBreakpointsReturns {
+            pub fn builder() -> GetPossibleBreakpointsReturnsBuilder {
+                GetPossibleBreakpointsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPossibleBreakpointsReturnsBuilder {
+            locations: Option<Vec<BreakLocation>>,
+        }
+        impl GetPossibleBreakpointsReturnsBuilder {
+            pub fn location(mut self, location: impl Into<BreakLocation>) -> Self {
+                let v = self.locations.get_or_insert(Vec::new());
+                v.push(location.into());
+                self
+            }
+            pub fn locations<I, S>(mut self, locations: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<BreakLocation>,
+            {
+                let v = self.locations.get_or_insert(Vec::new());
+                for val in locations {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetPossibleBreakpointsReturns, String> {
+                Ok(GetPossibleBreakpointsReturns {
+                    locations: self.locations.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(locations))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetPossibleBreakpointsParams {
+            type Response = GetPossibleBreakpointsReturns;
+        }
+        #[doc = "Returns source for the script with given id.\n[getScriptSource](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-getScriptSource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetScriptSourceParams {
+            #[doc = "Id of the script to get source for."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+        }
+        impl GetScriptSourceParams {
+            pub fn new(script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                }
+            }
+        }
+        impl GetScriptSourceParams {
+            pub fn builder() -> GetScriptSourceParamsBuilder {
+                GetScriptSourceParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetScriptSourceParamsBuilder {
+            script_id: Option<super::runtime::ScriptId>,
+        }
+        impl GetScriptSourceParamsBuilder {
+            pub fn script_id(mut self, script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetScriptSourceParams, String> {
+                Ok(GetScriptSourceParams {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                })
+            }
+        }
+        impl GetScriptSourceParams {
+            pub const IDENTIFIER: &'static str = "Debugger.getScriptSource";
+        }
+        impl chromiumoxide_types::Method for GetScriptSourceParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetScriptSourceParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns source for the script with given id.\n[getScriptSource](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-getScriptSource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetScriptSourceReturns {
+            #[doc = "Script source (empty in case of Wasm bytecode)."]
+            #[serde(rename = "scriptSource")]
+            pub script_source: String,
+            #[doc = "Wasm bytecode."]
+            #[serde(rename = "bytecode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub bytecode: Option<chromiumoxide_types::Binary>,
+        }
+        impl GetScriptSourceReturns {
+            pub fn new(script_source: impl Into<String>) -> Self {
+                Self {
+                    script_source: script_source.into(),
+                    bytecode: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetScriptSourceReturns {
+            fn from(url: T) -> Self {
+                GetScriptSourceReturns::new(url)
+            }
+        }
+        impl GetScriptSourceReturns {
+            pub fn builder() -> GetScriptSourceReturnsBuilder {
+                GetScriptSourceReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetScriptSourceReturnsBuilder {
+            script_source: Option<String>,
+            bytecode: Option<chromiumoxide_types::Binary>,
+        }
+        impl GetScriptSourceReturnsBuilder {
+            pub fn script_source(mut self, script_source: impl Into<String>) -> Self {
+                self.script_source = Some(script_source.into());
+                self
+            }
+            pub fn bytecode(mut self, bytecode: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.bytecode = Some(bytecode.into());
+                self
+            }
+            pub fn build(self) -> Result<GetScriptSourceReturns, String> {
+                Ok(GetScriptSourceReturns {
+                    script_source: self.script_source.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_source))
+                    })?,
+                    bytecode: self.bytecode,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetScriptSourceParams {
+            type Response = GetScriptSourceReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DisassembleWasmModuleParams {
+            #[doc = "Id of the script to disassemble"]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+        }
+        impl DisassembleWasmModuleParams {
+            pub fn new(script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                }
+            }
+        }
+        impl DisassembleWasmModuleParams {
+            pub fn builder() -> DisassembleWasmModuleParamsBuilder {
+                DisassembleWasmModuleParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DisassembleWasmModuleParamsBuilder {
+            script_id: Option<super::runtime::ScriptId>,
+        }
+        impl DisassembleWasmModuleParamsBuilder {
+            pub fn script_id(mut self, script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn build(self) -> Result<DisassembleWasmModuleParams, String> {
+                Ok(DisassembleWasmModuleParams {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                })
+            }
+        }
+        impl DisassembleWasmModuleParams {
+            pub const IDENTIFIER: &'static str = "Debugger.disassembleWasmModule";
+        }
+        impl chromiumoxide_types::Method for DisassembleWasmModuleParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisassembleWasmModuleParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DisassembleWasmModuleReturns {
+            #[doc = "For large modules, return a stream from which additional chunks of\ndisassembly can be read successively."]
+            #[serde(rename = "streamId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stream_id: Option<String>,
+            #[doc = "The total number of lines in the disassembly text."]
+            #[serde(rename = "totalNumberOfLines")]
+            pub total_number_of_lines: i64,
+            #[doc = "The offsets of all function bodies, in the format [start1, end1,\nstart2, end2, ...] where all ends are exclusive."]
+            #[serde(rename = "functionBodyOffsets")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub function_body_offsets: Vec<i64>,
+            #[doc = "The first chunk of disassembly."]
+            #[serde(rename = "chunk")]
+            pub chunk: WasmDisassemblyChunk,
+        }
+        impl DisassembleWasmModuleReturns {
+            pub fn new(
+                total_number_of_lines: impl Into<i64>,
+                function_body_offsets: Vec<i64>,
+                chunk: impl Into<WasmDisassemblyChunk>,
+            ) -> Self {
+                Self {
+                    total_number_of_lines: total_number_of_lines.into(),
+                    function_body_offsets,
+                    chunk: chunk.into(),
+                    stream_id: None,
+                }
+            }
+        }
+        impl DisassembleWasmModuleReturns {
+            pub fn builder() -> DisassembleWasmModuleReturnsBuilder {
+                DisassembleWasmModuleReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DisassembleWasmModuleReturnsBuilder {
+            stream_id: Option<String>,
+            total_number_of_lines: Option<i64>,
+            function_body_offsets: Option<Vec<i64>>,
+            chunk: Option<WasmDisassemblyChunk>,
+        }
+        impl DisassembleWasmModuleReturnsBuilder {
+            pub fn stream_id(mut self, stream_id: impl Into<String>) -> Self {
+                self.stream_id = Some(stream_id.into());
+                self
+            }
+            pub fn total_number_of_lines(mut self, total_number_of_lines: impl Into<i64>) -> Self {
+                self.total_number_of_lines = Some(total_number_of_lines.into());
+                self
+            }
+            pub fn function_body_offset(mut self, function_body_offset: impl Into<i64>) -> Self {
+                let v = self.function_body_offsets.get_or_insert(Vec::new());
+                v.push(function_body_offset.into());
+                self
+            }
+            pub fn function_body_offsets<I, S>(mut self, function_body_offsets: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.function_body_offsets.get_or_insert(Vec::new());
+                for val in function_body_offsets {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn chunk(mut self, chunk: impl Into<WasmDisassemblyChunk>) -> Self {
+                self.chunk = Some(chunk.into());
+                self
+            }
+            pub fn build(self) -> Result<DisassembleWasmModuleReturns, String> {
+                Ok(DisassembleWasmModuleReturns {
+                    stream_id: self.stream_id,
+                    total_number_of_lines: self.total_number_of_lines.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(total_number_of_lines)
+                        )
+                    })?,
+                    function_body_offsets: self.function_body_offsets.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(function_body_offsets)
+                        )
+                    })?,
+                    chunk: self.chunk.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(chunk))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for DisassembleWasmModuleParams {
+            type Response = DisassembleWasmModuleReturns;
+        }
+        #[doc = "Disassemble the next chunk of lines for the module corresponding to the\nstream. If disassembly is complete, this API will invalidate the streamId\nand return an empty chunk. Any subsequent calls for the now invalid stream\nwill return errors.\n[nextWasmDisassemblyChunk](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-nextWasmDisassemblyChunk)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct NextWasmDisassemblyChunkParams {
+            #[serde(rename = "streamId")]
+            pub stream_id: String,
+        }
+        impl NextWasmDisassemblyChunkParams {
+            pub fn new(stream_id: impl Into<String>) -> Self {
+                Self {
+                    stream_id: stream_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for NextWasmDisassemblyChunkParams {
+            fn from(url: T) -> Self {
+                NextWasmDisassemblyChunkParams::new(url)
+            }
+        }
+        impl NextWasmDisassemblyChunkParams {
+            pub fn builder() -> NextWasmDisassemblyChunkParamsBuilder {
+                NextWasmDisassemblyChunkParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct NextWasmDisassemblyChunkParamsBuilder {
+            stream_id: Option<String>,
+        }
+        impl NextWasmDisassemblyChunkParamsBuilder {
+            pub fn stream_id(mut self, stream_id: impl Into<String>) -> Self {
+                self.stream_id = Some(stream_id.into());
+                self
+            }
+            pub fn build(self) -> Result<NextWasmDisassemblyChunkParams, String> {
+                Ok(NextWasmDisassemblyChunkParams {
+                    stream_id: self.stream_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(stream_id))
+                    })?,
+                })
+            }
+        }
+        impl NextWasmDisassemblyChunkParams {
+            pub const IDENTIFIER: &'static str = "Debugger.nextWasmDisassemblyChunk";
+        }
+        impl chromiumoxide_types::Method for NextWasmDisassemblyChunkParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for NextWasmDisassemblyChunkParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disassemble the next chunk of lines for the module corresponding to the\nstream. If disassembly is complete, this API will invalidate the streamId\nand return an empty chunk. Any subsequent calls for the now invalid stream\nwill return errors.\n[nextWasmDisassemblyChunk](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-nextWasmDisassemblyChunk)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct NextWasmDisassemblyChunkReturns {
+            #[doc = "The next chunk of disassembly."]
+            #[serde(rename = "chunk")]
+            pub chunk: WasmDisassemblyChunk,
+        }
+        impl NextWasmDisassemblyChunkReturns {
+            pub fn new(chunk: impl Into<WasmDisassemblyChunk>) -> Self {
+                Self {
+                    chunk: chunk.into(),
+                }
+            }
+        }
+        impl NextWasmDisassemblyChunkReturns {
+            pub fn builder() -> NextWasmDisassemblyChunkReturnsBuilder {
+                NextWasmDisassemblyChunkReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct NextWasmDisassemblyChunkReturnsBuilder {
+            chunk: Option<WasmDisassemblyChunk>,
+        }
+        impl NextWasmDisassemblyChunkReturnsBuilder {
+            pub fn chunk(mut self, chunk: impl Into<WasmDisassemblyChunk>) -> Self {
+                self.chunk = Some(chunk.into());
+                self
+            }
+            pub fn build(self) -> Result<NextWasmDisassemblyChunkReturns, String> {
+                Ok(NextWasmDisassemblyChunkReturns {
+                    chunk: self.chunk.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(chunk))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for NextWasmDisassemblyChunkParams {
+            type Response = NextWasmDisassemblyChunkReturns;
+        }
+        #[doc = "Returns stack trace with given `stackTraceId`.\n[getStackTrace](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-getStackTrace)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetStackTraceParams {
+            #[serde(rename = "stackTraceId")]
+            pub stack_trace_id: super::runtime::StackTraceId,
+        }
+        impl GetStackTraceParams {
+            pub fn new(stack_trace_id: impl Into<super::runtime::StackTraceId>) -> Self {
+                Self {
+                    stack_trace_id: stack_trace_id.into(),
+                }
+            }
+        }
+        impl GetStackTraceParams {
+            pub fn builder() -> GetStackTraceParamsBuilder {
+                GetStackTraceParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetStackTraceParamsBuilder {
+            stack_trace_id: Option<super::runtime::StackTraceId>,
+        }
+        impl GetStackTraceParamsBuilder {
+            pub fn stack_trace_id(
+                mut self,
+                stack_trace_id: impl Into<super::runtime::StackTraceId>,
+            ) -> Self {
+                self.stack_trace_id = Some(stack_trace_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetStackTraceParams, String> {
+                Ok(GetStackTraceParams {
+                    stack_trace_id: self.stack_trace_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(stack_trace_id))
+                    })?,
+                })
+            }
+        }
+        impl GetStackTraceParams {
+            pub const IDENTIFIER: &'static str = "Debugger.getStackTrace";
+        }
+        impl chromiumoxide_types::Method for GetStackTraceParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetStackTraceParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns stack trace with given `stackTraceId`.\n[getStackTrace](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-getStackTrace)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetStackTraceReturns {
+            #[serde(rename = "stackTrace")]
+            pub stack_trace: super::runtime::StackTrace,
+        }
+        impl GetStackTraceReturns {
+            pub fn new(stack_trace: impl Into<super::runtime::StackTrace>) -> Self {
+                Self {
+                    stack_trace: stack_trace.into(),
+                }
+            }
+        }
+        impl GetStackTraceReturns {
+            pub fn builder() -> GetStackTraceReturnsBuilder {
+                GetStackTraceReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetStackTraceReturnsBuilder {
+            stack_trace: Option<super::runtime::StackTrace>,
+        }
+        impl GetStackTraceReturnsBuilder {
+            pub fn stack_trace(
+                mut self,
+                stack_trace: impl Into<super::runtime::StackTrace>,
+            ) -> Self {
+                self.stack_trace = Some(stack_trace.into());
+                self
+            }
+            pub fn build(self) -> Result<GetStackTraceReturns, String> {
+                Ok(GetStackTraceReturns {
+                    stack_trace: self.stack_trace.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(stack_trace))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetStackTraceParams {
+            type Response = GetStackTraceReturns;
+        }
+        #[doc = "Stops on the next JavaScript statement.\n[pause](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-pause)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct PauseParams {}
+        impl PauseParams {
+            pub const IDENTIFIER: &'static str = "Debugger.pause";
+        }
+        impl chromiumoxide_types::Method for PauseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for PauseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Stops on the next JavaScript statement.\n[pause](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-pause)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct PauseReturns {}
+        impl chromiumoxide_types::Command for PauseParams {
+            type Response = PauseReturns;
+        }
+        #[doc = "Removes JavaScript breakpoint.\n[removeBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-removeBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveBreakpointParams {
+            #[serde(rename = "breakpointId")]
+            pub breakpoint_id: BreakpointId,
+        }
+        impl RemoveBreakpointParams {
+            pub fn new(breakpoint_id: impl Into<BreakpointId>) -> Self {
+                Self {
+                    breakpoint_id: breakpoint_id.into(),
+                }
+            }
+        }
+        impl RemoveBreakpointParams {
+            pub fn builder() -> RemoveBreakpointParamsBuilder {
+                RemoveBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveBreakpointParamsBuilder {
+            breakpoint_id: Option<BreakpointId>,
+        }
+        impl RemoveBreakpointParamsBuilder {
+            pub fn breakpoint_id(mut self, breakpoint_id: impl Into<BreakpointId>) -> Self {
+                self.breakpoint_id = Some(breakpoint_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveBreakpointParams, String> {
+                Ok(RemoveBreakpointParams {
+                    breakpoint_id: self.breakpoint_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(breakpoint_id))
+                    })?,
+                })
+            }
+        }
+        impl RemoveBreakpointParams {
+            pub const IDENTIFIER: &'static str = "Debugger.removeBreakpoint";
+        }
+        impl chromiumoxide_types::Method for RemoveBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes JavaScript breakpoint.\n[removeBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-removeBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveBreakpointReturns {}
+        impl chromiumoxide_types::Command for RemoveBreakpointParams {
+            type Response = RemoveBreakpointReturns;
+        }
+        #[doc = "Restarts particular call frame from the beginning. The old, deprecated\nbehavior of `restartFrame` is to stay paused and allow further CDP commands\nafter a restart was scheduled. This can cause problems with restarting, so\nwe now continue execution immediatly after it has been scheduled until we\nreach the beginning of the restarted frame.\n\nTo stay back-wards compatible, `restartFrame` now expects a `mode`\nparameter to be present. If the `mode` parameter is missing, `restartFrame`\nerrors out.\n\nThe various return values are deprecated and `callFrames` is always empty.\nUse the call frames from the `Debugger#paused` events instead, that fires\nonce V8 pauses at the beginning of the restarted function.\n[restartFrame](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-restartFrame)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RestartFrameParams {
+            #[doc = "Call frame identifier to evaluate on."]
+            #[serde(rename = "callFrameId")]
+            pub call_frame_id: CallFrameId,
+            #[doc = "The `mode` parameter must be present and set to 'StepInto', otherwise\n`restartFrame` will error out."]
+            #[serde(rename = "mode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub mode: Option<RestartFrameMode>,
+        }
+        #[doc = "The `mode` parameter must be present and set to 'StepInto', otherwise\n`restartFrame` will error out."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum RestartFrameMode {
+            #[doc = "Pause at the beginning of the restarted function"]
+            #[serde(rename = "StepInto")]
+            StepInto,
+        }
+        impl AsRef<str> for RestartFrameMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    RestartFrameMode::StepInto => "StepInto",
+                }
+            }
+        }
+        impl ::std::str::FromStr for RestartFrameMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "StepInto" | "stepinto" => Ok(RestartFrameMode::StepInto),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl RestartFrameParams {
+            pub fn new(call_frame_id: impl Into<CallFrameId>) -> Self {
+                Self {
+                    call_frame_id: call_frame_id.into(),
+                    mode: None,
+                }
+            }
+        }
+        impl RestartFrameParams {
+            pub fn builder() -> RestartFrameParamsBuilder {
+                RestartFrameParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RestartFrameParamsBuilder {
+            call_frame_id: Option<CallFrameId>,
+            mode: Option<RestartFrameMode>,
+        }
+        impl RestartFrameParamsBuilder {
+            pub fn call_frame_id(mut self, call_frame_id: impl Into<CallFrameId>) -> Self {
+                self.call_frame_id = Some(call_frame_id.into());
+                self
+            }
+            pub fn mode(mut self, mode: impl Into<RestartFrameMode>) -> Self {
+                self.mode = Some(mode.into());
+                self
+            }
+            pub fn build(self) -> Result<RestartFrameParams, String> {
+                Ok(RestartFrameParams {
+                    call_frame_id: self.call_frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(call_frame_id))
+                    })?,
+                    mode: self.mode,
+                })
+            }
+        }
+        impl RestartFrameParams {
+            pub const IDENTIFIER: &'static str = "Debugger.restartFrame";
+        }
+        impl chromiumoxide_types::Method for RestartFrameParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RestartFrameParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Restarts particular call frame from the beginning. The old, deprecated\nbehavior of `restartFrame` is to stay paused and allow further CDP commands\nafter a restart was scheduled. This can cause problems with restarting, so\nwe now continue execution immediatly after it has been scheduled until we\nreach the beginning of the restarted frame.\n\nTo stay back-wards compatible, `restartFrame` now expects a `mode`\nparameter to be present. If the `mode` parameter is missing, `restartFrame`\nerrors out.\n\nThe various return values are deprecated and `callFrames` is always empty.\nUse the call frames from the `Debugger#paused` events instead, that fires\nonce V8 pauses at the beginning of the restarted function.\n[restartFrame](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-restartFrame)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RestartFrameReturns {}
+        impl chromiumoxide_types::Command for RestartFrameParams {
+            type Response = RestartFrameReturns;
+        }
+        #[doc = "Resumes JavaScript execution.\n[resume](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-resume)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResumeParams {
+            #[doc = "Set to true to terminate execution upon resuming execution. In contrast\nto Runtime.terminateExecution, this will allows to execute further\nJavaScript (i.e. via evaluation) until execution of the paused code\nis actually resumed, at which point termination is triggered.\nIf execution is currently not paused, this parameter has no effect."]
+            #[serde(rename = "terminateOnResume")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub terminate_on_resume: Option<bool>,
+        }
+        impl ResumeParams {
+            pub fn builder() -> ResumeParamsBuilder {
+                ResumeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResumeParamsBuilder {
+            terminate_on_resume: Option<bool>,
+        }
+        impl ResumeParamsBuilder {
+            pub fn terminate_on_resume(mut self, terminate_on_resume: impl Into<bool>) -> Self {
+                self.terminate_on_resume = Some(terminate_on_resume.into());
+                self
+            }
+            pub fn build(self) -> ResumeParams {
+                ResumeParams {
+                    terminate_on_resume: self.terminate_on_resume,
+                }
+            }
+        }
+        impl ResumeParams {
+            pub const IDENTIFIER: &'static str = "Debugger.resume";
+        }
+        impl chromiumoxide_types::Method for ResumeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ResumeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Resumes JavaScript execution.\n[resume](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-resume)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResumeReturns {}
+        impl chromiumoxide_types::Command for ResumeParams {
+            type Response = ResumeReturns;
+        }
+        #[doc = "Searches for given string in script content.\n[searchInContent](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-searchInContent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SearchInContentParams {
+            #[doc = "Id of the script to search in."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+            #[doc = "String to search for."]
+            #[serde(rename = "query")]
+            pub query: String,
+            #[doc = "If true, search is case sensitive."]
+            #[serde(rename = "caseSensitive")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub case_sensitive: Option<bool>,
+            #[doc = "If true, treats string parameter as regex."]
+            #[serde(rename = "isRegex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_regex: Option<bool>,
+        }
+        impl SearchInContentParams {
+            pub fn new(
+                script_id: impl Into<super::runtime::ScriptId>,
+                query: impl Into<String>,
+            ) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                    query: query.into(),
+                    case_sensitive: None,
+                    is_regex: None,
+                }
+            }
+        }
+        impl SearchInContentParams {
+            pub fn builder() -> SearchInContentParamsBuilder {
+                SearchInContentParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SearchInContentParamsBuilder {
+            script_id: Option<super::runtime::ScriptId>,
+            query: Option<String>,
+            case_sensitive: Option<bool>,
+            is_regex: Option<bool>,
+        }
+        impl SearchInContentParamsBuilder {
+            pub fn script_id(mut self, script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn query(mut self, query: impl Into<String>) -> Self {
+                self.query = Some(query.into());
+                self
+            }
+            pub fn case_sensitive(mut self, case_sensitive: impl Into<bool>) -> Self {
+                self.case_sensitive = Some(case_sensitive.into());
+                self
+            }
+            pub fn is_regex(mut self, is_regex: impl Into<bool>) -> Self {
+                self.is_regex = Some(is_regex.into());
+                self
+            }
+            pub fn build(self) -> Result<SearchInContentParams, String> {
+                Ok(SearchInContentParams {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    query: self.query.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(query))
+                    })?,
+                    case_sensitive: self.case_sensitive,
+                    is_regex: self.is_regex,
+                })
+            }
+        }
+        impl SearchInContentParams {
+            pub const IDENTIFIER: &'static str = "Debugger.searchInContent";
+        }
+        impl chromiumoxide_types::Method for SearchInContentParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SearchInContentParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Searches for given string in script content.\n[searchInContent](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-searchInContent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SearchInContentReturns {
+            #[doc = "List of search matches."]
+            #[serde(rename = "result")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub result: Vec<SearchMatch>,
+        }
+        impl SearchInContentReturns {
+            pub fn new(result: Vec<SearchMatch>) -> Self {
+                Self { result }
+            }
+        }
+        impl SearchInContentReturns {
+            pub fn builder() -> SearchInContentReturnsBuilder {
+                SearchInContentReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SearchInContentReturnsBuilder {
+            result: Option<Vec<SearchMatch>>,
+        }
+        impl SearchInContentReturnsBuilder {
+            pub fn result(mut self, result: impl Into<SearchMatch>) -> Self {
+                let v = self.result.get_or_insert(Vec::new());
+                v.push(result.into());
+                self
+            }
+            pub fn results<I, S>(mut self, results: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SearchMatch>,
+            {
+                let v = self.result.get_or_insert(Vec::new());
+                for val in results {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SearchInContentReturns, String> {
+                Ok(SearchInContentReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SearchInContentParams {
+            type Response = SearchInContentReturns;
+        }
+        #[doc = "Enables or disables async call stacks tracking.\n[setAsyncCallStackDepth](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setAsyncCallStackDepth)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAsyncCallStackDepthParams {
+            #[doc = "Maximum depth of async call stacks. Setting to `0` will effectively disable collecting async\ncall stacks (default)."]
+            #[serde(rename = "maxDepth")]
+            pub max_depth: i64,
+        }
+        impl SetAsyncCallStackDepthParams {
+            pub fn new(max_depth: impl Into<i64>) -> Self {
+                Self {
+                    max_depth: max_depth.into(),
+                }
+            }
+        }
+        impl SetAsyncCallStackDepthParams {
+            pub fn builder() -> SetAsyncCallStackDepthParamsBuilder {
+                SetAsyncCallStackDepthParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAsyncCallStackDepthParamsBuilder {
+            max_depth: Option<i64>,
+        }
+        impl SetAsyncCallStackDepthParamsBuilder {
+            pub fn max_depth(mut self, max_depth: impl Into<i64>) -> Self {
+                self.max_depth = Some(max_depth.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAsyncCallStackDepthParams, String> {
+                Ok(SetAsyncCallStackDepthParams {
+                    max_depth: self.max_depth.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(max_depth))
+                    })?,
+                })
+            }
+        }
+        impl SetAsyncCallStackDepthParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setAsyncCallStackDepth";
+        }
+        impl chromiumoxide_types::Method for SetAsyncCallStackDepthParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAsyncCallStackDepthParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables or disables async call stacks tracking.\n[setAsyncCallStackDepth](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setAsyncCallStackDepth)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAsyncCallStackDepthReturns {}
+        impl chromiumoxide_types::Command for SetAsyncCallStackDepthParams {
+            type Response = SetAsyncCallStackDepthReturns;
+        }
+        #[doc = "Replace previous blackbox execution contexts with passed ones. Forces backend to skip\nstepping/pausing in scripts in these execution contexts. VM will try to leave blackboxed script by\nperforming 'step in' several times, finally resorting to 'step out' if unsuccessful.\n[setBlackboxExecutionContexts](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBlackboxExecutionContexts)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBlackboxExecutionContextsParams {
+            #[doc = "Array of execution context unique ids for the debugger to ignore."]
+            #[serde(rename = "uniqueIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub unique_ids: Vec<String>,
+        }
+        impl SetBlackboxExecutionContextsParams {
+            pub fn new(unique_ids: Vec<String>) -> Self {
+                Self { unique_ids }
+            }
+        }
+        impl SetBlackboxExecutionContextsParams {
+            pub fn builder() -> SetBlackboxExecutionContextsParamsBuilder {
+                SetBlackboxExecutionContextsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBlackboxExecutionContextsParamsBuilder {
+            unique_ids: Option<Vec<String>>,
+        }
+        impl SetBlackboxExecutionContextsParamsBuilder {
+            pub fn unique_id(mut self, unique_id: impl Into<String>) -> Self {
+                let v = self.unique_ids.get_or_insert(Vec::new());
+                v.push(unique_id.into());
+                self
+            }
+            pub fn unique_ids<I, S>(mut self, unique_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.unique_ids.get_or_insert(Vec::new());
+                for val in unique_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetBlackboxExecutionContextsParams, String> {
+                Ok(SetBlackboxExecutionContextsParams {
+                    unique_ids: self.unique_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(unique_ids))
+                    })?,
+                })
+            }
+        }
+        impl SetBlackboxExecutionContextsParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setBlackboxExecutionContexts";
+        }
+        impl chromiumoxide_types::Method for SetBlackboxExecutionContextsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBlackboxExecutionContextsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Replace previous blackbox execution contexts with passed ones. Forces backend to skip\nstepping/pausing in scripts in these execution contexts. VM will try to leave blackboxed script by\nperforming 'step in' several times, finally resorting to 'step out' if unsuccessful.\n[setBlackboxExecutionContexts](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBlackboxExecutionContexts)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetBlackboxExecutionContextsReturns {}
+        impl chromiumoxide_types::Command for SetBlackboxExecutionContextsParams {
+            type Response = SetBlackboxExecutionContextsReturns;
+        }
+        #[doc = "Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in\nscripts with url matching one of the patterns. VM will try to leave blackboxed script by\nperforming 'step in' several times, finally resorting to 'step out' if unsuccessful.\n[setBlackboxPatterns](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBlackboxPatterns)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBlackboxPatternsParams {
+            #[doc = "Array of regexps that will be used to check script url for blackbox state."]
+            #[serde(rename = "patterns")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub patterns: Vec<String>,
+            #[doc = "If true, also ignore scripts with no source url."]
+            #[serde(rename = "skipAnonymous")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub skip_anonymous: Option<bool>,
+        }
+        impl SetBlackboxPatternsParams {
+            pub fn new(patterns: Vec<String>) -> Self {
+                Self {
+                    patterns,
+                    skip_anonymous: None,
+                }
+            }
+        }
+        impl SetBlackboxPatternsParams {
+            pub fn builder() -> SetBlackboxPatternsParamsBuilder {
+                SetBlackboxPatternsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBlackboxPatternsParamsBuilder {
+            patterns: Option<Vec<String>>,
+            skip_anonymous: Option<bool>,
+        }
+        impl SetBlackboxPatternsParamsBuilder {
+            pub fn pattern(mut self, pattern: impl Into<String>) -> Self {
+                let v = self.patterns.get_or_insert(Vec::new());
+                v.push(pattern.into());
+                self
+            }
+            pub fn patterns<I, S>(mut self, patterns: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.patterns.get_or_insert(Vec::new());
+                for val in patterns {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn skip_anonymous(mut self, skip_anonymous: impl Into<bool>) -> Self {
+                self.skip_anonymous = Some(skip_anonymous.into());
+                self
+            }
+            pub fn build(self) -> Result<SetBlackboxPatternsParams, String> {
+                Ok(SetBlackboxPatternsParams {
+                    patterns: self.patterns.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(patterns))
+                    })?,
+                    skip_anonymous: self.skip_anonymous,
+                })
+            }
+        }
+        impl SetBlackboxPatternsParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setBlackboxPatterns";
+        }
+        impl chromiumoxide_types::Method for SetBlackboxPatternsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBlackboxPatternsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in\nscripts with url matching one of the patterns. VM will try to leave blackboxed script by\nperforming 'step in' several times, finally resorting to 'step out' if unsuccessful.\n[setBlackboxPatterns](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBlackboxPatterns)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetBlackboxPatternsReturns {}
+        impl chromiumoxide_types::Command for SetBlackboxPatternsParams {
+            type Response = SetBlackboxPatternsReturns;
+        }
+        #[doc = "Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted\nscripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.\nPositions array contains positions where blackbox state is changed. First interval isn't\nblackboxed. Array should be sorted.\n[setBlackboxedRanges](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBlackboxedRanges)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBlackboxedRangesParams {
+            #[doc = "Id of the script."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+            #[serde(rename = "positions")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub positions: Vec<ScriptPosition>,
+        }
+        impl SetBlackboxedRangesParams {
+            pub fn new(
+                script_id: impl Into<super::runtime::ScriptId>,
+                positions: Vec<ScriptPosition>,
+            ) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                    positions,
+                }
+            }
+        }
+        impl SetBlackboxedRangesParams {
+            pub fn builder() -> SetBlackboxedRangesParamsBuilder {
+                SetBlackboxedRangesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBlackboxedRangesParamsBuilder {
+            script_id: Option<super::runtime::ScriptId>,
+            positions: Option<Vec<ScriptPosition>>,
+        }
+        impl SetBlackboxedRangesParamsBuilder {
+            pub fn script_id(mut self, script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn position(mut self, position: impl Into<ScriptPosition>) -> Self {
+                let v = self.positions.get_or_insert(Vec::new());
+                v.push(position.into());
+                self
+            }
+            pub fn positions<I, S>(mut self, positions: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ScriptPosition>,
+            {
+                let v = self.positions.get_or_insert(Vec::new());
+                for val in positions {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetBlackboxedRangesParams, String> {
+                Ok(SetBlackboxedRangesParams {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    positions: self.positions.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(positions))
+                    })?,
+                })
+            }
+        }
+        impl SetBlackboxedRangesParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setBlackboxedRanges";
+        }
+        impl chromiumoxide_types::Method for SetBlackboxedRangesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBlackboxedRangesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted\nscripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.\nPositions array contains positions where blackbox state is changed. First interval isn't\nblackboxed. Array should be sorted.\n[setBlackboxedRanges](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBlackboxedRanges)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetBlackboxedRangesReturns {}
+        impl chromiumoxide_types::Command for SetBlackboxedRangesParams {
+            type Response = SetBlackboxedRangesReturns;
+        }
+        #[doc = "Sets JavaScript breakpoint at a given location.\n[setBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBreakpointParams {
+            #[doc = "Location to set breakpoint in."]
+            #[serde(rename = "location")]
+            pub location: Location,
+            #[doc = "Expression to use as a breakpoint condition. When specified, debugger will only stop on the\nbreakpoint if this expression evaluates to true."]
+            #[serde(rename = "condition")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub condition: Option<String>,
+        }
+        impl SetBreakpointParams {
+            pub fn new(location: impl Into<Location>) -> Self {
+                Self {
+                    location: location.into(),
+                    condition: None,
+                }
+            }
+        }
+        impl SetBreakpointParams {
+            pub fn builder() -> SetBreakpointParamsBuilder {
+                SetBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBreakpointParamsBuilder {
+            location: Option<Location>,
+            condition: Option<String>,
+        }
+        impl SetBreakpointParamsBuilder {
+            pub fn location(mut self, location: impl Into<Location>) -> Self {
+                self.location = Some(location.into());
+                self
+            }
+            pub fn condition(mut self, condition: impl Into<String>) -> Self {
+                self.condition = Some(condition.into());
+                self
+            }
+            pub fn build(self) -> Result<SetBreakpointParams, String> {
+                Ok(SetBreakpointParams {
+                    location: self.location.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(location))
+                    })?,
+                    condition: self.condition,
+                })
+            }
+        }
+        impl SetBreakpointParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setBreakpoint";
+        }
+        impl chromiumoxide_types::Method for SetBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets JavaScript breakpoint at a given location.\n[setBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBreakpointReturns {
+            #[doc = "Id of the created breakpoint for further reference."]
+            #[serde(rename = "breakpointId")]
+            pub breakpoint_id: BreakpointId,
+            #[doc = "Location this breakpoint resolved into."]
+            #[serde(rename = "actualLocation")]
+            pub actual_location: Location,
+        }
+        impl SetBreakpointReturns {
+            pub fn new(
+                breakpoint_id: impl Into<BreakpointId>,
+                actual_location: impl Into<Location>,
+            ) -> Self {
+                Self {
+                    breakpoint_id: breakpoint_id.into(),
+                    actual_location: actual_location.into(),
+                }
+            }
+        }
+        impl SetBreakpointReturns {
+            pub fn builder() -> SetBreakpointReturnsBuilder {
+                SetBreakpointReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBreakpointReturnsBuilder {
+            breakpoint_id: Option<BreakpointId>,
+            actual_location: Option<Location>,
+        }
+        impl SetBreakpointReturnsBuilder {
+            pub fn breakpoint_id(mut self, breakpoint_id: impl Into<BreakpointId>) -> Self {
+                self.breakpoint_id = Some(breakpoint_id.into());
+                self
+            }
+            pub fn actual_location(mut self, actual_location: impl Into<Location>) -> Self {
+                self.actual_location = Some(actual_location.into());
+                self
+            }
+            pub fn build(self) -> Result<SetBreakpointReturns, String> {
+                Ok(SetBreakpointReturns {
+                    breakpoint_id: self.breakpoint_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(breakpoint_id))
+                    })?,
+                    actual_location: self.actual_location.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(actual_location))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetBreakpointParams {
+            type Response = SetBreakpointReturns;
+        }
+        #[doc = "Sets instrumentation breakpoint.\n[setInstrumentationBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setInstrumentationBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetInstrumentationBreakpointParams {
+            #[doc = "Instrumentation name."]
+            #[serde(rename = "instrumentation")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub instrumentation: SetInstrumentationBreakpointInstrumentation,
+        }
+        #[doc = "Instrumentation name."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SetInstrumentationBreakpointInstrumentation {
+            #[serde(rename = "beforeScriptExecution")]
+            BeforeScriptExecution,
+            #[serde(rename = "beforeScriptWithSourceMapExecution")]
+            BeforeScriptWithSourceMapExecution,
+        }
+        impl AsRef<str> for SetInstrumentationBreakpointInstrumentation {
+            fn as_ref(&self) -> &str {
+                match self { SetInstrumentationBreakpointInstrumentation :: BeforeScriptExecution => "beforeScriptExecution" , SetInstrumentationBreakpointInstrumentation :: BeforeScriptWithSourceMapExecution => "beforeScriptWithSourceMapExecution" }
+            }
+        }
+        impl ::std::str::FromStr for SetInstrumentationBreakpointInstrumentation {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s { "beforeScriptExecution" | "BeforeScriptExecution" | "beforescriptexecution" => Ok (SetInstrumentationBreakpointInstrumentation :: BeforeScriptExecution) , "beforeScriptWithSourceMapExecution" | "BeforeScriptWithSourceMapExecution" | "beforescriptwithsourcemapexecution" => Ok (SetInstrumentationBreakpointInstrumentation :: BeforeScriptWithSourceMapExecution) , _ => Err (s . to_string ()) }
+            }
+        }
+        impl SetInstrumentationBreakpointParams {
+            pub fn new(
+                instrumentation: impl Into<SetInstrumentationBreakpointInstrumentation>,
+            ) -> Self {
+                Self {
+                    instrumentation: instrumentation.into(),
+                }
+            }
+        }
+        impl SetInstrumentationBreakpointParams {
+            pub fn builder() -> SetInstrumentationBreakpointParamsBuilder {
+                SetInstrumentationBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetInstrumentationBreakpointParamsBuilder {
+            instrumentation: Option<SetInstrumentationBreakpointInstrumentation>,
+        }
+        impl SetInstrumentationBreakpointParamsBuilder {
+            pub fn instrumentation(
+                mut self,
+                instrumentation: impl Into<SetInstrumentationBreakpointInstrumentation>,
+            ) -> Self {
+                self.instrumentation = Some(instrumentation.into());
+                self
+            }
+            pub fn build(self) -> Result<SetInstrumentationBreakpointParams, String> {
+                Ok(SetInstrumentationBreakpointParams {
+                    instrumentation: self.instrumentation.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(instrumentation))
+                    })?,
+                })
+            }
+        }
+        impl SetInstrumentationBreakpointParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setInstrumentationBreakpoint";
+        }
+        impl chromiumoxide_types::Method for SetInstrumentationBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetInstrumentationBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets instrumentation breakpoint.\n[setInstrumentationBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setInstrumentationBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetInstrumentationBreakpointReturns {
+            #[doc = "Id of the created breakpoint for further reference."]
+            #[serde(rename = "breakpointId")]
+            pub breakpoint_id: BreakpointId,
+        }
+        impl SetInstrumentationBreakpointReturns {
+            pub fn new(breakpoint_id: impl Into<BreakpointId>) -> Self {
+                Self {
+                    breakpoint_id: breakpoint_id.into(),
+                }
+            }
+        }
+        impl SetInstrumentationBreakpointReturns {
+            pub fn builder() -> SetInstrumentationBreakpointReturnsBuilder {
+                SetInstrumentationBreakpointReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetInstrumentationBreakpointReturnsBuilder {
+            breakpoint_id: Option<BreakpointId>,
+        }
+        impl SetInstrumentationBreakpointReturnsBuilder {
+            pub fn breakpoint_id(mut self, breakpoint_id: impl Into<BreakpointId>) -> Self {
+                self.breakpoint_id = Some(breakpoint_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SetInstrumentationBreakpointReturns, String> {
+                Ok(SetInstrumentationBreakpointReturns {
+                    breakpoint_id: self.breakpoint_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(breakpoint_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetInstrumentationBreakpointParams {
+            type Response = SetInstrumentationBreakpointReturns;
+        }
+        #[doc = "Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this\ncommand is issued, all existing parsed scripts will have breakpoints resolved and returned in\n`locations` property. Further matching script parsing will result in subsequent\n`breakpointResolved` events issued. This logical breakpoint will survive page reloads.\n[setBreakpointByUrl](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBreakpointByUrl)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBreakpointByUrlParams {
+            #[doc = "Line number to set breakpoint at."]
+            #[serde(rename = "lineNumber")]
+            pub line_number: i64,
+            #[doc = "URL of the resources to set breakpoint on."]
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[doc = "Regex pattern for the URLs of the resources to set breakpoints on. Either `url` or\n`urlRegex` must be specified."]
+            #[serde(rename = "urlRegex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url_regex: Option<String>,
+            #[doc = "Script hash of the resources to set breakpoint on."]
+            #[serde(rename = "scriptHash")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub script_hash: Option<String>,
+            #[doc = "Offset in the line to set breakpoint at."]
+            #[serde(rename = "columnNumber")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub column_number: Option<i64>,
+            #[doc = "Expression to use as a breakpoint condition. When specified, debugger will only stop on the\nbreakpoint if this expression evaluates to true."]
+            #[serde(rename = "condition")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub condition: Option<String>,
+        }
+        impl SetBreakpointByUrlParams {
+            pub fn new(line_number: impl Into<i64>) -> Self {
+                Self {
+                    line_number: line_number.into(),
+                    url: None,
+                    url_regex: None,
+                    script_hash: None,
+                    column_number: None,
+                    condition: None,
+                }
+            }
+        }
+        impl SetBreakpointByUrlParams {
+            pub fn builder() -> SetBreakpointByUrlParamsBuilder {
+                SetBreakpointByUrlParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBreakpointByUrlParamsBuilder {
+            line_number: Option<i64>,
+            url: Option<String>,
+            url_regex: Option<String>,
+            script_hash: Option<String>,
+            column_number: Option<i64>,
+            condition: Option<String>,
+        }
+        impl SetBreakpointByUrlParamsBuilder {
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn url_regex(mut self, url_regex: impl Into<String>) -> Self {
+                self.url_regex = Some(url_regex.into());
+                self
+            }
+            pub fn script_hash(mut self, script_hash: impl Into<String>) -> Self {
+                self.script_hash = Some(script_hash.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<i64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn condition(mut self, condition: impl Into<String>) -> Self {
+                self.condition = Some(condition.into());
+                self
+            }
+            pub fn build(self) -> Result<SetBreakpointByUrlParams, String> {
+                Ok(SetBreakpointByUrlParams {
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    url: self.url,
+                    url_regex: self.url_regex,
+                    script_hash: self.script_hash,
+                    column_number: self.column_number,
+                    condition: self.condition,
+                })
+            }
+        }
+        impl SetBreakpointByUrlParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setBreakpointByUrl";
+        }
+        impl chromiumoxide_types::Method for SetBreakpointByUrlParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBreakpointByUrlParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this\ncommand is issued, all existing parsed scripts will have breakpoints resolved and returned in\n`locations` property. Further matching script parsing will result in subsequent\n`breakpointResolved` events issued. This logical breakpoint will survive page reloads.\n[setBreakpointByUrl](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBreakpointByUrl)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBreakpointByUrlReturns {
+            #[doc = "Id of the created breakpoint for further reference."]
+            #[serde(rename = "breakpointId")]
+            pub breakpoint_id: BreakpointId,
+            #[doc = "List of the locations this breakpoint resolved into upon addition."]
+            #[serde(rename = "locations")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub locations: Vec<Location>,
+        }
+        impl SetBreakpointByUrlReturns {
+            pub fn new(breakpoint_id: impl Into<BreakpointId>, locations: Vec<Location>) -> Self {
+                Self {
+                    breakpoint_id: breakpoint_id.into(),
+                    locations,
+                }
+            }
+        }
+        impl SetBreakpointByUrlReturns {
+            pub fn builder() -> SetBreakpointByUrlReturnsBuilder {
+                SetBreakpointByUrlReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBreakpointByUrlReturnsBuilder {
+            breakpoint_id: Option<BreakpointId>,
+            locations: Option<Vec<Location>>,
+        }
+        impl SetBreakpointByUrlReturnsBuilder {
+            pub fn breakpoint_id(mut self, breakpoint_id: impl Into<BreakpointId>) -> Self {
+                self.breakpoint_id = Some(breakpoint_id.into());
+                self
+            }
+            pub fn location(mut self, location: impl Into<Location>) -> Self {
+                let v = self.locations.get_or_insert(Vec::new());
+                v.push(location.into());
+                self
+            }
+            pub fn locations<I, S>(mut self, locations: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Location>,
+            {
+                let v = self.locations.get_or_insert(Vec::new());
+                for val in locations {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetBreakpointByUrlReturns, String> {
+                Ok(SetBreakpointByUrlReturns {
+                    breakpoint_id: self.breakpoint_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(breakpoint_id))
+                    })?,
+                    locations: self.locations.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(locations))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetBreakpointByUrlParams {
+            type Response = SetBreakpointByUrlReturns;
+        }
+        #[doc = "Sets JavaScript breakpoint before each call to the given function.\nIf another function was created from the same source as a given one,\ncalling it will also trigger the breakpoint.\n[setBreakpointOnFunctionCall](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBreakpointOnFunctionCall)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBreakpointOnFunctionCallParams {
+            #[doc = "Function object id."]
+            #[serde(rename = "objectId")]
+            pub object_id: super::runtime::RemoteObjectId,
+            #[doc = "Expression to use as a breakpoint condition. When specified, debugger will\nstop on the breakpoint if this expression evaluates to true."]
+            #[serde(rename = "condition")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub condition: Option<String>,
+        }
+        impl SetBreakpointOnFunctionCallParams {
+            pub fn new(object_id: impl Into<super::runtime::RemoteObjectId>) -> Self {
+                Self {
+                    object_id: object_id.into(),
+                    condition: None,
+                }
+            }
+        }
+        impl SetBreakpointOnFunctionCallParams {
+            pub fn builder() -> SetBreakpointOnFunctionCallParamsBuilder {
+                SetBreakpointOnFunctionCallParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBreakpointOnFunctionCallParamsBuilder {
+            object_id: Option<super::runtime::RemoteObjectId>,
+            condition: Option<String>,
+        }
+        impl SetBreakpointOnFunctionCallParamsBuilder {
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn condition(mut self, condition: impl Into<String>) -> Self {
+                self.condition = Some(condition.into());
+                self
+            }
+            pub fn build(self) -> Result<SetBreakpointOnFunctionCallParams, String> {
+                Ok(SetBreakpointOnFunctionCallParams {
+                    object_id: self.object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_id))
+                    })?,
+                    condition: self.condition,
+                })
+            }
+        }
+        impl SetBreakpointOnFunctionCallParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setBreakpointOnFunctionCall";
+        }
+        impl chromiumoxide_types::Method for SetBreakpointOnFunctionCallParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBreakpointOnFunctionCallParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets JavaScript breakpoint before each call to the given function.\nIf another function was created from the same source as a given one,\ncalling it will also trigger the breakpoint.\n[setBreakpointOnFunctionCall](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBreakpointOnFunctionCall)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBreakpointOnFunctionCallReturns {
+            #[doc = "Id of the created breakpoint for further reference."]
+            #[serde(rename = "breakpointId")]
+            pub breakpoint_id: BreakpointId,
+        }
+        impl SetBreakpointOnFunctionCallReturns {
+            pub fn new(breakpoint_id: impl Into<BreakpointId>) -> Self {
+                Self {
+                    breakpoint_id: breakpoint_id.into(),
+                }
+            }
+        }
+        impl SetBreakpointOnFunctionCallReturns {
+            pub fn builder() -> SetBreakpointOnFunctionCallReturnsBuilder {
+                SetBreakpointOnFunctionCallReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBreakpointOnFunctionCallReturnsBuilder {
+            breakpoint_id: Option<BreakpointId>,
+        }
+        impl SetBreakpointOnFunctionCallReturnsBuilder {
+            pub fn breakpoint_id(mut self, breakpoint_id: impl Into<BreakpointId>) -> Self {
+                self.breakpoint_id = Some(breakpoint_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SetBreakpointOnFunctionCallReturns, String> {
+                Ok(SetBreakpointOnFunctionCallReturns {
+                    breakpoint_id: self.breakpoint_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(breakpoint_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetBreakpointOnFunctionCallParams {
+            type Response = SetBreakpointOnFunctionCallReturns;
+        }
+        #[doc = "Activates / deactivates all breakpoints on the page.\n[setBreakpointsActive](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBreakpointsActive)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBreakpointsActiveParams {
+            #[doc = "New value for breakpoints active state."]
+            #[serde(rename = "active")]
+            pub active: bool,
+        }
+        impl SetBreakpointsActiveParams {
+            pub fn new(active: impl Into<bool>) -> Self {
+                Self {
+                    active: active.into(),
+                }
+            }
+        }
+        impl SetBreakpointsActiveParams {
+            pub fn builder() -> SetBreakpointsActiveParamsBuilder {
+                SetBreakpointsActiveParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBreakpointsActiveParamsBuilder {
+            active: Option<bool>,
+        }
+        impl SetBreakpointsActiveParamsBuilder {
+            pub fn active(mut self, active: impl Into<bool>) -> Self {
+                self.active = Some(active.into());
+                self
+            }
+            pub fn build(self) -> Result<SetBreakpointsActiveParams, String> {
+                Ok(SetBreakpointsActiveParams {
+                    active: self.active.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(active))
+                    })?,
+                })
+            }
+        }
+        impl SetBreakpointsActiveParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setBreakpointsActive";
+        }
+        impl chromiumoxide_types::Method for SetBreakpointsActiveParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBreakpointsActiveParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Activates / deactivates all breakpoints on the page.\n[setBreakpointsActive](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setBreakpointsActive)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetBreakpointsActiveReturns {}
+        impl chromiumoxide_types::Command for SetBreakpointsActiveParams {
+            type Response = SetBreakpointsActiveReturns;
+        }
+        #[doc = "Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions,\nor caught exceptions, no exceptions. Initial pause on exceptions state is `none`.\n[setPauseOnExceptions](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setPauseOnExceptions)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPauseOnExceptionsParams {
+            #[doc = "Pause on exceptions mode."]
+            #[serde(rename = "state")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub state: SetPauseOnExceptionsState,
+        }
+        #[doc = "Pause on exceptions mode."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SetPauseOnExceptionsState {
+            #[serde(rename = "none")]
+            None,
+            #[serde(rename = "caught")]
+            Caught,
+            #[serde(rename = "uncaught")]
+            Uncaught,
+            #[serde(rename = "all")]
+            All,
+        }
+        impl AsRef<str> for SetPauseOnExceptionsState {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SetPauseOnExceptionsState::None => "none",
+                    SetPauseOnExceptionsState::Caught => "caught",
+                    SetPauseOnExceptionsState::Uncaught => "uncaught",
+                    SetPauseOnExceptionsState::All => "all",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SetPauseOnExceptionsState {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "none" | "None" => Ok(SetPauseOnExceptionsState::None),
+                    "caught" | "Caught" => Ok(SetPauseOnExceptionsState::Caught),
+                    "uncaught" | "Uncaught" => Ok(SetPauseOnExceptionsState::Uncaught),
+                    "all" | "All" => Ok(SetPauseOnExceptionsState::All),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl SetPauseOnExceptionsParams {
+            pub fn new(state: impl Into<SetPauseOnExceptionsState>) -> Self {
+                Self {
+                    state: state.into(),
+                }
+            }
+        }
+        impl SetPauseOnExceptionsParams {
+            pub fn builder() -> SetPauseOnExceptionsParamsBuilder {
+                SetPauseOnExceptionsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPauseOnExceptionsParamsBuilder {
+            state: Option<SetPauseOnExceptionsState>,
+        }
+        impl SetPauseOnExceptionsParamsBuilder {
+            pub fn state(mut self, state: impl Into<SetPauseOnExceptionsState>) -> Self {
+                self.state = Some(state.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPauseOnExceptionsParams, String> {
+                Ok(SetPauseOnExceptionsParams {
+                    state: self.state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(state))
+                    })?,
+                })
+            }
+        }
+        impl SetPauseOnExceptionsParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setPauseOnExceptions";
+        }
+        impl chromiumoxide_types::Method for SetPauseOnExceptionsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPauseOnExceptionsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions,\nor caught exceptions, no exceptions. Initial pause on exceptions state is `none`.\n[setPauseOnExceptions](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setPauseOnExceptions)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPauseOnExceptionsReturns {}
+        impl chromiumoxide_types::Command for SetPauseOnExceptionsParams {
+            type Response = SetPauseOnExceptionsReturns;
+        }
+        #[doc = "Changes return value in top frame. Available only at return break position.\n[setReturnValue](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setReturnValue)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetReturnValueParams {
+            #[doc = "New return value."]
+            #[serde(rename = "newValue")]
+            pub new_value: super::runtime::CallArgument,
+        }
+        impl SetReturnValueParams {
+            pub fn new(new_value: impl Into<super::runtime::CallArgument>) -> Self {
+                Self {
+                    new_value: new_value.into(),
+                }
+            }
+        }
+        impl SetReturnValueParams {
+            pub fn builder() -> SetReturnValueParamsBuilder {
+                SetReturnValueParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetReturnValueParamsBuilder {
+            new_value: Option<super::runtime::CallArgument>,
+        }
+        impl SetReturnValueParamsBuilder {
+            pub fn new_value(mut self, new_value: impl Into<super::runtime::CallArgument>) -> Self {
+                self.new_value = Some(new_value.into());
+                self
+            }
+            pub fn build(self) -> Result<SetReturnValueParams, String> {
+                Ok(SetReturnValueParams {
+                    new_value: self.new_value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(new_value))
+                    })?,
+                })
+            }
+        }
+        impl SetReturnValueParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setReturnValue";
+        }
+        impl chromiumoxide_types::Method for SetReturnValueParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetReturnValueParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Changes return value in top frame. Available only at return break position.\n[setReturnValue](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setReturnValue)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetReturnValueReturns {}
+        impl chromiumoxide_types::Command for SetReturnValueParams {
+            type Response = SetReturnValueReturns;
+        }
+        #[doc = "Edits JavaScript source live.\n\nIn general, functions that are currently on the stack can not be edited with\na single exception: If the edited function is the top-most stack frame and\nthat is the only activation of that function on the stack. In this case\nthe live edit will be successful and a `Debugger.restartFrame` for the\ntop-most function is automatically triggered.\n[setScriptSource](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setScriptSource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetScriptSourceParams {
+            #[doc = "Id of the script to edit."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+            #[doc = "New content of the script."]
+            #[serde(rename = "scriptSource")]
+            pub script_source: String,
+            #[doc = "If true the change will not actually be applied. Dry run may be used to get result\ndescription without actually modifying the code."]
+            #[serde(rename = "dryRun")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub dry_run: Option<bool>,
+            #[doc = "If true, then `scriptSource` is allowed to change the function on top of the stack\nas long as the top-most stack frame is the only activation of that function."]
+            #[serde(rename = "allowTopFrameEditing")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub allow_top_frame_editing: Option<bool>,
+        }
+        impl SetScriptSourceParams {
+            pub fn new(
+                script_id: impl Into<super::runtime::ScriptId>,
+                script_source: impl Into<String>,
+            ) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                    script_source: script_source.into(),
+                    dry_run: None,
+                    allow_top_frame_editing: None,
+                }
+            }
+        }
+        impl SetScriptSourceParams {
+            pub fn builder() -> SetScriptSourceParamsBuilder {
+                SetScriptSourceParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetScriptSourceParamsBuilder {
+            script_id: Option<super::runtime::ScriptId>,
+            script_source: Option<String>,
+            dry_run: Option<bool>,
+            allow_top_frame_editing: Option<bool>,
+        }
+        impl SetScriptSourceParamsBuilder {
+            pub fn script_id(mut self, script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn script_source(mut self, script_source: impl Into<String>) -> Self {
+                self.script_source = Some(script_source.into());
+                self
+            }
+            pub fn dry_run(mut self, dry_run: impl Into<bool>) -> Self {
+                self.dry_run = Some(dry_run.into());
+                self
+            }
+            pub fn allow_top_frame_editing(
+                mut self,
+                allow_top_frame_editing: impl Into<bool>,
+            ) -> Self {
+                self.allow_top_frame_editing = Some(allow_top_frame_editing.into());
+                self
+            }
+            pub fn build(self) -> Result<SetScriptSourceParams, String> {
+                Ok(SetScriptSourceParams {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    script_source: self.script_source.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_source))
+                    })?,
+                    dry_run: self.dry_run,
+                    allow_top_frame_editing: self.allow_top_frame_editing,
+                })
+            }
+        }
+        impl SetScriptSourceParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setScriptSource";
+        }
+        impl chromiumoxide_types::Method for SetScriptSourceParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetScriptSourceParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Edits JavaScript source live.\n\nIn general, functions that are currently on the stack can not be edited with\na single exception: If the edited function is the top-most stack frame and\nthat is the only activation of that function on the stack. In this case\nthe live edit will be successful and a `Debugger.restartFrame` for the\ntop-most function is automatically triggered.\n[setScriptSource](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setScriptSource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetScriptSourceReturns {
+            #[doc = "Whether the operation was successful or not. Only `Ok` denotes a\nsuccessful live edit while the other enum variants denote why\nthe live edit failed."]
+            #[serde(rename = "status")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub status: SetScriptSourceStatus,
+            #[doc = "Exception details if any. Only present when `status` is `CompileError`."]
+            #[serde(rename = "exceptionDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception_details: Option<super::runtime::ExceptionDetails>,
+        }
+        #[doc = "Whether the operation was successful or not. Only `Ok` denotes a\nsuccessful live edit while the other enum variants denote why\nthe live edit failed."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SetScriptSourceStatus {
+            #[serde(rename = "Ok")]
+            Ok,
+            #[serde(rename = "CompileError")]
+            CompileError,
+            #[serde(rename = "BlockedByActiveGenerator")]
+            BlockedByActiveGenerator,
+            #[serde(rename = "BlockedByActiveFunction")]
+            BlockedByActiveFunction,
+            #[serde(rename = "BlockedByTopLevelEsModuleChange")]
+            BlockedByTopLevelEsModuleChange,
+        }
+        impl AsRef<str> for SetScriptSourceStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SetScriptSourceStatus::Ok => "Ok",
+                    SetScriptSourceStatus::CompileError => "CompileError",
+                    SetScriptSourceStatus::BlockedByActiveGenerator => "BlockedByActiveGenerator",
+                    SetScriptSourceStatus::BlockedByActiveFunction => "BlockedByActiveFunction",
+                    SetScriptSourceStatus::BlockedByTopLevelEsModuleChange => {
+                        "BlockedByTopLevelEsModuleChange"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for SetScriptSourceStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Ok" | "ok" => Ok(SetScriptSourceStatus::Ok),
+                    "CompileError" | "compileerror" => Ok(SetScriptSourceStatus::CompileError),
+                    "BlockedByActiveGenerator" | "blockedbyactivegenerator" => {
+                        Ok(SetScriptSourceStatus::BlockedByActiveGenerator)
+                    }
+                    "BlockedByActiveFunction" | "blockedbyactivefunction" => {
+                        Ok(SetScriptSourceStatus::BlockedByActiveFunction)
+                    }
+                    "BlockedByTopLevelEsModuleChange" | "blockedbytoplevelesmodulechange" => {
+                        Ok(SetScriptSourceStatus::BlockedByTopLevelEsModuleChange)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl SetScriptSourceReturns {
+            pub fn new(status: impl Into<SetScriptSourceStatus>) -> Self {
+                Self {
+                    status: status.into(),
+                    exception_details: None,
+                }
+            }
+        }
+        impl SetScriptSourceReturns {
+            pub fn builder() -> SetScriptSourceReturnsBuilder {
+                SetScriptSourceReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetScriptSourceReturnsBuilder {
+            status: Option<SetScriptSourceStatus>,
+            exception_details: Option<super::runtime::ExceptionDetails>,
+        }
+        impl SetScriptSourceReturnsBuilder {
+            pub fn status(mut self, status: impl Into<SetScriptSourceStatus>) -> Self {
+                self.status = Some(status.into());
+                self
+            }
+            pub fn exception_details(
+                mut self,
+                exception_details: impl Into<super::runtime::ExceptionDetails>,
+            ) -> Self {
+                self.exception_details = Some(exception_details.into());
+                self
+            }
+            pub fn build(self) -> Result<SetScriptSourceReturns, String> {
+                Ok(SetScriptSourceReturns {
+                    status: self.status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status))
+                    })?,
+                    exception_details: self.exception_details,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetScriptSourceParams {
+            type Response = SetScriptSourceReturns;
+        }
+        #[doc = "Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).\n[setSkipAllPauses](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setSkipAllPauses)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSkipAllPausesParams {
+            #[doc = "New value for skip pauses state."]
+            #[serde(rename = "skip")]
+            pub skip: bool,
+        }
+        impl SetSkipAllPausesParams {
+            pub fn new(skip: impl Into<bool>) -> Self {
+                Self { skip: skip.into() }
+            }
+        }
+        impl SetSkipAllPausesParams {
+            pub fn builder() -> SetSkipAllPausesParamsBuilder {
+                SetSkipAllPausesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSkipAllPausesParamsBuilder {
+            skip: Option<bool>,
+        }
+        impl SetSkipAllPausesParamsBuilder {
+            pub fn skip(mut self, skip: impl Into<bool>) -> Self {
+                self.skip = Some(skip.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSkipAllPausesParams, String> {
+                Ok(SetSkipAllPausesParams {
+                    skip: self.skip.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(skip))
+                    })?,
+                })
+            }
+        }
+        impl SetSkipAllPausesParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setSkipAllPauses";
+        }
+        impl chromiumoxide_types::Method for SetSkipAllPausesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSkipAllPausesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).\n[setSkipAllPauses](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setSkipAllPauses)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSkipAllPausesReturns {}
+        impl chromiumoxide_types::Command for SetSkipAllPausesParams {
+            type Response = SetSkipAllPausesReturns;
+        }
+        #[doc = "Changes value of variable in a callframe. Object-based scopes are not supported and must be\nmutated manually.\n[setVariableValue](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setVariableValue)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetVariableValueParams {
+            #[doc = "0-based number of scope as was listed in scope chain. Only 'local', 'closure' and 'catch'\nscope types are allowed. Other scopes could be manipulated manually."]
+            #[serde(rename = "scopeNumber")]
+            pub scope_number: i64,
+            #[doc = "Variable name."]
+            #[serde(rename = "variableName")]
+            pub variable_name: String,
+            #[doc = "New variable value."]
+            #[serde(rename = "newValue")]
+            pub new_value: super::runtime::CallArgument,
+            #[doc = "Id of callframe that holds variable."]
+            #[serde(rename = "callFrameId")]
+            pub call_frame_id: CallFrameId,
+        }
+        impl SetVariableValueParams {
+            pub fn new(
+                scope_number: impl Into<i64>,
+                variable_name: impl Into<String>,
+                new_value: impl Into<super::runtime::CallArgument>,
+                call_frame_id: impl Into<CallFrameId>,
+            ) -> Self {
+                Self {
+                    scope_number: scope_number.into(),
+                    variable_name: variable_name.into(),
+                    new_value: new_value.into(),
+                    call_frame_id: call_frame_id.into(),
+                }
+            }
+        }
+        impl SetVariableValueParams {
+            pub fn builder() -> SetVariableValueParamsBuilder {
+                SetVariableValueParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetVariableValueParamsBuilder {
+            scope_number: Option<i64>,
+            variable_name: Option<String>,
+            new_value: Option<super::runtime::CallArgument>,
+            call_frame_id: Option<CallFrameId>,
+        }
+        impl SetVariableValueParamsBuilder {
+            pub fn scope_number(mut self, scope_number: impl Into<i64>) -> Self {
+                self.scope_number = Some(scope_number.into());
+                self
+            }
+            pub fn variable_name(mut self, variable_name: impl Into<String>) -> Self {
+                self.variable_name = Some(variable_name.into());
+                self
+            }
+            pub fn new_value(mut self, new_value: impl Into<super::runtime::CallArgument>) -> Self {
+                self.new_value = Some(new_value.into());
+                self
+            }
+            pub fn call_frame_id(mut self, call_frame_id: impl Into<CallFrameId>) -> Self {
+                self.call_frame_id = Some(call_frame_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SetVariableValueParams, String> {
+                Ok(SetVariableValueParams {
+                    scope_number: self.scope_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scope_number))
+                    })?,
+                    variable_name: self.variable_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(variable_name))
+                    })?,
+                    new_value: self.new_value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(new_value))
+                    })?,
+                    call_frame_id: self.call_frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(call_frame_id))
+                    })?,
+                })
+            }
+        }
+        impl SetVariableValueParams {
+            pub const IDENTIFIER: &'static str = "Debugger.setVariableValue";
+        }
+        impl chromiumoxide_types::Method for SetVariableValueParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetVariableValueParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Changes value of variable in a callframe. Object-based scopes are not supported and must be\nmutated manually.\n[setVariableValue](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-setVariableValue)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetVariableValueReturns {}
+        impl chromiumoxide_types::Command for SetVariableValueParams {
+            type Response = SetVariableValueReturns;
+        }
+        #[doc = "Steps into the function call.\n[stepInto](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-stepInto)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StepIntoParams {
+            #[doc = "Debugger will pause on the execution of the first async task which was scheduled\nbefore next pause."]
+            #[serde(rename = "breakOnAsyncCall")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub break_on_async_call: Option<bool>,
+            #[doc = "The skipList specifies location ranges that should be skipped on step into."]
+            #[serde(rename = "skipList")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub skip_list: Option<Vec<LocationRange>>,
+        }
+        impl StepIntoParams {
+            pub fn builder() -> StepIntoParamsBuilder {
+                StepIntoParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StepIntoParamsBuilder {
+            break_on_async_call: Option<bool>,
+            skip_list: Option<Vec<LocationRange>>,
+        }
+        impl StepIntoParamsBuilder {
+            pub fn break_on_async_call(mut self, break_on_async_call: impl Into<bool>) -> Self {
+                self.break_on_async_call = Some(break_on_async_call.into());
+                self
+            }
+            pub fn skip_list(mut self, skip_list: impl Into<LocationRange>) -> Self {
+                let v = self.skip_list.get_or_insert(Vec::new());
+                v.push(skip_list.into());
+                self
+            }
+            pub fn skip_lists<I, S>(mut self, skip_lists: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<LocationRange>,
+            {
+                let v = self.skip_list.get_or_insert(Vec::new());
+                for val in skip_lists {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> StepIntoParams {
+                StepIntoParams {
+                    break_on_async_call: self.break_on_async_call,
+                    skip_list: self.skip_list,
+                }
+            }
+        }
+        impl StepIntoParams {
+            pub const IDENTIFIER: &'static str = "Debugger.stepInto";
+        }
+        impl chromiumoxide_types::Method for StepIntoParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StepIntoParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Steps into the function call.\n[stepInto](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-stepInto)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StepIntoReturns {}
+        impl chromiumoxide_types::Command for StepIntoParams {
+            type Response = StepIntoReturns;
+        }
+        #[doc = "Steps out of the function call.\n[stepOut](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-stepOut)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StepOutParams {}
+        impl StepOutParams {
+            pub const IDENTIFIER: &'static str = "Debugger.stepOut";
+        }
+        impl chromiumoxide_types::Method for StepOutParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StepOutParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Steps out of the function call.\n[stepOut](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-stepOut)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StepOutReturns {}
+        impl chromiumoxide_types::Command for StepOutParams {
+            type Response = StepOutReturns;
+        }
+        #[doc = "Steps over the statement.\n[stepOver](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-stepOver)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StepOverParams {
+            #[doc = "The skipList specifies location ranges that should be skipped on step over."]
+            #[serde(rename = "skipList")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub skip_list: Option<Vec<LocationRange>>,
+        }
+        impl StepOverParams {
+            pub fn builder() -> StepOverParamsBuilder {
+                StepOverParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StepOverParamsBuilder {
+            skip_list: Option<Vec<LocationRange>>,
+        }
+        impl StepOverParamsBuilder {
+            pub fn skip_list(mut self, skip_list: impl Into<LocationRange>) -> Self {
+                let v = self.skip_list.get_or_insert(Vec::new());
+                v.push(skip_list.into());
+                self
+            }
+            pub fn skip_lists<I, S>(mut self, skip_lists: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<LocationRange>,
+            {
+                let v = self.skip_list.get_or_insert(Vec::new());
+                for val in skip_lists {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> StepOverParams {
+                StepOverParams {
+                    skip_list: self.skip_list,
+                }
+            }
+        }
+        impl StepOverParams {
+            pub const IDENTIFIER: &'static str = "Debugger.stepOver";
+        }
+        impl chromiumoxide_types::Method for StepOverParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StepOverParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Steps over the statement.\n[stepOver](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#method-stepOver)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StepOverReturns {}
+        impl chromiumoxide_types::Command for StepOverParams {
+            type Response = StepOverReturns;
+        }
+        #[doc = "Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.\n[paused](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#event-paused)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPaused {
+            #[doc = "Call stack the virtual machine stopped on."]
+            #[serde(rename = "callFrames")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub call_frames: Vec<CallFrame>,
+            #[doc = "Pause reason."]
+            #[serde(rename = "reason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub reason: PausedReason,
+            #[doc = "Object containing break-specific auxiliary properties."]
+            #[serde(rename = "data")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub data: Option<serde_json::Value>,
+            #[doc = "Hit breakpoints IDs"]
+            #[serde(rename = "hitBreakpoints")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub hit_breakpoints: Option<Vec<String>>,
+            #[doc = "Async stack trace, if any."]
+            #[serde(rename = "asyncStackTrace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub async_stack_trace: Option<super::runtime::StackTrace>,
+            #[doc = "Async stack trace, if any."]
+            #[serde(rename = "asyncStackTraceId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub async_stack_trace_id: Option<super::runtime::StackTraceId>,
+        }
+        #[doc = "Pause reason."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PausedReason {
+            #[serde(rename = "ambiguous")]
+            Ambiguous,
+            #[serde(rename = "assert")]
+            Assert,
+            #[serde(rename = "CSPViolation")]
+            CspViolation,
+            #[serde(rename = "debugCommand")]
+            DebugCommand,
+            #[serde(rename = "DOM")]
+            Dom,
+            #[serde(rename = "EventListener")]
+            EventListener,
+            #[serde(rename = "exception")]
+            Exception,
+            #[serde(rename = "instrumentation")]
+            Instrumentation,
+            #[serde(rename = "OOM")]
+            Oom,
+            #[serde(rename = "other")]
+            Other,
+            #[serde(rename = "promiseRejection")]
+            PromiseRejection,
+            #[serde(rename = "XHR")]
+            Xhr,
+            #[serde(rename = "step")]
+            Step,
+        }
+        impl AsRef<str> for PausedReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PausedReason::Ambiguous => "ambiguous",
+                    PausedReason::Assert => "assert",
+                    PausedReason::CspViolation => "CSPViolation",
+                    PausedReason::DebugCommand => "debugCommand",
+                    PausedReason::Dom => "DOM",
+                    PausedReason::EventListener => "EventListener",
+                    PausedReason::Exception => "exception",
+                    PausedReason::Instrumentation => "instrumentation",
+                    PausedReason::Oom => "OOM",
+                    PausedReason::Other => "other",
+                    PausedReason::PromiseRejection => "promiseRejection",
+                    PausedReason::Xhr => "XHR",
+                    PausedReason::Step => "step",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PausedReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "ambiguous" | "Ambiguous" => Ok(PausedReason::Ambiguous),
+                    "assert" | "Assert" => Ok(PausedReason::Assert),
+                    "CSPViolation" | "CspViolation" | "cspviolation" => {
+                        Ok(PausedReason::CspViolation)
+                    }
+                    "debugCommand" | "DebugCommand" | "debugcommand" => {
+                        Ok(PausedReason::DebugCommand)
+                    }
+                    "DOM" | "Dom" | "dom" => Ok(PausedReason::Dom),
+                    "EventListener" | "eventlistener" => Ok(PausedReason::EventListener),
+                    "exception" | "Exception" => Ok(PausedReason::Exception),
+                    "instrumentation" | "Instrumentation" => Ok(PausedReason::Instrumentation),
+                    "OOM" | "Oom" | "oom" => Ok(PausedReason::Oom),
+                    "other" | "Other" => Ok(PausedReason::Other),
+                    "promiseRejection" | "PromiseRejection" | "promiserejection" => {
+                        Ok(PausedReason::PromiseRejection)
+                    }
+                    "XHR" | "Xhr" | "xhr" => Ok(PausedReason::Xhr),
+                    "step" | "Step" => Ok(PausedReason::Step),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EventPaused {
+            pub const IDENTIFIER: &'static str = "Debugger.paused";
+        }
+        impl chromiumoxide_types::Method for EventPaused {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPaused {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when the virtual machine resumed execution.\n[resumed](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#event-resumed)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventResumed {}
+        impl EventResumed {
+            pub const IDENTIFIER: &'static str = "Debugger.resumed";
+        }
+        impl chromiumoxide_types::Method for EventResumed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventResumed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when virtual machine fails to parse the script.\n[scriptFailedToParse](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#event-scriptFailedToParse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventScriptFailedToParse {
+            #[doc = "Identifier of the script parsed."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+            #[doc = "URL or name of the script parsed (if any)."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Line offset of the script within the resource with given URL (for script tags)."]
+            #[serde(rename = "startLine")]
+            pub start_line: i64,
+            #[doc = "Column offset of the script within the resource with given URL."]
+            #[serde(rename = "startColumn")]
+            pub start_column: i64,
+            #[doc = "Last line of the script."]
+            #[serde(rename = "endLine")]
+            pub end_line: i64,
+            #[doc = "Length of the last line of the script."]
+            #[serde(rename = "endColumn")]
+            pub end_column: i64,
+            #[doc = "Specifies script creation context."]
+            #[serde(rename = "executionContextId")]
+            pub execution_context_id: super::runtime::ExecutionContextId,
+            #[doc = "Content hash of the script, SHA-256."]
+            #[serde(rename = "hash")]
+            pub hash: String,
+            #[doc = "For Wasm modules, the content of the `build_id` custom section. For JavaScript the `debugId` magic comment."]
+            #[serde(rename = "buildId")]
+            pub build_id: String,
+            #[doc = "Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'|'isolated'|'worker', frameId: string}"]
+            #[serde(rename = "executionContextAuxData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub execution_context_aux_data: Option<serde_json::Value>,
+            #[doc = "URL of source map associated with script (if any)."]
+            #[serde(rename = "sourceMapURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_map_url: Option<String>,
+            #[doc = "True, if this script has sourceURL."]
+            #[serde(rename = "hasSourceURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_source_url: Option<bool>,
+            #[doc = "True, if this script is ES6 module."]
+            #[serde(rename = "isModule")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_module: Option<bool>,
+            #[doc = "This script length."]
+            #[serde(rename = "length")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub length: Option<i64>,
+            #[doc = "JavaScript top stack frame of where the script parsed event was triggered if available."]
+            #[serde(rename = "stackTrace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stack_trace: Option<super::runtime::StackTrace>,
+            #[doc = "If the scriptLanguage is WebAssembly, the code section offset in the module."]
+            #[serde(rename = "codeOffset")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub code_offset: Option<i64>,
+            #[doc = "The language of the script."]
+            #[serde(rename = "scriptLanguage")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub script_language: Option<super::debugger::ScriptLanguage>,
+            #[doc = "The name the embedder supplied for this script."]
+            #[serde(rename = "embedderName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub embedder_name: Option<String>,
+        }
+        impl EventScriptFailedToParse {
+            pub const IDENTIFIER: &'static str = "Debugger.scriptFailedToParse";
+        }
+        impl chromiumoxide_types::Method for EventScriptFailedToParse {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventScriptFailedToParse {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when virtual machine parses script. This event is also fired for all known and uncollected\nscripts upon enabling debugger.\n[scriptParsed](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#event-scriptParsed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventScriptParsed {
+            #[doc = "Identifier of the script parsed."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+            #[doc = "URL or name of the script parsed (if any)."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Line offset of the script within the resource with given URL (for script tags)."]
+            #[serde(rename = "startLine")]
+            pub start_line: i64,
+            #[doc = "Column offset of the script within the resource with given URL."]
+            #[serde(rename = "startColumn")]
+            pub start_column: i64,
+            #[doc = "Last line of the script."]
+            #[serde(rename = "endLine")]
+            pub end_line: i64,
+            #[doc = "Length of the last line of the script."]
+            #[serde(rename = "endColumn")]
+            pub end_column: i64,
+            #[doc = "Specifies script creation context."]
+            #[serde(rename = "executionContextId")]
+            pub execution_context_id: super::runtime::ExecutionContextId,
+            #[doc = "Content hash of the script, SHA-256."]
+            #[serde(rename = "hash")]
+            pub hash: String,
+            #[doc = "For Wasm modules, the content of the `build_id` custom section. For JavaScript the `debugId` magic comment."]
+            #[serde(rename = "buildId")]
+            pub build_id: String,
+            #[doc = "Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'|'isolated'|'worker', frameId: string}"]
+            #[serde(rename = "executionContextAuxData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub execution_context_aux_data: Option<serde_json::Value>,
+            #[doc = "True, if this script is generated as a result of the live edit operation."]
+            #[serde(rename = "isLiveEdit")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_live_edit: Option<bool>,
+            #[doc = "URL of source map associated with script (if any)."]
+            #[serde(rename = "sourceMapURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_map_url: Option<String>,
+            #[doc = "True, if this script has sourceURL."]
+            #[serde(rename = "hasSourceURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_source_url: Option<bool>,
+            #[doc = "True, if this script is ES6 module."]
+            #[serde(rename = "isModule")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_module: Option<bool>,
+            #[doc = "This script length."]
+            #[serde(rename = "length")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub length: Option<i64>,
+            #[doc = "JavaScript top stack frame of where the script parsed event was triggered if available."]
+            #[serde(rename = "stackTrace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stack_trace: Option<super::runtime::StackTrace>,
+            #[doc = "If the scriptLanguage is WebAssembly, the code section offset in the module."]
+            #[serde(rename = "codeOffset")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub code_offset: Option<i64>,
+            #[doc = "The language of the script."]
+            #[serde(rename = "scriptLanguage")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub script_language: Option<super::debugger::ScriptLanguage>,
+            #[doc = "If the scriptLanguage is WebAssembly, the source of debug symbols for the module."]
+            #[serde(rename = "debugSymbols")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub debug_symbols: Option<Vec<super::debugger::DebugSymbols>>,
+            #[doc = "The name the embedder supplied for this script."]
+            #[serde(rename = "embedderName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub embedder_name: Option<String>,
+            #[doc = "The list of set breakpoints in this script if calls to `setBreakpointByUrl`\nmatches this script's URL or hash. Clients that use this list can ignore the\n`breakpointResolved` event. They are equivalent."]
+            #[serde(rename = "resolvedBreakpoints")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub resolved_breakpoints: Option<Vec<ResolvedBreakpoint>>,
+        }
+        impl EventScriptParsed {
+            pub const IDENTIFIER: &'static str = "Debugger.scriptParsed";
+        }
+        impl chromiumoxide_types::Method for EventScriptParsed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventScriptParsed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod heap_profiler {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Heap snapshot object id.\n[HeapSnapshotObjectId](https://chromedevtools.github.io/devtools-protocol/tot/HeapProfiler/#type-HeapSnapshotObjectId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct HeapSnapshotObjectId(String);
+        impl HeapSnapshotObjectId {
+            pub fn new(val: impl Into<String>) -> Self {
+                HeapSnapshotObjectId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for HeapSnapshotObjectId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<HeapSnapshotObjectId> for String {
+            fn from(el: HeapSnapshotObjectId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for HeapSnapshotObjectId {
+            fn from(expr: String) -> Self {
+                HeapSnapshotObjectId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for HeapSnapshotObjectId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl HeapSnapshotObjectId {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.HeapSnapshotObjectId";
+        }
+        #[doc = "Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes.\n[SamplingHeapProfileNode](https://chromedevtools.github.io/devtools-protocol/tot/HeapProfiler/#type-SamplingHeapProfileNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SamplingHeapProfileNode {
+            #[doc = "Function location."]
+            #[serde(rename = "callFrame")]
+            pub call_frame: super::runtime::CallFrame,
+            #[doc = "Allocations size in bytes for the node excluding children."]
+            #[serde(rename = "selfSize")]
+            pub self_size: f64,
+            #[doc = "Node id. Ids are unique across all profiles collected between startSampling and stopSampling."]
+            #[serde(rename = "id")]
+            pub id: i64,
+            #[doc = "Child nodes."]
+            #[serde(rename = "children")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub children: Vec<SamplingHeapProfileNode>,
+        }
+        impl SamplingHeapProfileNode {
+            pub fn new(
+                call_frame: impl Into<super::runtime::CallFrame>,
+                self_size: impl Into<f64>,
+                id: impl Into<i64>,
+                children: Vec<SamplingHeapProfileNode>,
+            ) -> Self {
+                Self {
+                    call_frame: call_frame.into(),
+                    self_size: self_size.into(),
+                    id: id.into(),
+                    children,
+                }
+            }
+        }
+        impl SamplingHeapProfileNode {
+            pub fn builder() -> SamplingHeapProfileNodeBuilder {
+                SamplingHeapProfileNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SamplingHeapProfileNodeBuilder {
+            call_frame: Option<super::runtime::CallFrame>,
+            self_size: Option<f64>,
+            id: Option<i64>,
+            children: Option<Vec<SamplingHeapProfileNode>>,
+        }
+        impl SamplingHeapProfileNodeBuilder {
+            pub fn call_frame(mut self, call_frame: impl Into<super::runtime::CallFrame>) -> Self {
+                self.call_frame = Some(call_frame.into());
+                self
+            }
+            pub fn self_size(mut self, self_size: impl Into<f64>) -> Self {
+                self.self_size = Some(self_size.into());
+                self
+            }
+            pub fn id(mut self, id: impl Into<i64>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn children(mut self, children: impl Into<SamplingHeapProfileNode>) -> Self {
+                let v = self.children.get_or_insert(Vec::new());
+                v.push(children.into());
+                self
+            }
+            pub fn childrens<I, S>(mut self, childrens: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SamplingHeapProfileNode>,
+            {
+                let v = self.children.get_or_insert(Vec::new());
+                for val in childrens {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SamplingHeapProfileNode, String> {
+                Ok(SamplingHeapProfileNode {
+                    call_frame: self.call_frame.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(call_frame))
+                    })?,
+                    self_size: self.self_size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(self_size))
+                    })?,
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    children: self.children.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(children))
+                    })?,
+                })
+            }
+        }
+        impl SamplingHeapProfileNode {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.SamplingHeapProfileNode";
+        }
+        #[doc = "A single sample from a sampling profile.\n[SamplingHeapProfileSample](https://chromedevtools.github.io/devtools-protocol/tot/HeapProfiler/#type-SamplingHeapProfileSample)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SamplingHeapProfileSample {
+            #[doc = "Allocation size in bytes attributed to the sample."]
+            #[serde(rename = "size")]
+            pub size: f64,
+            #[doc = "Id of the corresponding profile tree node."]
+            #[serde(rename = "nodeId")]
+            pub node_id: i64,
+            #[doc = "Time-ordered sample ordinal number. It is unique across all profiles retrieved\nbetween startSampling and stopSampling."]
+            #[serde(rename = "ordinal")]
+            pub ordinal: f64,
+        }
+        impl SamplingHeapProfileSample {
+            pub fn new(
+                size: impl Into<f64>,
+                node_id: impl Into<i64>,
+                ordinal: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    size: size.into(),
+                    node_id: node_id.into(),
+                    ordinal: ordinal.into(),
+                }
+            }
+        }
+        impl SamplingHeapProfileSample {
+            pub fn builder() -> SamplingHeapProfileSampleBuilder {
+                SamplingHeapProfileSampleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SamplingHeapProfileSampleBuilder {
+            size: Option<f64>,
+            node_id: Option<i64>,
+            ordinal: Option<f64>,
+        }
+        impl SamplingHeapProfileSampleBuilder {
+            pub fn size(mut self, size: impl Into<f64>) -> Self {
+                self.size = Some(size.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<i64>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn ordinal(mut self, ordinal: impl Into<f64>) -> Self {
+                self.ordinal = Some(ordinal.into());
+                self
+            }
+            pub fn build(self) -> Result<SamplingHeapProfileSample, String> {
+                Ok(SamplingHeapProfileSample {
+                    size: self.size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(size))
+                    })?,
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    ordinal: self.ordinal.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ordinal))
+                    })?,
+                })
+            }
+        }
+        impl SamplingHeapProfileSample {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.SamplingHeapProfileSample";
+        }
+        #[doc = "Sampling profile.\n[SamplingHeapProfile](https://chromedevtools.github.io/devtools-protocol/tot/HeapProfiler/#type-SamplingHeapProfile)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SamplingHeapProfile {
+            #[serde(rename = "head")]
+            pub head: SamplingHeapProfileNode,
+            #[serde(rename = "samples")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub samples: Vec<SamplingHeapProfileSample>,
+        }
+        impl SamplingHeapProfile {
+            pub fn new(
+                head: impl Into<SamplingHeapProfileNode>,
+                samples: Vec<SamplingHeapProfileSample>,
+            ) -> Self {
+                Self {
+                    head: head.into(),
+                    samples,
+                }
+            }
+        }
+        impl SamplingHeapProfile {
+            pub fn builder() -> SamplingHeapProfileBuilder {
+                SamplingHeapProfileBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SamplingHeapProfileBuilder {
+            head: Option<SamplingHeapProfileNode>,
+            samples: Option<Vec<SamplingHeapProfileSample>>,
+        }
+        impl SamplingHeapProfileBuilder {
+            pub fn head(mut self, head: impl Into<SamplingHeapProfileNode>) -> Self {
+                self.head = Some(head.into());
+                self
+            }
+            pub fn sample(mut self, sample: impl Into<SamplingHeapProfileSample>) -> Self {
+                let v = self.samples.get_or_insert(Vec::new());
+                v.push(sample.into());
+                self
+            }
+            pub fn samples<I, S>(mut self, samples: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SamplingHeapProfileSample>,
+            {
+                let v = self.samples.get_or_insert(Vec::new());
+                for val in samples {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SamplingHeapProfile, String> {
+                Ok(SamplingHeapProfile {
+                    head: self.head.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(head))
+                    })?,
+                    samples: self.samples.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(samples))
+                    })?,
+                })
+            }
+        }
+        impl SamplingHeapProfile {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.SamplingHeapProfile";
+        }
+        #[doc = "Enables console to refer to the node with given id via $x (see Command Line API for more details\n$x functions).\n[addInspectedHeapObject](https://chromedevtools.github.io/devtools-protocol/tot/HeapProfiler/#method-addInspectedHeapObject)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddInspectedHeapObjectParams {
+            #[doc = "Heap snapshot object id to be accessible by means of $x command line API."]
+            #[serde(rename = "heapObjectId")]
+            pub heap_object_id: HeapSnapshotObjectId,
+        }
+        impl AddInspectedHeapObjectParams {
+            pub fn new(heap_object_id: impl Into<HeapSnapshotObjectId>) -> Self {
+                Self {
+                    heap_object_id: heap_object_id.into(),
+                }
+            }
+        }
+        impl AddInspectedHeapObjectParams {
+            pub fn builder() -> AddInspectedHeapObjectParamsBuilder {
+                AddInspectedHeapObjectParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddInspectedHeapObjectParamsBuilder {
+            heap_object_id: Option<HeapSnapshotObjectId>,
+        }
+        impl AddInspectedHeapObjectParamsBuilder {
+            pub fn heap_object_id(
+                mut self,
+                heap_object_id: impl Into<HeapSnapshotObjectId>,
+            ) -> Self {
+                self.heap_object_id = Some(heap_object_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AddInspectedHeapObjectParams, String> {
+                Ok(AddInspectedHeapObjectParams {
+                    heap_object_id: self.heap_object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(heap_object_id))
+                    })?,
+                })
+            }
+        }
+        impl AddInspectedHeapObjectParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.addInspectedHeapObject";
+        }
+        impl chromiumoxide_types::Method for AddInspectedHeapObjectParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddInspectedHeapObjectParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables console to refer to the node with given id via $x (see Command Line API for more details\n$x functions).\n[addInspectedHeapObject](https://chromedevtools.github.io/devtools-protocol/tot/HeapProfiler/#method-addInspectedHeapObject)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct AddInspectedHeapObjectReturns {}
+        impl chromiumoxide_types::Command for AddInspectedHeapObjectParams {
+            type Response = AddInspectedHeapObjectReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CollectGarbageParams {}
+        impl CollectGarbageParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.collectGarbage";
+        }
+        impl chromiumoxide_types::Method for CollectGarbageParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CollectGarbageParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CollectGarbageReturns {}
+        impl chromiumoxide_types::Command for CollectGarbageParams {
+            type Response = CollectGarbageReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetHeapObjectIdParams {
+            #[doc = "Identifier of the object to get heap object id for."]
+            #[serde(rename = "objectId")]
+            pub object_id: super::runtime::RemoteObjectId,
+        }
+        impl GetHeapObjectIdParams {
+            pub fn new(object_id: impl Into<super::runtime::RemoteObjectId>) -> Self {
+                Self {
+                    object_id: object_id.into(),
+                }
+            }
+        }
+        impl GetHeapObjectIdParams {
+            pub fn builder() -> GetHeapObjectIdParamsBuilder {
+                GetHeapObjectIdParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetHeapObjectIdParamsBuilder {
+            object_id: Option<super::runtime::RemoteObjectId>,
+        }
+        impl GetHeapObjectIdParamsBuilder {
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetHeapObjectIdParams, String> {
+                Ok(GetHeapObjectIdParams {
+                    object_id: self.object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_id))
+                    })?,
+                })
+            }
+        }
+        impl GetHeapObjectIdParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.getHeapObjectId";
+        }
+        impl chromiumoxide_types::Method for GetHeapObjectIdParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetHeapObjectIdParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetHeapObjectIdReturns {
+            #[doc = "Id of the heap snapshot object corresponding to the passed remote object id."]
+            #[serde(rename = "heapSnapshotObjectId")]
+            pub heap_snapshot_object_id: HeapSnapshotObjectId,
+        }
+        impl GetHeapObjectIdReturns {
+            pub fn new(heap_snapshot_object_id: impl Into<HeapSnapshotObjectId>) -> Self {
+                Self {
+                    heap_snapshot_object_id: heap_snapshot_object_id.into(),
+                }
+            }
+        }
+        impl GetHeapObjectIdReturns {
+            pub fn builder() -> GetHeapObjectIdReturnsBuilder {
+                GetHeapObjectIdReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetHeapObjectIdReturnsBuilder {
+            heap_snapshot_object_id: Option<HeapSnapshotObjectId>,
+        }
+        impl GetHeapObjectIdReturnsBuilder {
+            pub fn heap_snapshot_object_id(
+                mut self,
+                heap_snapshot_object_id: impl Into<HeapSnapshotObjectId>,
+            ) -> Self {
+                self.heap_snapshot_object_id = Some(heap_snapshot_object_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetHeapObjectIdReturns, String> {
+                Ok(GetHeapObjectIdReturns {
+                    heap_snapshot_object_id: self.heap_snapshot_object_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(heap_snapshot_object_id)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetHeapObjectIdParams {
+            type Response = GetHeapObjectIdReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetObjectByHeapObjectIdParams {
+            #[serde(rename = "objectId")]
+            pub object_id: HeapSnapshotObjectId,
+            #[doc = "Symbolic group name that can be used to release multiple objects."]
+            #[serde(rename = "objectGroup")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_group: Option<String>,
+        }
+        impl GetObjectByHeapObjectIdParams {
+            pub fn new(object_id: impl Into<HeapSnapshotObjectId>) -> Self {
+                Self {
+                    object_id: object_id.into(),
+                    object_group: None,
+                }
+            }
+        }
+        impl GetObjectByHeapObjectIdParams {
+            pub fn builder() -> GetObjectByHeapObjectIdParamsBuilder {
+                GetObjectByHeapObjectIdParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetObjectByHeapObjectIdParamsBuilder {
+            object_id: Option<HeapSnapshotObjectId>,
+            object_group: Option<String>,
+        }
+        impl GetObjectByHeapObjectIdParamsBuilder {
+            pub fn object_id(mut self, object_id: impl Into<HeapSnapshotObjectId>) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn object_group(mut self, object_group: impl Into<String>) -> Self {
+                self.object_group = Some(object_group.into());
+                self
+            }
+            pub fn build(self) -> Result<GetObjectByHeapObjectIdParams, String> {
+                Ok(GetObjectByHeapObjectIdParams {
+                    object_id: self.object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_id))
+                    })?,
+                    object_group: self.object_group,
+                })
+            }
+        }
+        impl GetObjectByHeapObjectIdParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.getObjectByHeapObjectId";
+        }
+        impl chromiumoxide_types::Method for GetObjectByHeapObjectIdParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetObjectByHeapObjectIdParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetObjectByHeapObjectIdReturns {
+            #[doc = "Evaluation result."]
+            #[serde(rename = "result")]
+            pub result: super::runtime::RemoteObject,
+        }
+        impl GetObjectByHeapObjectIdReturns {
+            pub fn new(result: impl Into<super::runtime::RemoteObject>) -> Self {
+                Self {
+                    result: result.into(),
+                }
+            }
+        }
+        impl GetObjectByHeapObjectIdReturns {
+            pub fn builder() -> GetObjectByHeapObjectIdReturnsBuilder {
+                GetObjectByHeapObjectIdReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetObjectByHeapObjectIdReturnsBuilder {
+            result: Option<super::runtime::RemoteObject>,
+        }
+        impl GetObjectByHeapObjectIdReturnsBuilder {
+            pub fn result(mut self, result: impl Into<super::runtime::RemoteObject>) -> Self {
+                self.result = Some(result.into());
+                self
+            }
+            pub fn build(self) -> Result<GetObjectByHeapObjectIdReturns, String> {
+                Ok(GetObjectByHeapObjectIdReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetObjectByHeapObjectIdParams {
+            type Response = GetObjectByHeapObjectIdReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetSamplingProfileParams {}
+        impl GetSamplingProfileParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.getSamplingProfile";
+        }
+        impl chromiumoxide_types::Method for GetSamplingProfileParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetSamplingProfileParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSamplingProfileReturns {
+            #[doc = "Return the sampling profile being collected."]
+            #[serde(rename = "profile")]
+            pub profile: SamplingHeapProfile,
+        }
+        impl GetSamplingProfileReturns {
+            pub fn new(profile: impl Into<SamplingHeapProfile>) -> Self {
+                Self {
+                    profile: profile.into(),
+                }
+            }
+        }
+        impl GetSamplingProfileReturns {
+            pub fn builder() -> GetSamplingProfileReturnsBuilder {
+                GetSamplingProfileReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSamplingProfileReturnsBuilder {
+            profile: Option<SamplingHeapProfile>,
+        }
+        impl GetSamplingProfileReturnsBuilder {
+            pub fn profile(mut self, profile: impl Into<SamplingHeapProfile>) -> Self {
+                self.profile = Some(profile.into());
+                self
+            }
+            pub fn build(self) -> Result<GetSamplingProfileReturns, String> {
+                Ok(GetSamplingProfileReturns {
+                    profile: self.profile.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(profile))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetSamplingProfileParams {
+            type Response = GetSamplingProfileReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartSamplingParams {
+            #[doc = "Average sample interval in bytes. Poisson distribution is used for the intervals. The\ndefault value is 32768 bytes."]
+            #[serde(rename = "samplingInterval")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub sampling_interval: Option<f64>,
+            #[doc = "Maximum stack depth. The default value is 128."]
+            #[serde(rename = "stackDepth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stack_depth: Option<f64>,
+            #[doc = "By default, the sampling heap profiler reports only objects which are\nstill alive when the profile is returned via getSamplingProfile or\nstopSampling, which is useful for determining what functions contribute\nthe most to steady-state memory usage. This flag instructs the sampling\nheap profiler to also include information about objects discarded by\nmajor GC, which will show which functions cause large temporary memory\nusage or long GC pauses."]
+            #[serde(rename = "includeObjectsCollectedByMajorGC")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_objects_collected_by_major_gc: Option<bool>,
+            #[doc = "By default, the sampling heap profiler reports only objects which are\nstill alive when the profile is returned via getSamplingProfile or\nstopSampling, which is useful for determining what functions contribute\nthe most to steady-state memory usage. This flag instructs the sampling\nheap profiler to also include information about objects discarded by\nminor GC, which is useful when tuning a latency-sensitive application\nfor minimal GC activity."]
+            #[serde(rename = "includeObjectsCollectedByMinorGC")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_objects_collected_by_minor_gc: Option<bool>,
+        }
+        impl StartSamplingParams {
+            pub fn builder() -> StartSamplingParamsBuilder {
+                StartSamplingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartSamplingParamsBuilder {
+            sampling_interval: Option<f64>,
+            stack_depth: Option<f64>,
+            include_objects_collected_by_major_gc: Option<bool>,
+            include_objects_collected_by_minor_gc: Option<bool>,
+        }
+        impl StartSamplingParamsBuilder {
+            pub fn sampling_interval(mut self, sampling_interval: impl Into<f64>) -> Self {
+                self.sampling_interval = Some(sampling_interval.into());
+                self
+            }
+            pub fn stack_depth(mut self, stack_depth: impl Into<f64>) -> Self {
+                self.stack_depth = Some(stack_depth.into());
+                self
+            }
+            pub fn include_objects_collected_by_major_gc(
+                mut self,
+                include_objects_collected_by_major_gc: impl Into<bool>,
+            ) -> Self {
+                self.include_objects_collected_by_major_gc =
+                    Some(include_objects_collected_by_major_gc.into());
+                self
+            }
+            pub fn include_objects_collected_by_minor_gc(
+                mut self,
+                include_objects_collected_by_minor_gc: impl Into<bool>,
+            ) -> Self {
+                self.include_objects_collected_by_minor_gc =
+                    Some(include_objects_collected_by_minor_gc.into());
+                self
+            }
+            pub fn build(self) -> StartSamplingParams {
+                StartSamplingParams {
+                    sampling_interval: self.sampling_interval,
+                    stack_depth: self.stack_depth,
+                    include_objects_collected_by_major_gc: self
+                        .include_objects_collected_by_major_gc,
+                    include_objects_collected_by_minor_gc: self
+                        .include_objects_collected_by_minor_gc,
+                }
+            }
+        }
+        impl StartSamplingParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.startSampling";
+        }
+        impl chromiumoxide_types::Method for StartSamplingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartSamplingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartSamplingReturns {}
+        impl chromiumoxide_types::Command for StartSamplingParams {
+            type Response = StartSamplingReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartTrackingHeapObjectsParams {
+            #[serde(rename = "trackAllocations")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub track_allocations: Option<bool>,
+        }
+        impl StartTrackingHeapObjectsParams {
+            pub fn builder() -> StartTrackingHeapObjectsParamsBuilder {
+                StartTrackingHeapObjectsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartTrackingHeapObjectsParamsBuilder {
+            track_allocations: Option<bool>,
+        }
+        impl StartTrackingHeapObjectsParamsBuilder {
+            pub fn track_allocations(mut self, track_allocations: impl Into<bool>) -> Self {
+                self.track_allocations = Some(track_allocations.into());
+                self
+            }
+            pub fn build(self) -> StartTrackingHeapObjectsParams {
+                StartTrackingHeapObjectsParams {
+                    track_allocations: self.track_allocations,
+                }
+            }
+        }
+        impl StartTrackingHeapObjectsParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.startTrackingHeapObjects";
+        }
+        impl chromiumoxide_types::Method for StartTrackingHeapObjectsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartTrackingHeapObjectsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartTrackingHeapObjectsReturns {}
+        impl chromiumoxide_types::Command for StartTrackingHeapObjectsParams {
+            type Response = StartTrackingHeapObjectsReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopSamplingParams {}
+        impl StopSamplingParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.stopSampling";
+        }
+        impl chromiumoxide_types::Method for StopSamplingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopSamplingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StopSamplingReturns {
+            #[doc = "Recorded sampling heap profile."]
+            #[serde(rename = "profile")]
+            pub profile: SamplingHeapProfile,
+        }
+        impl StopSamplingReturns {
+            pub fn new(profile: impl Into<SamplingHeapProfile>) -> Self {
+                Self {
+                    profile: profile.into(),
+                }
+            }
+        }
+        impl StopSamplingReturns {
+            pub fn builder() -> StopSamplingReturnsBuilder {
+                StopSamplingReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StopSamplingReturnsBuilder {
+            profile: Option<SamplingHeapProfile>,
+        }
+        impl StopSamplingReturnsBuilder {
+            pub fn profile(mut self, profile: impl Into<SamplingHeapProfile>) -> Self {
+                self.profile = Some(profile.into());
+                self
+            }
+            pub fn build(self) -> Result<StopSamplingReturns, String> {
+                Ok(StopSamplingReturns {
+                    profile: self.profile.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(profile))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for StopSamplingParams {
+            type Response = StopSamplingReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopTrackingHeapObjectsParams {
+            #[doc = "If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken\nwhen the tracking is stopped."]
+            #[serde(rename = "reportProgress")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub report_progress: Option<bool>,
+            #[doc = "If true, numerical values are included in the snapshot"]
+            #[serde(rename = "captureNumericValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub capture_numeric_value: Option<bool>,
+            #[doc = "If true, exposes internals of the snapshot."]
+            #[serde(rename = "exposeInternals")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub expose_internals: Option<bool>,
+        }
+        impl StopTrackingHeapObjectsParams {
+            pub fn builder() -> StopTrackingHeapObjectsParamsBuilder {
+                StopTrackingHeapObjectsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StopTrackingHeapObjectsParamsBuilder {
+            report_progress: Option<bool>,
+            capture_numeric_value: Option<bool>,
+            expose_internals: Option<bool>,
+        }
+        impl StopTrackingHeapObjectsParamsBuilder {
+            pub fn report_progress(mut self, report_progress: impl Into<bool>) -> Self {
+                self.report_progress = Some(report_progress.into());
+                self
+            }
+            pub fn capture_numeric_value(mut self, capture_numeric_value: impl Into<bool>) -> Self {
+                self.capture_numeric_value = Some(capture_numeric_value.into());
+                self
+            }
+            pub fn expose_internals(mut self, expose_internals: impl Into<bool>) -> Self {
+                self.expose_internals = Some(expose_internals.into());
+                self
+            }
+            pub fn build(self) -> StopTrackingHeapObjectsParams {
+                StopTrackingHeapObjectsParams {
+                    report_progress: self.report_progress,
+                    capture_numeric_value: self.capture_numeric_value,
+                    expose_internals: self.expose_internals,
+                }
+            }
+        }
+        impl StopTrackingHeapObjectsParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.stopTrackingHeapObjects";
+        }
+        impl chromiumoxide_types::Method for StopTrackingHeapObjectsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopTrackingHeapObjectsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopTrackingHeapObjectsReturns {}
+        impl chromiumoxide_types::Command for StopTrackingHeapObjectsParams {
+            type Response = StopTrackingHeapObjectsReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TakeHeapSnapshotParams {
+            #[doc = "If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken."]
+            #[serde(rename = "reportProgress")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub report_progress: Option<bool>,
+            #[doc = "If true, numerical values are included in the snapshot"]
+            #[serde(rename = "captureNumericValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub capture_numeric_value: Option<bool>,
+            #[doc = "If true, exposes internals of the snapshot."]
+            #[serde(rename = "exposeInternals")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub expose_internals: Option<bool>,
+        }
+        impl TakeHeapSnapshotParams {
+            pub fn builder() -> TakeHeapSnapshotParamsBuilder {
+                TakeHeapSnapshotParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TakeHeapSnapshotParamsBuilder {
+            report_progress: Option<bool>,
+            capture_numeric_value: Option<bool>,
+            expose_internals: Option<bool>,
+        }
+        impl TakeHeapSnapshotParamsBuilder {
+            pub fn report_progress(mut self, report_progress: impl Into<bool>) -> Self {
+                self.report_progress = Some(report_progress.into());
+                self
+            }
+            pub fn capture_numeric_value(mut self, capture_numeric_value: impl Into<bool>) -> Self {
+                self.capture_numeric_value = Some(capture_numeric_value.into());
+                self
+            }
+            pub fn expose_internals(mut self, expose_internals: impl Into<bool>) -> Self {
+                self.expose_internals = Some(expose_internals.into());
+                self
+            }
+            pub fn build(self) -> TakeHeapSnapshotParams {
+                TakeHeapSnapshotParams {
+                    report_progress: self.report_progress,
+                    capture_numeric_value: self.capture_numeric_value,
+                    expose_internals: self.expose_internals,
+                }
+            }
+        }
+        impl TakeHeapSnapshotParams {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.takeHeapSnapshot";
+        }
+        impl chromiumoxide_types::Method for TakeHeapSnapshotParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TakeHeapSnapshotParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TakeHeapSnapshotReturns {}
+        impl chromiumoxide_types::Command for TakeHeapSnapshotParams {
+            type Response = TakeHeapSnapshotReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAddHeapSnapshotChunk {
+            #[serde(rename = "chunk")]
+            pub chunk: String,
+        }
+        impl EventAddHeapSnapshotChunk {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.addHeapSnapshotChunk";
+        }
+        impl chromiumoxide_types::Method for EventAddHeapSnapshotChunk {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAddHeapSnapshotChunk {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "If heap objects tracking has been started then backend may send update for one or more fragments\n[heapStatsUpdate](https://chromedevtools.github.io/devtools-protocol/tot/HeapProfiler/#event-heapStatsUpdate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventHeapStatsUpdate {
+            #[doc = "An array of triplets. Each triplet describes a fragment. The first integer is the fragment\nindex, the second integer is a total count of objects for the fragment, the third integer is\na total size of the objects for the fragment."]
+            #[serde(rename = "statsUpdate")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub stats_update: Vec<i64>,
+        }
+        impl EventHeapStatsUpdate {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.heapStatsUpdate";
+        }
+        impl chromiumoxide_types::Method for EventHeapStatsUpdate {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventHeapStatsUpdate {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "If heap objects tracking has been started then backend regularly sends a current value for last\nseen object id and corresponding timestamp. If the were changes in the heap since last event\nthen one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.\n[lastSeenObjectId](https://chromedevtools.github.io/devtools-protocol/tot/HeapProfiler/#event-lastSeenObjectId)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventLastSeenObjectId {
+            #[serde(rename = "lastSeenObjectId")]
+            pub last_seen_object_id: i64,
+            #[serde(rename = "timestamp")]
+            pub timestamp: f64,
+        }
+        impl EventLastSeenObjectId {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.lastSeenObjectId";
+        }
+        impl chromiumoxide_types::Method for EventLastSeenObjectId {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventLastSeenObjectId {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventReportHeapSnapshotProgress {
+            #[serde(rename = "done")]
+            pub done: i64,
+            #[serde(rename = "total")]
+            pub total: i64,
+            #[serde(rename = "finished")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub finished: Option<bool>,
+        }
+        impl EventReportHeapSnapshotProgress {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.reportHeapSnapshotProgress";
+        }
+        impl chromiumoxide_types::Method for EventReportHeapSnapshotProgress {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventReportHeapSnapshotProgress {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventResetProfiles {}
+        impl EventResetProfiles {
+            pub const IDENTIFIER: &'static str = "HeapProfiler.resetProfiles";
+        }
+        impl chromiumoxide_types::Method for EventResetProfiles {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventResetProfiles {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod profiler {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Profile node. Holds callsite information, execution statistics and child nodes.\n[ProfileNode](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#type-ProfileNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ProfileNode {
+            #[doc = "Unique id of the node."]
+            #[serde(rename = "id")]
+            pub id: i64,
+            #[doc = "Function location."]
+            #[serde(rename = "callFrame")]
+            pub call_frame: super::runtime::CallFrame,
+            #[doc = "Number of samples where this node was on top of the call stack."]
+            #[serde(rename = "hitCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub hit_count: Option<i64>,
+            #[doc = "Child node ids."]
+            #[serde(rename = "children")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub children: Option<Vec<i64>>,
+            #[doc = "The reason of being not optimized. The function may be deoptimized or marked as don't\noptimize."]
+            #[serde(rename = "deoptReason")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub deopt_reason: Option<String>,
+            #[doc = "An array of source position ticks."]
+            #[serde(rename = "positionTicks")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub position_ticks: Option<Vec<PositionTickInfo>>,
+        }
+        impl ProfileNode {
+            pub fn new(
+                id: impl Into<i64>,
+                call_frame: impl Into<super::runtime::CallFrame>,
+            ) -> Self {
+                Self {
+                    id: id.into(),
+                    call_frame: call_frame.into(),
+                    hit_count: None,
+                    children: None,
+                    deopt_reason: None,
+                    position_ticks: None,
+                }
+            }
+        }
+        impl ProfileNode {
+            pub fn builder() -> ProfileNodeBuilder {
+                ProfileNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ProfileNodeBuilder {
+            id: Option<i64>,
+            call_frame: Option<super::runtime::CallFrame>,
+            hit_count: Option<i64>,
+            children: Option<Vec<i64>>,
+            deopt_reason: Option<String>,
+            position_ticks: Option<Vec<PositionTickInfo>>,
+        }
+        impl ProfileNodeBuilder {
+            pub fn id(mut self, id: impl Into<i64>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn call_frame(mut self, call_frame: impl Into<super::runtime::CallFrame>) -> Self {
+                self.call_frame = Some(call_frame.into());
+                self
+            }
+            pub fn hit_count(mut self, hit_count: impl Into<i64>) -> Self {
+                self.hit_count = Some(hit_count.into());
+                self
+            }
+            pub fn children(mut self, children: impl Into<i64>) -> Self {
+                let v = self.children.get_or_insert(Vec::new());
+                v.push(children.into());
+                self
+            }
+            pub fn childrens<I, S>(mut self, childrens: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.children.get_or_insert(Vec::new());
+                for val in childrens {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn deopt_reason(mut self, deopt_reason: impl Into<String>) -> Self {
+                self.deopt_reason = Some(deopt_reason.into());
+                self
+            }
+            pub fn position_tick(mut self, position_tick: impl Into<PositionTickInfo>) -> Self {
+                let v = self.position_ticks.get_or_insert(Vec::new());
+                v.push(position_tick.into());
+                self
+            }
+            pub fn position_ticks<I, S>(mut self, position_ticks: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PositionTickInfo>,
+            {
+                let v = self.position_ticks.get_or_insert(Vec::new());
+                for val in position_ticks {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ProfileNode, String> {
+                Ok(ProfileNode {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    call_frame: self.call_frame.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(call_frame))
+                    })?,
+                    hit_count: self.hit_count,
+                    children: self.children,
+                    deopt_reason: self.deopt_reason,
+                    position_ticks: self.position_ticks,
+                })
+            }
+        }
+        impl ProfileNode {
+            pub const IDENTIFIER: &'static str = "Profiler.ProfileNode";
+        }
+        #[doc = "Profile.\n[Profile](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#type-Profile)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Profile {
+            #[doc = "The list of profile nodes. First item is the root node."]
+            #[serde(rename = "nodes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub nodes: Vec<ProfileNode>,
+            #[doc = "Profiling start timestamp in microseconds."]
+            #[serde(rename = "startTime")]
+            pub start_time: f64,
+            #[doc = "Profiling end timestamp in microseconds."]
+            #[serde(rename = "endTime")]
+            pub end_time: f64,
+            #[doc = "Ids of samples top nodes."]
+            #[serde(rename = "samples")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub samples: Option<Vec<i64>>,
+            #[doc = "Time intervals between adjacent samples in microseconds. The first delta is relative to the\nprofile startTime."]
+            #[serde(rename = "timeDeltas")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub time_deltas: Option<Vec<i64>>,
+        }
+        impl Profile {
+            pub fn new(
+                nodes: Vec<ProfileNode>,
+                start_time: impl Into<f64>,
+                end_time: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    nodes,
+                    start_time: start_time.into(),
+                    end_time: end_time.into(),
+                    samples: None,
+                    time_deltas: None,
+                }
+            }
+        }
+        impl Profile {
+            pub fn builder() -> ProfileBuilder {
+                ProfileBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ProfileBuilder {
+            nodes: Option<Vec<ProfileNode>>,
+            start_time: Option<f64>,
+            end_time: Option<f64>,
+            samples: Option<Vec<i64>>,
+            time_deltas: Option<Vec<i64>>,
+        }
+        impl ProfileBuilder {
+            pub fn node(mut self, node: impl Into<ProfileNode>) -> Self {
+                let v = self.nodes.get_or_insert(Vec::new());
+                v.push(node.into());
+                self
+            }
+            pub fn nodes<I, S>(mut self, nodes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ProfileNode>,
+            {
+                let v = self.nodes.get_or_insert(Vec::new());
+                for val in nodes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn start_time(mut self, start_time: impl Into<f64>) -> Self {
+                self.start_time = Some(start_time.into());
+                self
+            }
+            pub fn end_time(mut self, end_time: impl Into<f64>) -> Self {
+                self.end_time = Some(end_time.into());
+                self
+            }
+            pub fn sample(mut self, sample: impl Into<i64>) -> Self {
+                let v = self.samples.get_or_insert(Vec::new());
+                v.push(sample.into());
+                self
+            }
+            pub fn samples<I, S>(mut self, samples: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.samples.get_or_insert(Vec::new());
+                for val in samples {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn time_delta(mut self, time_delta: impl Into<i64>) -> Self {
+                let v = self.time_deltas.get_or_insert(Vec::new());
+                v.push(time_delta.into());
+                self
+            }
+            pub fn time_deltas<I, S>(mut self, time_deltas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.time_deltas.get_or_insert(Vec::new());
+                for val in time_deltas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<Profile, String> {
+                Ok(Profile {
+                    nodes: self.nodes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(nodes))
+                    })?,
+                    start_time: self.start_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start_time))
+                    })?,
+                    end_time: self.end_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(end_time))
+                    })?,
+                    samples: self.samples,
+                    time_deltas: self.time_deltas,
+                })
+            }
+        }
+        impl Profile {
+            pub const IDENTIFIER: &'static str = "Profiler.Profile";
+        }
+        #[doc = "Specifies a number of samples attributed to a certain source position.\n[PositionTickInfo](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#type-PositionTickInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PositionTickInfo {
+            #[doc = "Source line number (1-based)."]
+            #[serde(rename = "line")]
+            pub line: i64,
+            #[doc = "Number of samples attributed to the source line."]
+            #[serde(rename = "ticks")]
+            pub ticks: i64,
+        }
+        impl PositionTickInfo {
+            pub fn new(line: impl Into<i64>, ticks: impl Into<i64>) -> Self {
+                Self {
+                    line: line.into(),
+                    ticks: ticks.into(),
+                }
+            }
+        }
+        impl PositionTickInfo {
+            pub fn builder() -> PositionTickInfoBuilder {
+                PositionTickInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PositionTickInfoBuilder {
+            line: Option<i64>,
+            ticks: Option<i64>,
+        }
+        impl PositionTickInfoBuilder {
+            pub fn line(mut self, line: impl Into<i64>) -> Self {
+                self.line = Some(line.into());
+                self
+            }
+            pub fn ticks(mut self, ticks: impl Into<i64>) -> Self {
+                self.ticks = Some(ticks.into());
+                self
+            }
+            pub fn build(self) -> Result<PositionTickInfo, String> {
+                Ok(PositionTickInfo {
+                    line: self.line.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line))
+                    })?,
+                    ticks: self.ticks.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ticks))
+                    })?,
+                })
+            }
+        }
+        impl PositionTickInfo {
+            pub const IDENTIFIER: &'static str = "Profiler.PositionTickInfo";
+        }
+        #[doc = "Coverage data for a source range.\n[CoverageRange](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#type-CoverageRange)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CoverageRange {
+            #[doc = "JavaScript script source offset for the range start."]
+            #[serde(rename = "startOffset")]
+            pub start_offset: i64,
+            #[doc = "JavaScript script source offset for the range end."]
+            #[serde(rename = "endOffset")]
+            pub end_offset: i64,
+            #[doc = "Collected execution count of the source range."]
+            #[serde(rename = "count")]
+            pub count: i64,
+        }
+        impl CoverageRange {
+            pub fn new(
+                start_offset: impl Into<i64>,
+                end_offset: impl Into<i64>,
+                count: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    start_offset: start_offset.into(),
+                    end_offset: end_offset.into(),
+                    count: count.into(),
+                }
+            }
+        }
+        impl CoverageRange {
+            pub fn builder() -> CoverageRangeBuilder {
+                CoverageRangeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CoverageRangeBuilder {
+            start_offset: Option<i64>,
+            end_offset: Option<i64>,
+            count: Option<i64>,
+        }
+        impl CoverageRangeBuilder {
+            pub fn start_offset(mut self, start_offset: impl Into<i64>) -> Self {
+                self.start_offset = Some(start_offset.into());
+                self
+            }
+            pub fn end_offset(mut self, end_offset: impl Into<i64>) -> Self {
+                self.end_offset = Some(end_offset.into());
+                self
+            }
+            pub fn count(mut self, count: impl Into<i64>) -> Self {
+                self.count = Some(count.into());
+                self
+            }
+            pub fn build(self) -> Result<CoverageRange, String> {
+                Ok(CoverageRange {
+                    start_offset: self.start_offset.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start_offset))
+                    })?,
+                    end_offset: self.end_offset.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(end_offset))
+                    })?,
+                    count: self.count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(count))
+                    })?,
+                })
+            }
+        }
+        impl CoverageRange {
+            pub const IDENTIFIER: &'static str = "Profiler.CoverageRange";
+        }
+        #[doc = "Coverage data for a JavaScript function.\n[FunctionCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#type-FunctionCoverage)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FunctionCoverage {
+            #[doc = "JavaScript function name."]
+            #[serde(rename = "functionName")]
+            pub function_name: String,
+            #[doc = "Source ranges inside the function with coverage data."]
+            #[serde(rename = "ranges")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub ranges: Vec<CoverageRange>,
+            #[doc = "Whether coverage data for this function has block granularity."]
+            #[serde(rename = "isBlockCoverage")]
+            pub is_block_coverage: bool,
+        }
+        impl FunctionCoverage {
+            pub fn new(
+                function_name: impl Into<String>,
+                ranges: Vec<CoverageRange>,
+                is_block_coverage: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    function_name: function_name.into(),
+                    ranges,
+                    is_block_coverage: is_block_coverage.into(),
+                }
+            }
+        }
+        impl FunctionCoverage {
+            pub fn builder() -> FunctionCoverageBuilder {
+                FunctionCoverageBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FunctionCoverageBuilder {
+            function_name: Option<String>,
+            ranges: Option<Vec<CoverageRange>>,
+            is_block_coverage: Option<bool>,
+        }
+        impl FunctionCoverageBuilder {
+            pub fn function_name(mut self, function_name: impl Into<String>) -> Self {
+                self.function_name = Some(function_name.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<CoverageRange>) -> Self {
+                let v = self.ranges.get_or_insert(Vec::new());
+                v.push(range.into());
+                self
+            }
+            pub fn ranges<I, S>(mut self, ranges: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CoverageRange>,
+            {
+                let v = self.ranges.get_or_insert(Vec::new());
+                for val in ranges {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn is_block_coverage(mut self, is_block_coverage: impl Into<bool>) -> Self {
+                self.is_block_coverage = Some(is_block_coverage.into());
+                self
+            }
+            pub fn build(self) -> Result<FunctionCoverage, String> {
+                Ok(FunctionCoverage {
+                    function_name: self.function_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(function_name))
+                    })?,
+                    ranges: self.ranges.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ranges))
+                    })?,
+                    is_block_coverage: self.is_block_coverage.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(is_block_coverage)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl FunctionCoverage {
+            pub const IDENTIFIER: &'static str = "Profiler.FunctionCoverage";
+        }
+        #[doc = "Coverage data for a JavaScript script.\n[ScriptCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#type-ScriptCoverage)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScriptCoverage {
+            #[doc = "JavaScript script id."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::runtime::ScriptId,
+            #[doc = "JavaScript script name or url."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Functions contained in the script that has coverage data."]
+            #[serde(rename = "functions")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub functions: Vec<FunctionCoverage>,
+        }
+        impl ScriptCoverage {
+            pub fn new(
+                script_id: impl Into<super::runtime::ScriptId>,
+                url: impl Into<String>,
+                functions: Vec<FunctionCoverage>,
+            ) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                    url: url.into(),
+                    functions,
+                }
+            }
+        }
+        impl ScriptCoverage {
+            pub fn builder() -> ScriptCoverageBuilder {
+                ScriptCoverageBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScriptCoverageBuilder {
+            script_id: Option<super::runtime::ScriptId>,
+            url: Option<String>,
+            functions: Option<Vec<FunctionCoverage>>,
+        }
+        impl ScriptCoverageBuilder {
+            pub fn script_id(mut self, script_id: impl Into<super::runtime::ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn function(mut self, function: impl Into<FunctionCoverage>) -> Self {
+                let v = self.functions.get_or_insert(Vec::new());
+                v.push(function.into());
+                self
+            }
+            pub fn functions<I, S>(mut self, functions: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FunctionCoverage>,
+            {
+                let v = self.functions.get_or_insert(Vec::new());
+                for val in functions {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ScriptCoverage, String> {
+                Ok(ScriptCoverage {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    functions: self.functions.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(functions))
+                    })?,
+                })
+            }
+        }
+        impl ScriptCoverage {
+            pub const IDENTIFIER: &'static str = "Profiler.ScriptCoverage";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Profiler.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Profiler.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Collect coverage data for the current isolate. The coverage data may be incomplete due to\ngarbage collection.\n[getBestEffortCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-getBestEffortCoverage)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetBestEffortCoverageParams {}
+        impl GetBestEffortCoverageParams {
+            pub const IDENTIFIER: &'static str = "Profiler.getBestEffortCoverage";
+        }
+        impl chromiumoxide_types::Method for GetBestEffortCoverageParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetBestEffortCoverageParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Collect coverage data for the current isolate. The coverage data may be incomplete due to\ngarbage collection.\n[getBestEffortCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-getBestEffortCoverage)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetBestEffortCoverageReturns {
+            #[doc = "Coverage data for the current isolate."]
+            #[serde(rename = "result")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub result: Vec<ScriptCoverage>,
+        }
+        impl GetBestEffortCoverageReturns {
+            pub fn new(result: Vec<ScriptCoverage>) -> Self {
+                Self { result }
+            }
+        }
+        impl GetBestEffortCoverageReturns {
+            pub fn builder() -> GetBestEffortCoverageReturnsBuilder {
+                GetBestEffortCoverageReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetBestEffortCoverageReturnsBuilder {
+            result: Option<Vec<ScriptCoverage>>,
+        }
+        impl GetBestEffortCoverageReturnsBuilder {
+            pub fn result(mut self, result: impl Into<ScriptCoverage>) -> Self {
+                let v = self.result.get_or_insert(Vec::new());
+                v.push(result.into());
+                self
+            }
+            pub fn results<I, S>(mut self, results: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ScriptCoverage>,
+            {
+                let v = self.result.get_or_insert(Vec::new());
+                for val in results {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetBestEffortCoverageReturns, String> {
+                Ok(GetBestEffortCoverageReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetBestEffortCoverageParams {
+            type Response = GetBestEffortCoverageReturns;
+        }
+        #[doc = "Changes CPU profiler sampling interval. Must be called before CPU profiles recording started.\n[setSamplingInterval](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-setSamplingInterval)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSamplingIntervalParams {
+            #[doc = "New sampling interval in microseconds."]
+            #[serde(rename = "interval")]
+            pub interval: i64,
+        }
+        impl SetSamplingIntervalParams {
+            pub fn new(interval: impl Into<i64>) -> Self {
+                Self {
+                    interval: interval.into(),
+                }
+            }
+        }
+        impl SetSamplingIntervalParams {
+            pub fn builder() -> SetSamplingIntervalParamsBuilder {
+                SetSamplingIntervalParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSamplingIntervalParamsBuilder {
+            interval: Option<i64>,
+        }
+        impl SetSamplingIntervalParamsBuilder {
+            pub fn interval(mut self, interval: impl Into<i64>) -> Self {
+                self.interval = Some(interval.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSamplingIntervalParams, String> {
+                Ok(SetSamplingIntervalParams {
+                    interval: self.interval.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(interval))
+                    })?,
+                })
+            }
+        }
+        impl SetSamplingIntervalParams {
+            pub const IDENTIFIER: &'static str = "Profiler.setSamplingInterval";
+        }
+        impl chromiumoxide_types::Method for SetSamplingIntervalParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSamplingIntervalParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Changes CPU profiler sampling interval. Must be called before CPU profiles recording started.\n[setSamplingInterval](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-setSamplingInterval)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSamplingIntervalReturns {}
+        impl chromiumoxide_types::Command for SetSamplingIntervalParams {
+            type Response = SetSamplingIntervalReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartParams {}
+        impl StartParams {
+            pub const IDENTIFIER: &'static str = "Profiler.start";
+        }
+        impl chromiumoxide_types::Method for StartParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartReturns {}
+        impl chromiumoxide_types::Command for StartParams {
+            type Response = StartReturns;
+        }
+        #[doc = "Enable precise code coverage. Coverage data for JavaScript executed before enabling precise code\ncoverage may be incomplete. Enabling prevents running optimized code and resets execution\ncounters.\n[startPreciseCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-startPreciseCoverage)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartPreciseCoverageParams {
+            #[doc = "Collect accurate call counts beyond simple 'covered' or 'not covered'."]
+            #[serde(rename = "callCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub call_count: Option<bool>,
+            #[doc = "Collect block-based coverage."]
+            #[serde(rename = "detailed")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub detailed: Option<bool>,
+            #[doc = "Allow the backend to send updates on its own initiative"]
+            #[serde(rename = "allowTriggeredUpdates")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub allow_triggered_updates: Option<bool>,
+        }
+        impl StartPreciseCoverageParams {
+            pub fn builder() -> StartPreciseCoverageParamsBuilder {
+                StartPreciseCoverageParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartPreciseCoverageParamsBuilder {
+            call_count: Option<bool>,
+            detailed: Option<bool>,
+            allow_triggered_updates: Option<bool>,
+        }
+        impl StartPreciseCoverageParamsBuilder {
+            pub fn call_count(mut self, call_count: impl Into<bool>) -> Self {
+                self.call_count = Some(call_count.into());
+                self
+            }
+            pub fn detailed(mut self, detailed: impl Into<bool>) -> Self {
+                self.detailed = Some(detailed.into());
+                self
+            }
+            pub fn allow_triggered_updates(
+                mut self,
+                allow_triggered_updates: impl Into<bool>,
+            ) -> Self {
+                self.allow_triggered_updates = Some(allow_triggered_updates.into());
+                self
+            }
+            pub fn build(self) -> StartPreciseCoverageParams {
+                StartPreciseCoverageParams {
+                    call_count: self.call_count,
+                    detailed: self.detailed,
+                    allow_triggered_updates: self.allow_triggered_updates,
+                }
+            }
+        }
+        impl StartPreciseCoverageParams {
+            pub const IDENTIFIER: &'static str = "Profiler.startPreciseCoverage";
+        }
+        impl chromiumoxide_types::Method for StartPreciseCoverageParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartPreciseCoverageParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enable precise code coverage. Coverage data for JavaScript executed before enabling precise code\ncoverage may be incomplete. Enabling prevents running optimized code and resets execution\ncounters.\n[startPreciseCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-startPreciseCoverage)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StartPreciseCoverageReturns {
+            #[doc = "Monotonically increasing time (in seconds) when the coverage update was taken in the backend."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: f64,
+        }
+        impl StartPreciseCoverageReturns {
+            pub fn new(timestamp: impl Into<f64>) -> Self {
+                Self {
+                    timestamp: timestamp.into(),
+                }
+            }
+        }
+        impl StartPreciseCoverageReturns {
+            pub fn builder() -> StartPreciseCoverageReturnsBuilder {
+                StartPreciseCoverageReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartPreciseCoverageReturnsBuilder {
+            timestamp: Option<f64>,
+        }
+        impl StartPreciseCoverageReturnsBuilder {
+            pub fn timestamp(mut self, timestamp: impl Into<f64>) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn build(self) -> Result<StartPreciseCoverageReturns, String> {
+                Ok(StartPreciseCoverageReturns {
+                    timestamp: self.timestamp.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(timestamp))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for StartPreciseCoverageParams {
+            type Response = StartPreciseCoverageReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopParams {}
+        impl StopParams {
+            pub const IDENTIFIER: &'static str = "Profiler.stop";
+        }
+        impl chromiumoxide_types::Method for StopParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StopReturns {
+            #[doc = "Recorded profile."]
+            #[serde(rename = "profile")]
+            pub profile: Profile,
+        }
+        impl StopReturns {
+            pub fn new(profile: impl Into<Profile>) -> Self {
+                Self {
+                    profile: profile.into(),
+                }
+            }
+        }
+        impl StopReturns {
+            pub fn builder() -> StopReturnsBuilder {
+                StopReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StopReturnsBuilder {
+            profile: Option<Profile>,
+        }
+        impl StopReturnsBuilder {
+            pub fn profile(mut self, profile: impl Into<Profile>) -> Self {
+                self.profile = Some(profile.into());
+                self
+            }
+            pub fn build(self) -> Result<StopReturns, String> {
+                Ok(StopReturns {
+                    profile: self.profile.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(profile))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for StopParams {
+            type Response = StopReturns;
+        }
+        #[doc = "Disable precise code coverage. Disabling releases unnecessary execution count records and allows\nexecuting optimized code.\n[stopPreciseCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-stopPreciseCoverage)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopPreciseCoverageParams {}
+        impl StopPreciseCoverageParams {
+            pub const IDENTIFIER: &'static str = "Profiler.stopPreciseCoverage";
+        }
+        impl chromiumoxide_types::Method for StopPreciseCoverageParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopPreciseCoverageParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disable precise code coverage. Disabling releases unnecessary execution count records and allows\nexecuting optimized code.\n[stopPreciseCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-stopPreciseCoverage)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopPreciseCoverageReturns {}
+        impl chromiumoxide_types::Command for StopPreciseCoverageParams {
+            type Response = StopPreciseCoverageReturns;
+        }
+        #[doc = "Collect coverage data for the current isolate, and resets execution counters. Precise code\ncoverage needs to have started.\n[takePreciseCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-takePreciseCoverage)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TakePreciseCoverageParams {}
+        impl TakePreciseCoverageParams {
+            pub const IDENTIFIER: &'static str = "Profiler.takePreciseCoverage";
+        }
+        impl chromiumoxide_types::Method for TakePreciseCoverageParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TakePreciseCoverageParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Collect coverage data for the current isolate, and resets execution counters. Precise code\ncoverage needs to have started.\n[takePreciseCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-takePreciseCoverage)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TakePreciseCoverageReturns {
+            #[doc = "Coverage data for the current isolate."]
+            #[serde(rename = "result")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub result: Vec<ScriptCoverage>,
+            #[doc = "Monotonically increasing time (in seconds) when the coverage update was taken in the backend."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: f64,
+        }
+        impl TakePreciseCoverageReturns {
+            pub fn new(result: Vec<ScriptCoverage>, timestamp: impl Into<f64>) -> Self {
+                Self {
+                    result,
+                    timestamp: timestamp.into(),
+                }
+            }
+        }
+        impl TakePreciseCoverageReturns {
+            pub fn builder() -> TakePreciseCoverageReturnsBuilder {
+                TakePreciseCoverageReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TakePreciseCoverageReturnsBuilder {
+            result: Option<Vec<ScriptCoverage>>,
+            timestamp: Option<f64>,
+        }
+        impl TakePreciseCoverageReturnsBuilder {
+            pub fn result(mut self, result: impl Into<ScriptCoverage>) -> Self {
+                let v = self.result.get_or_insert(Vec::new());
+                v.push(result.into());
+                self
+            }
+            pub fn results<I, S>(mut self, results: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ScriptCoverage>,
+            {
+                let v = self.result.get_or_insert(Vec::new());
+                for val in results {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn timestamp(mut self, timestamp: impl Into<f64>) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn build(self) -> Result<TakePreciseCoverageReturns, String> {
+                Ok(TakePreciseCoverageReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                    timestamp: self.timestamp.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(timestamp))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for TakePreciseCoverageParams {
+            type Response = TakePreciseCoverageReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventConsoleProfileFinished {
+            #[serde(rename = "id")]
+            pub id: String,
+            #[doc = "Location of console.profileEnd()."]
+            #[serde(rename = "location")]
+            pub location: super::debugger::Location,
+            #[serde(rename = "profile")]
+            pub profile: Profile,
+            #[doc = "Profile title passed as an argument to console.profile()."]
+            #[serde(rename = "title")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub title: Option<String>,
+        }
+        impl EventConsoleProfileFinished {
+            pub const IDENTIFIER: &'static str = "Profiler.consoleProfileFinished";
+        }
+        impl chromiumoxide_types::Method for EventConsoleProfileFinished {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventConsoleProfileFinished {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sent when new profile recording is started using console.profile() call.\n[consoleProfileStarted](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#event-consoleProfileStarted)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventConsoleProfileStarted {
+            #[serde(rename = "id")]
+            pub id: String,
+            #[doc = "Location of console.profile()."]
+            #[serde(rename = "location")]
+            pub location: super::debugger::Location,
+            #[doc = "Profile title passed as an argument to console.profile()."]
+            #[serde(rename = "title")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub title: Option<String>,
+        }
+        impl EventConsoleProfileStarted {
+            pub const IDENTIFIER: &'static str = "Profiler.consoleProfileStarted";
+        }
+        impl chromiumoxide_types::Method for EventConsoleProfileStarted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventConsoleProfileStarted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Reports coverage delta since the last poll (either from an event like this, or from\n`takePreciseCoverage` for the current isolate. May only be sent if precise code\ncoverage has been started. This event can be trigged by the embedder to, for example,\ntrigger collection of coverage data immediately at a certain point in time.\n[preciseCoverageDeltaUpdate](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#event-preciseCoverageDeltaUpdate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPreciseCoverageDeltaUpdate {
+            #[doc = "Monotonically increasing time (in seconds) when the coverage update was taken in the backend."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: f64,
+            #[doc = "Identifier for distinguishing coverage events."]
+            #[serde(rename = "occasion")]
+            pub occasion: String,
+            #[doc = "Coverage data for the current isolate."]
+            #[serde(rename = "result")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub result: Vec<ScriptCoverage>,
+        }
+        impl EventPreciseCoverageDeltaUpdate {
+            pub const IDENTIFIER: &'static str = "Profiler.preciseCoverageDeltaUpdate";
+        }
+        impl chromiumoxide_types::Method for EventPreciseCoverageDeltaUpdate {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPreciseCoverageDeltaUpdate {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "Runtime domain exposes JavaScript runtime by means of remote evaluation and mirror objects.\nEvaluation results are returned as mirror object that expose object type, string representation\nand unique identifier that can be used for further object reference. Original objects are\nmaintained in memory unless they are either explicitly released or are released along with the\nother objects in their object group."]
+    pub mod runtime {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Unique script identifier.\n[ScriptId](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-ScriptId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct ScriptId(String);
+        impl ScriptId {
+            pub fn new(val: impl Into<String>) -> Self {
+                ScriptId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for ScriptId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<ScriptId> for String {
+            fn from(el: ScriptId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for ScriptId {
+            fn from(expr: String) -> Self {
+                ScriptId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for ScriptId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl ScriptId {
+            pub const IDENTIFIER: &'static str = "Runtime.ScriptId";
+        }
+        #[doc = "Represents options for serialization. Overrides `generatePreview` and `returnByValue`.\n[SerializationOptions](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-SerializationOptions)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SerializationOptions {
+            #[serde(rename = "serialization")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub serialization: SerializationOptionsSerialization,
+            #[doc = "Deep serialization depth. Default is full depth. Respected only in `deep` serialization mode."]
+            #[serde(rename = "maxDepth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_depth: Option<i64>,
+            #[doc = "Embedder-specific parameters. For example if connected to V8 in Chrome these control DOM\nserialization via `maxNodeDepth: integer` and `includeShadowTree: \"none\" | \"open\" | \"all\"`.\nValues can be only of type string or integer."]
+            #[serde(rename = "additionalParameters")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub additional_parameters: Option<serde_json::Value>,
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SerializationOptionsSerialization {
+            #[doc = "Whether the result should be deep-serialized. The result is put into\n`deepSerializedValue` and `ObjectId` is provided."]
+            #[serde(rename = "deep")]
+            Deep,
+            #[doc = "Whether the result is expected to be a JSON object which should be sent by value.\nThe result is put either into `value` or into `unserializableValue`. Synonym of\n`returnByValue: true`. Overrides `returnByValue`."]
+            #[serde(rename = "json")]
+            Json,
+            #[doc = "Only remote object id is put in the result. Same bahaviour as if no\n`serializationOptions`, `generatePreview` nor `returnByValue` are provided."]
+            #[serde(rename = "idOnly")]
+            IdOnly,
+        }
+        impl AsRef<str> for SerializationOptionsSerialization {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SerializationOptionsSerialization::Deep => "deep",
+                    SerializationOptionsSerialization::Json => "json",
+                    SerializationOptionsSerialization::IdOnly => "idOnly",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SerializationOptionsSerialization {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "deep" | "Deep" => Ok(SerializationOptionsSerialization::Deep),
+                    "json" | "Json" => Ok(SerializationOptionsSerialization::Json),
+                    "idOnly" | "IdOnly" | "idonly" => Ok(SerializationOptionsSerialization::IdOnly),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl SerializationOptions {
+            pub fn new(serialization: impl Into<SerializationOptionsSerialization>) -> Self {
+                Self {
+                    serialization: serialization.into(),
+                    max_depth: None,
+                    additional_parameters: None,
+                }
+            }
+        }
+        impl SerializationOptions {
+            pub fn builder() -> SerializationOptionsBuilder {
+                SerializationOptionsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SerializationOptionsBuilder {
+            serialization: Option<SerializationOptionsSerialization>,
+            max_depth: Option<i64>,
+            additional_parameters: Option<serde_json::Value>,
+        }
+        impl SerializationOptionsBuilder {
+            pub fn serialization(
+                mut self,
+                serialization: impl Into<SerializationOptionsSerialization>,
+            ) -> Self {
+                self.serialization = Some(serialization.into());
+                self
+            }
+            pub fn max_depth(mut self, max_depth: impl Into<i64>) -> Self {
+                self.max_depth = Some(max_depth.into());
+                self
+            }
+            pub fn additional_parameters(
+                mut self,
+                additional_parameters: impl Into<serde_json::Value>,
+            ) -> Self {
+                self.additional_parameters = Some(additional_parameters.into());
+                self
+            }
+            pub fn build(self) -> Result<SerializationOptions, String> {
+                Ok(SerializationOptions {
+                    serialization: self.serialization.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(serialization))
+                    })?,
+                    max_depth: self.max_depth,
+                    additional_parameters: self.additional_parameters,
+                })
+            }
+        }
+        impl SerializationOptions {
+            pub const IDENTIFIER: &'static str = "Runtime.SerializationOptions";
+        }
+        #[doc = "Represents deep serialized value.\n[DeepSerializedValue](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-DeepSerializedValue)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeepSerializedValue {
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DeepSerializedValueType,
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<serde_json::Value>,
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<String>,
+            #[doc = "Set if value reference met more then once during serialization. In such\ncase, value is provided only to one of the serialized values. Unique\nper value in the scope of one CDP call."]
+            #[serde(rename = "weakLocalObjectReference")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub weak_local_object_reference: Option<i64>,
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DeepSerializedValueType {
+            #[serde(rename = "undefined")]
+            Undefined,
+            #[serde(rename = "null")]
+            Null,
+            #[serde(rename = "string")]
+            String,
+            #[serde(rename = "number")]
+            Number,
+            #[serde(rename = "boolean")]
+            Boolean,
+            #[serde(rename = "bigint")]
+            Bigint,
+            #[serde(rename = "regexp")]
+            Regexp,
+            #[serde(rename = "date")]
+            Date,
+            #[serde(rename = "symbol")]
+            Symbol,
+            #[serde(rename = "array")]
+            Array,
+            #[serde(rename = "object")]
+            Object,
+            #[serde(rename = "function")]
+            Function,
+            #[serde(rename = "map")]
+            Map,
+            #[serde(rename = "set")]
+            Set,
+            #[serde(rename = "weakmap")]
+            Weakmap,
+            #[serde(rename = "weakset")]
+            Weakset,
+            #[serde(rename = "error")]
+            Error,
+            #[serde(rename = "proxy")]
+            Proxy,
+            #[serde(rename = "promise")]
+            Promise,
+            #[serde(rename = "typedarray")]
+            Typedarray,
+            #[serde(rename = "arraybuffer")]
+            Arraybuffer,
+            #[serde(rename = "node")]
+            Node,
+            #[serde(rename = "window")]
+            Window,
+            #[serde(rename = "generator")]
+            Generator,
+        }
+        impl AsRef<str> for DeepSerializedValueType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DeepSerializedValueType::Undefined => "undefined",
+                    DeepSerializedValueType::Null => "null",
+                    DeepSerializedValueType::String => "string",
+                    DeepSerializedValueType::Number => "number",
+                    DeepSerializedValueType::Boolean => "boolean",
+                    DeepSerializedValueType::Bigint => "bigint",
+                    DeepSerializedValueType::Regexp => "regexp",
+                    DeepSerializedValueType::Date => "date",
+                    DeepSerializedValueType::Symbol => "symbol",
+                    DeepSerializedValueType::Array => "array",
+                    DeepSerializedValueType::Object => "object",
+                    DeepSerializedValueType::Function => "function",
+                    DeepSerializedValueType::Map => "map",
+                    DeepSerializedValueType::Set => "set",
+                    DeepSerializedValueType::Weakmap => "weakmap",
+                    DeepSerializedValueType::Weakset => "weakset",
+                    DeepSerializedValueType::Error => "error",
+                    DeepSerializedValueType::Proxy => "proxy",
+                    DeepSerializedValueType::Promise => "promise",
+                    DeepSerializedValueType::Typedarray => "typedarray",
+                    DeepSerializedValueType::Arraybuffer => "arraybuffer",
+                    DeepSerializedValueType::Node => "node",
+                    DeepSerializedValueType::Window => "window",
+                    DeepSerializedValueType::Generator => "generator",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DeepSerializedValueType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "undefined" | "Undefined" => Ok(DeepSerializedValueType::Undefined),
+                    "null" | "Null" => Ok(DeepSerializedValueType::Null),
+                    "string" | "String" => Ok(DeepSerializedValueType::String),
+                    "number" | "Number" => Ok(DeepSerializedValueType::Number),
+                    "boolean" | "Boolean" => Ok(DeepSerializedValueType::Boolean),
+                    "bigint" | "Bigint" => Ok(DeepSerializedValueType::Bigint),
+                    "regexp" | "Regexp" => Ok(DeepSerializedValueType::Regexp),
+                    "date" | "Date" => Ok(DeepSerializedValueType::Date),
+                    "symbol" | "Symbol" => Ok(DeepSerializedValueType::Symbol),
+                    "array" | "Array" => Ok(DeepSerializedValueType::Array),
+                    "object" | "Object" => Ok(DeepSerializedValueType::Object),
+                    "function" | "Function" => Ok(DeepSerializedValueType::Function),
+                    "map" | "Map" => Ok(DeepSerializedValueType::Map),
+                    "set" | "Set" => Ok(DeepSerializedValueType::Set),
+                    "weakmap" | "Weakmap" => Ok(DeepSerializedValueType::Weakmap),
+                    "weakset" | "Weakset" => Ok(DeepSerializedValueType::Weakset),
+                    "error" | "Error" => Ok(DeepSerializedValueType::Error),
+                    "proxy" | "Proxy" => Ok(DeepSerializedValueType::Proxy),
+                    "promise" | "Promise" => Ok(DeepSerializedValueType::Promise),
+                    "typedarray" | "Typedarray" => Ok(DeepSerializedValueType::Typedarray),
+                    "arraybuffer" | "Arraybuffer" => Ok(DeepSerializedValueType::Arraybuffer),
+                    "node" | "Node" => Ok(DeepSerializedValueType::Node),
+                    "window" | "Window" => Ok(DeepSerializedValueType::Window),
+                    "generator" | "Generator" => Ok(DeepSerializedValueType::Generator),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl DeepSerializedValue {
+            pub fn new(r#type: impl Into<DeepSerializedValueType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    value: None,
+                    object_id: None,
+                    weak_local_object_reference: None,
+                }
+            }
+        }
+        impl DeepSerializedValue {
+            pub fn builder() -> DeepSerializedValueBuilder {
+                DeepSerializedValueBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeepSerializedValueBuilder {
+            r#type: Option<DeepSerializedValueType>,
+            value: Option<serde_json::Value>,
+            object_id: Option<String>,
+            weak_local_object_reference: Option<i64>,
+        }
+        impl DeepSerializedValueBuilder {
+            pub fn r#type(mut self, r#type: impl Into<DeepSerializedValueType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<serde_json::Value>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn object_id(mut self, object_id: impl Into<String>) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn weak_local_object_reference(
+                mut self,
+                weak_local_object_reference: impl Into<i64>,
+            ) -> Self {
+                self.weak_local_object_reference = Some(weak_local_object_reference.into());
+                self
+            }
+            pub fn build(self) -> Result<DeepSerializedValue, String> {
+                Ok(DeepSerializedValue {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    value: self.value,
+                    object_id: self.object_id,
+                    weak_local_object_reference: self.weak_local_object_reference,
+                })
+            }
+        }
+        impl DeepSerializedValue {
+            pub const IDENTIFIER: &'static str = "Runtime.DeepSerializedValue";
+        }
+        #[doc = "Unique object identifier.\n[RemoteObjectId](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-RemoteObjectId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct RemoteObjectId(String);
+        impl RemoteObjectId {
+            pub fn new(val: impl Into<String>) -> Self {
+                RemoteObjectId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for RemoteObjectId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<RemoteObjectId> for String {
+            fn from(el: RemoteObjectId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for RemoteObjectId {
+            fn from(expr: String) -> Self {
+                RemoteObjectId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for RemoteObjectId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl RemoteObjectId {
+            pub const IDENTIFIER: &'static str = "Runtime.RemoteObjectId";
+        }
+        #[doc = "Primitive value which cannot be JSON-stringified. Includes values `-0`, `NaN`, `Infinity`,\n`-Infinity`, and bigint literals.\n[UnserializableValue](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-UnserializableValue)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct UnserializableValue(String);
+        impl UnserializableValue {
+            pub fn new(val: impl Into<String>) -> Self {
+                UnserializableValue(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for UnserializableValue {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<UnserializableValue> for String {
+            fn from(el: UnserializableValue) -> String {
+                el.0
+            }
+        }
+        impl From<String> for UnserializableValue {
+            fn from(expr: String) -> Self {
+                UnserializableValue(expr)
+            }
+        }
+        impl UnserializableValue {
+            pub const IDENTIFIER: &'static str = "Runtime.UnserializableValue";
+        }
+        #[doc = "Mirror object referencing original JavaScript object.\n[RemoteObject](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-RemoteObject)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoteObject {
+            #[doc = "Object type."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: RemoteObjectType,
+            #[doc = "Object subtype hint. Specified for `object` type values only.\nNOTE: If you change anything here, make sure to also update\n`subtype` in `ObjectPreview` and `PropertyPreview` below."]
+            #[serde(rename = "subtype")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub subtype: Option<RemoteObjectSubtype>,
+            #[doc = "Object class (constructor) name. Specified for `object` type values only."]
+            #[serde(rename = "className")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub class_name: Option<String>,
+            #[doc = "Remote object value in case of primitive values or JSON values (if it was requested)."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<serde_json::Value>,
+            #[doc = "Primitive value which can not be JSON-stringified does not have `value`, but gets this\nproperty."]
+            #[serde(rename = "unserializableValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub unserializable_value: Option<UnserializableValue>,
+            #[doc = "String representation of the object."]
+            #[serde(rename = "description")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub description: Option<String>,
+            #[doc = "Deep serialized value."]
+            #[serde(rename = "deepSerializedValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub deep_serialized_value: Option<DeepSerializedValue>,
+            #[doc = "Unique object identifier (for non-primitive values)."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<RemoteObjectId>,
+            #[doc = "Preview containing abbreviated property values. Specified for `object` type values only."]
+            #[serde(rename = "preview")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub preview: Option<ObjectPreview>,
+            #[serde(rename = "customPreview")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub custom_preview: Option<CustomPreview>,
+        }
+        #[doc = "Object type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum RemoteObjectType {
+            #[serde(rename = "object")]
+            Object,
+            #[serde(rename = "function")]
+            Function,
+            #[serde(rename = "undefined")]
+            Undefined,
+            #[serde(rename = "string")]
+            String,
+            #[serde(rename = "number")]
+            Number,
+            #[serde(rename = "boolean")]
+            Boolean,
+            #[serde(rename = "symbol")]
+            Symbol,
+            #[serde(rename = "bigint")]
+            Bigint,
+        }
+        impl AsRef<str> for RemoteObjectType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    RemoteObjectType::Object => "object",
+                    RemoteObjectType::Function => "function",
+                    RemoteObjectType::Undefined => "undefined",
+                    RemoteObjectType::String => "string",
+                    RemoteObjectType::Number => "number",
+                    RemoteObjectType::Boolean => "boolean",
+                    RemoteObjectType::Symbol => "symbol",
+                    RemoteObjectType::Bigint => "bigint",
+                }
+            }
+        }
+        impl ::std::str::FromStr for RemoteObjectType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "object" | "Object" => Ok(RemoteObjectType::Object),
+                    "function" | "Function" => Ok(RemoteObjectType::Function),
+                    "undefined" | "Undefined" => Ok(RemoteObjectType::Undefined),
+                    "string" | "String" => Ok(RemoteObjectType::String),
+                    "number" | "Number" => Ok(RemoteObjectType::Number),
+                    "boolean" | "Boolean" => Ok(RemoteObjectType::Boolean),
+                    "symbol" | "Symbol" => Ok(RemoteObjectType::Symbol),
+                    "bigint" | "Bigint" => Ok(RemoteObjectType::Bigint),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Object subtype hint. Specified for `object` type values only.\nNOTE: If you change anything here, make sure to also update\n`subtype` in `ObjectPreview` and `PropertyPreview` below."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum RemoteObjectSubtype {
+            #[serde(rename = "array")]
+            Array,
+            #[serde(rename = "null")]
+            Null,
+            #[serde(rename = "node")]
+            Node,
+            #[serde(rename = "regexp")]
+            Regexp,
+            #[serde(rename = "date")]
+            Date,
+            #[serde(rename = "map")]
+            Map,
+            #[serde(rename = "set")]
+            Set,
+            #[serde(rename = "weakmap")]
+            Weakmap,
+            #[serde(rename = "weakset")]
+            Weakset,
+            #[serde(rename = "iterator")]
+            Iterator,
+            #[serde(rename = "generator")]
+            Generator,
+            #[serde(rename = "error")]
+            Error,
+            #[serde(rename = "proxy")]
+            Proxy,
+            #[serde(rename = "promise")]
+            Promise,
+            #[serde(rename = "typedarray")]
+            Typedarray,
+            #[serde(rename = "arraybuffer")]
+            Arraybuffer,
+            #[serde(rename = "dataview")]
+            Dataview,
+            #[serde(rename = "webassemblymemory")]
+            Webassemblymemory,
+            #[serde(rename = "wasmvalue")]
+            Wasmvalue,
+            #[doc = "blink's subtypes."]
+            #[serde(rename = "trustedtype")]
+            Trustedtype,
+        }
+        impl AsRef<str> for RemoteObjectSubtype {
+            fn as_ref(&self) -> &str {
+                match self {
+                    RemoteObjectSubtype::Array => "array",
+                    RemoteObjectSubtype::Null => "null",
+                    RemoteObjectSubtype::Node => "node",
+                    RemoteObjectSubtype::Regexp => "regexp",
+                    RemoteObjectSubtype::Date => "date",
+                    RemoteObjectSubtype::Map => "map",
+                    RemoteObjectSubtype::Set => "set",
+                    RemoteObjectSubtype::Weakmap => "weakmap",
+                    RemoteObjectSubtype::Weakset => "weakset",
+                    RemoteObjectSubtype::Iterator => "iterator",
+                    RemoteObjectSubtype::Generator => "generator",
+                    RemoteObjectSubtype::Error => "error",
+                    RemoteObjectSubtype::Proxy => "proxy",
+                    RemoteObjectSubtype::Promise => "promise",
+                    RemoteObjectSubtype::Typedarray => "typedarray",
+                    RemoteObjectSubtype::Arraybuffer => "arraybuffer",
+                    RemoteObjectSubtype::Dataview => "dataview",
+                    RemoteObjectSubtype::Webassemblymemory => "webassemblymemory",
+                    RemoteObjectSubtype::Wasmvalue => "wasmvalue",
+                    RemoteObjectSubtype::Trustedtype => "trustedtype",
+                }
+            }
+        }
+        impl ::std::str::FromStr for RemoteObjectSubtype {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "array" | "Array" => Ok(RemoteObjectSubtype::Array),
+                    "null" | "Null" => Ok(RemoteObjectSubtype::Null),
+                    "node" | "Node" => Ok(RemoteObjectSubtype::Node),
+                    "regexp" | "Regexp" => Ok(RemoteObjectSubtype::Regexp),
+                    "date" | "Date" => Ok(RemoteObjectSubtype::Date),
+                    "map" | "Map" => Ok(RemoteObjectSubtype::Map),
+                    "set" | "Set" => Ok(RemoteObjectSubtype::Set),
+                    "weakmap" | "Weakmap" => Ok(RemoteObjectSubtype::Weakmap),
+                    "weakset" | "Weakset" => Ok(RemoteObjectSubtype::Weakset),
+                    "iterator" | "Iterator" => Ok(RemoteObjectSubtype::Iterator),
+                    "generator" | "Generator" => Ok(RemoteObjectSubtype::Generator),
+                    "error" | "Error" => Ok(RemoteObjectSubtype::Error),
+                    "proxy" | "Proxy" => Ok(RemoteObjectSubtype::Proxy),
+                    "promise" | "Promise" => Ok(RemoteObjectSubtype::Promise),
+                    "typedarray" | "Typedarray" => Ok(RemoteObjectSubtype::Typedarray),
+                    "arraybuffer" | "Arraybuffer" => Ok(RemoteObjectSubtype::Arraybuffer),
+                    "dataview" | "Dataview" => Ok(RemoteObjectSubtype::Dataview),
+                    "webassemblymemory" | "Webassemblymemory" => {
+                        Ok(RemoteObjectSubtype::Webassemblymemory)
+                    }
+                    "wasmvalue" | "Wasmvalue" => Ok(RemoteObjectSubtype::Wasmvalue),
+                    "trustedtype" | "Trustedtype" => Ok(RemoteObjectSubtype::Trustedtype),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl RemoteObject {
+            pub fn new(r#type: impl Into<RemoteObjectType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    subtype: None,
+                    class_name: None,
+                    value: None,
+                    unserializable_value: None,
+                    description: None,
+                    deep_serialized_value: None,
+                    object_id: None,
+                    preview: None,
+                    custom_preview: None,
+                }
+            }
+        }
+        impl RemoteObject {
+            pub fn builder() -> RemoteObjectBuilder {
+                RemoteObjectBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoteObjectBuilder {
+            r#type: Option<RemoteObjectType>,
+            subtype: Option<RemoteObjectSubtype>,
+            class_name: Option<String>,
+            value: Option<serde_json::Value>,
+            unserializable_value: Option<UnserializableValue>,
+            description: Option<String>,
+            deep_serialized_value: Option<DeepSerializedValue>,
+            object_id: Option<RemoteObjectId>,
+            preview: Option<ObjectPreview>,
+            custom_preview: Option<CustomPreview>,
+        }
+        impl RemoteObjectBuilder {
+            pub fn r#type(mut self, r#type: impl Into<RemoteObjectType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn subtype(mut self, subtype: impl Into<RemoteObjectSubtype>) -> Self {
+                self.subtype = Some(subtype.into());
+                self
+            }
+            pub fn class_name(mut self, class_name: impl Into<String>) -> Self {
+                self.class_name = Some(class_name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<serde_json::Value>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn unserializable_value(
+                mut self,
+                unserializable_value: impl Into<UnserializableValue>,
+            ) -> Self {
+                self.unserializable_value = Some(unserializable_value.into());
+                self
+            }
+            pub fn description(mut self, description: impl Into<String>) -> Self {
+                self.description = Some(description.into());
+                self
+            }
+            pub fn deep_serialized_value(
+                mut self,
+                deep_serialized_value: impl Into<DeepSerializedValue>,
+            ) -> Self {
+                self.deep_serialized_value = Some(deep_serialized_value.into());
+                self
+            }
+            pub fn object_id(mut self, object_id: impl Into<RemoteObjectId>) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn preview(mut self, preview: impl Into<ObjectPreview>) -> Self {
+                self.preview = Some(preview.into());
+                self
+            }
+            pub fn custom_preview(mut self, custom_preview: impl Into<CustomPreview>) -> Self {
+                self.custom_preview = Some(custom_preview.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoteObject, String> {
+                Ok(RemoteObject {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    subtype: self.subtype,
+                    class_name: self.class_name,
+                    value: self.value,
+                    unserializable_value: self.unserializable_value,
+                    description: self.description,
+                    deep_serialized_value: self.deep_serialized_value,
+                    object_id: self.object_id,
+                    preview: self.preview,
+                    custom_preview: self.custom_preview,
+                })
+            }
+        }
+        impl RemoteObject {
+            pub const IDENTIFIER: &'static str = "Runtime.RemoteObject";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CustomPreview {
+            #[doc = "The JSON-stringified result of formatter.header(object, config) call.\nIt contains json ML array that represents RemoteObject."]
+            #[serde(rename = "header")]
+            pub header: String,
+            #[doc = "If formatter returns true as a result of formatter.hasBody call then bodyGetterId will\ncontain RemoteObjectId for the function that returns result of formatter.body(object, config) call.\nThe result value is json ML array."]
+            #[serde(rename = "bodyGetterId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub body_getter_id: Option<RemoteObjectId>,
+        }
+        impl CustomPreview {
+            pub fn new(header: impl Into<String>) -> Self {
+                Self {
+                    header: header.into(),
+                    body_getter_id: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for CustomPreview {
+            fn from(url: T) -> Self {
+                CustomPreview::new(url)
+            }
+        }
+        impl CustomPreview {
+            pub fn builder() -> CustomPreviewBuilder {
+                CustomPreviewBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CustomPreviewBuilder {
+            header: Option<String>,
+            body_getter_id: Option<RemoteObjectId>,
+        }
+        impl CustomPreviewBuilder {
+            pub fn header(mut self, header: impl Into<String>) -> Self {
+                self.header = Some(header.into());
+                self
+            }
+            pub fn body_getter_id(mut self, body_getter_id: impl Into<RemoteObjectId>) -> Self {
+                self.body_getter_id = Some(body_getter_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CustomPreview, String> {
+                Ok(CustomPreview {
+                    header: self.header.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(header))
+                    })?,
+                    body_getter_id: self.body_getter_id,
+                })
+            }
+        }
+        impl CustomPreview {
+            pub const IDENTIFIER: &'static str = "Runtime.CustomPreview";
+        }
+        #[doc = "Object containing abbreviated remote object value.\n[ObjectPreview](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-ObjectPreview)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ObjectPreview {
+            #[doc = "Object type."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: ObjectPreviewType,
+            #[doc = "Object subtype hint. Specified for `object` type values only."]
+            #[serde(rename = "subtype")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub subtype: Option<ObjectPreviewSubtype>,
+            #[doc = "String representation of the object."]
+            #[serde(rename = "description")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub description: Option<String>,
+            #[doc = "True iff some of the properties or entries of the original object did not fit."]
+            #[serde(rename = "overflow")]
+            pub overflow: bool,
+            #[doc = "List of the properties."]
+            #[serde(rename = "properties")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub properties: Vec<PropertyPreview>,
+            #[doc = "List of the entries. Specified for `map` and `set` subtype values only."]
+            #[serde(rename = "entries")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub entries: Option<Vec<EntryPreview>>,
+        }
+        #[doc = "Object type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ObjectPreviewType {
+            #[serde(rename = "object")]
+            Object,
+            #[serde(rename = "function")]
+            Function,
+            #[serde(rename = "undefined")]
+            Undefined,
+            #[serde(rename = "string")]
+            String,
+            #[serde(rename = "number")]
+            Number,
+            #[serde(rename = "boolean")]
+            Boolean,
+            #[serde(rename = "symbol")]
+            Symbol,
+            #[serde(rename = "bigint")]
+            Bigint,
+        }
+        impl AsRef<str> for ObjectPreviewType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ObjectPreviewType::Object => "object",
+                    ObjectPreviewType::Function => "function",
+                    ObjectPreviewType::Undefined => "undefined",
+                    ObjectPreviewType::String => "string",
+                    ObjectPreviewType::Number => "number",
+                    ObjectPreviewType::Boolean => "boolean",
+                    ObjectPreviewType::Symbol => "symbol",
+                    ObjectPreviewType::Bigint => "bigint",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ObjectPreviewType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "object" | "Object" => Ok(ObjectPreviewType::Object),
+                    "function" | "Function" => Ok(ObjectPreviewType::Function),
+                    "undefined" | "Undefined" => Ok(ObjectPreviewType::Undefined),
+                    "string" | "String" => Ok(ObjectPreviewType::String),
+                    "number" | "Number" => Ok(ObjectPreviewType::Number),
+                    "boolean" | "Boolean" => Ok(ObjectPreviewType::Boolean),
+                    "symbol" | "Symbol" => Ok(ObjectPreviewType::Symbol),
+                    "bigint" | "Bigint" => Ok(ObjectPreviewType::Bigint),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Object subtype hint. Specified for `object` type values only."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ObjectPreviewSubtype {
+            #[serde(rename = "array")]
+            Array,
+            #[serde(rename = "null")]
+            Null,
+            #[serde(rename = "node")]
+            Node,
+            #[serde(rename = "regexp")]
+            Regexp,
+            #[serde(rename = "date")]
+            Date,
+            #[serde(rename = "map")]
+            Map,
+            #[serde(rename = "set")]
+            Set,
+            #[serde(rename = "weakmap")]
+            Weakmap,
+            #[serde(rename = "weakset")]
+            Weakset,
+            #[serde(rename = "iterator")]
+            Iterator,
+            #[serde(rename = "generator")]
+            Generator,
+            #[serde(rename = "error")]
+            Error,
+            #[serde(rename = "proxy")]
+            Proxy,
+            #[serde(rename = "promise")]
+            Promise,
+            #[serde(rename = "typedarray")]
+            Typedarray,
+            #[serde(rename = "arraybuffer")]
+            Arraybuffer,
+            #[serde(rename = "dataview")]
+            Dataview,
+            #[serde(rename = "webassemblymemory")]
+            Webassemblymemory,
+            #[serde(rename = "wasmvalue")]
+            Wasmvalue,
+            #[doc = "blink's subtypes."]
+            #[serde(rename = "trustedtype")]
+            Trustedtype,
+        }
+        impl AsRef<str> for ObjectPreviewSubtype {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ObjectPreviewSubtype::Array => "array",
+                    ObjectPreviewSubtype::Null => "null",
+                    ObjectPreviewSubtype::Node => "node",
+                    ObjectPreviewSubtype::Regexp => "regexp",
+                    ObjectPreviewSubtype::Date => "date",
+                    ObjectPreviewSubtype::Map => "map",
+                    ObjectPreviewSubtype::Set => "set",
+                    ObjectPreviewSubtype::Weakmap => "weakmap",
+                    ObjectPreviewSubtype::Weakset => "weakset",
+                    ObjectPreviewSubtype::Iterator => "iterator",
+                    ObjectPreviewSubtype::Generator => "generator",
+                    ObjectPreviewSubtype::Error => "error",
+                    ObjectPreviewSubtype::Proxy => "proxy",
+                    ObjectPreviewSubtype::Promise => "promise",
+                    ObjectPreviewSubtype::Typedarray => "typedarray",
+                    ObjectPreviewSubtype::Arraybuffer => "arraybuffer",
+                    ObjectPreviewSubtype::Dataview => "dataview",
+                    ObjectPreviewSubtype::Webassemblymemory => "webassemblymemory",
+                    ObjectPreviewSubtype::Wasmvalue => "wasmvalue",
+                    ObjectPreviewSubtype::Trustedtype => "trustedtype",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ObjectPreviewSubtype {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "array" | "Array" => Ok(ObjectPreviewSubtype::Array),
+                    "null" | "Null" => Ok(ObjectPreviewSubtype::Null),
+                    "node" | "Node" => Ok(ObjectPreviewSubtype::Node),
+                    "regexp" | "Regexp" => Ok(ObjectPreviewSubtype::Regexp),
+                    "date" | "Date" => Ok(ObjectPreviewSubtype::Date),
+                    "map" | "Map" => Ok(ObjectPreviewSubtype::Map),
+                    "set" | "Set" => Ok(ObjectPreviewSubtype::Set),
+                    "weakmap" | "Weakmap" => Ok(ObjectPreviewSubtype::Weakmap),
+                    "weakset" | "Weakset" => Ok(ObjectPreviewSubtype::Weakset),
+                    "iterator" | "Iterator" => Ok(ObjectPreviewSubtype::Iterator),
+                    "generator" | "Generator" => Ok(ObjectPreviewSubtype::Generator),
+                    "error" | "Error" => Ok(ObjectPreviewSubtype::Error),
+                    "proxy" | "Proxy" => Ok(ObjectPreviewSubtype::Proxy),
+                    "promise" | "Promise" => Ok(ObjectPreviewSubtype::Promise),
+                    "typedarray" | "Typedarray" => Ok(ObjectPreviewSubtype::Typedarray),
+                    "arraybuffer" | "Arraybuffer" => Ok(ObjectPreviewSubtype::Arraybuffer),
+                    "dataview" | "Dataview" => Ok(ObjectPreviewSubtype::Dataview),
+                    "webassemblymemory" | "Webassemblymemory" => {
+                        Ok(ObjectPreviewSubtype::Webassemblymemory)
+                    }
+                    "wasmvalue" | "Wasmvalue" => Ok(ObjectPreviewSubtype::Wasmvalue),
+                    "trustedtype" | "Trustedtype" => Ok(ObjectPreviewSubtype::Trustedtype),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl ObjectPreview {
+            pub fn new(
+                r#type: impl Into<ObjectPreviewType>,
+                overflow: impl Into<bool>,
+                properties: Vec<PropertyPreview>,
+            ) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    overflow: overflow.into(),
+                    properties,
+                    subtype: None,
+                    description: None,
+                    entries: None,
+                }
+            }
+        }
+        impl ObjectPreview {
+            pub fn builder() -> ObjectPreviewBuilder {
+                ObjectPreviewBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ObjectPreviewBuilder {
+            r#type: Option<ObjectPreviewType>,
+            subtype: Option<ObjectPreviewSubtype>,
+            description: Option<String>,
+            overflow: Option<bool>,
+            properties: Option<Vec<PropertyPreview>>,
+            entries: Option<Vec<EntryPreview>>,
+        }
+        impl ObjectPreviewBuilder {
+            pub fn r#type(mut self, r#type: impl Into<ObjectPreviewType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn subtype(mut self, subtype: impl Into<ObjectPreviewSubtype>) -> Self {
+                self.subtype = Some(subtype.into());
+                self
+            }
+            pub fn description(mut self, description: impl Into<String>) -> Self {
+                self.description = Some(description.into());
+                self
+            }
+            pub fn overflow(mut self, overflow: impl Into<bool>) -> Self {
+                self.overflow = Some(overflow.into());
+                self
+            }
+            pub fn propertie(mut self, propertie: impl Into<PropertyPreview>) -> Self {
+                let v = self.properties.get_or_insert(Vec::new());
+                v.push(propertie.into());
+                self
+            }
+            pub fn properties<I, S>(mut self, properties: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PropertyPreview>,
+            {
+                let v = self.properties.get_or_insert(Vec::new());
+                for val in properties {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn entrie(mut self, entrie: impl Into<EntryPreview>) -> Self {
+                let v = self.entries.get_or_insert(Vec::new());
+                v.push(entrie.into());
+                self
+            }
+            pub fn entries<I, S>(mut self, entries: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<EntryPreview>,
+            {
+                let v = self.entries.get_or_insert(Vec::new());
+                for val in entries {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ObjectPreview, String> {
+                Ok(ObjectPreview {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    subtype: self.subtype,
+                    description: self.description,
+                    overflow: self.overflow.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(overflow))
+                    })?,
+                    properties: self.properties.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(properties))
+                    })?,
+                    entries: self.entries,
+                })
+            }
+        }
+        impl ObjectPreview {
+            pub const IDENTIFIER: &'static str = "Runtime.ObjectPreview";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PropertyPreview {
+            #[doc = "Property name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Object type. Accessor means that the property itself is an accessor property."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: PropertyPreviewType,
+            #[doc = "User-friendly property value string."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<String>,
+            #[doc = "Nested value preview."]
+            #[serde(rename = "valuePreview")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value_preview: Option<ObjectPreview>,
+            #[doc = "Object subtype hint. Specified for `object` type values only."]
+            #[serde(rename = "subtype")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub subtype: Option<PropertyPreviewSubtype>,
+        }
+        #[doc = "Object type. Accessor means that the property itself is an accessor property."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PropertyPreviewType {
+            #[serde(rename = "object")]
+            Object,
+            #[serde(rename = "function")]
+            Function,
+            #[serde(rename = "undefined")]
+            Undefined,
+            #[serde(rename = "string")]
+            String,
+            #[serde(rename = "number")]
+            Number,
+            #[serde(rename = "boolean")]
+            Boolean,
+            #[serde(rename = "symbol")]
+            Symbol,
+            #[serde(rename = "accessor")]
+            Accessor,
+            #[serde(rename = "bigint")]
+            Bigint,
+        }
+        impl AsRef<str> for PropertyPreviewType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PropertyPreviewType::Object => "object",
+                    PropertyPreviewType::Function => "function",
+                    PropertyPreviewType::Undefined => "undefined",
+                    PropertyPreviewType::String => "string",
+                    PropertyPreviewType::Number => "number",
+                    PropertyPreviewType::Boolean => "boolean",
+                    PropertyPreviewType::Symbol => "symbol",
+                    PropertyPreviewType::Accessor => "accessor",
+                    PropertyPreviewType::Bigint => "bigint",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PropertyPreviewType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "object" | "Object" => Ok(PropertyPreviewType::Object),
+                    "function" | "Function" => Ok(PropertyPreviewType::Function),
+                    "undefined" | "Undefined" => Ok(PropertyPreviewType::Undefined),
+                    "string" | "String" => Ok(PropertyPreviewType::String),
+                    "number" | "Number" => Ok(PropertyPreviewType::Number),
+                    "boolean" | "Boolean" => Ok(PropertyPreviewType::Boolean),
+                    "symbol" | "Symbol" => Ok(PropertyPreviewType::Symbol),
+                    "accessor" | "Accessor" => Ok(PropertyPreviewType::Accessor),
+                    "bigint" | "Bigint" => Ok(PropertyPreviewType::Bigint),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Object subtype hint. Specified for `object` type values only."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PropertyPreviewSubtype {
+            #[serde(rename = "array")]
+            Array,
+            #[serde(rename = "null")]
+            Null,
+            #[serde(rename = "node")]
+            Node,
+            #[serde(rename = "regexp")]
+            Regexp,
+            #[serde(rename = "date")]
+            Date,
+            #[serde(rename = "map")]
+            Map,
+            #[serde(rename = "set")]
+            Set,
+            #[serde(rename = "weakmap")]
+            Weakmap,
+            #[serde(rename = "weakset")]
+            Weakset,
+            #[serde(rename = "iterator")]
+            Iterator,
+            #[serde(rename = "generator")]
+            Generator,
+            #[serde(rename = "error")]
+            Error,
+            #[serde(rename = "proxy")]
+            Proxy,
+            #[serde(rename = "promise")]
+            Promise,
+            #[serde(rename = "typedarray")]
+            Typedarray,
+            #[serde(rename = "arraybuffer")]
+            Arraybuffer,
+            #[serde(rename = "dataview")]
+            Dataview,
+            #[serde(rename = "webassemblymemory")]
+            Webassemblymemory,
+            #[serde(rename = "wasmvalue")]
+            Wasmvalue,
+            #[doc = "blink's subtypes."]
+            #[serde(rename = "trustedtype")]
+            Trustedtype,
+        }
+        impl AsRef<str> for PropertyPreviewSubtype {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PropertyPreviewSubtype::Array => "array",
+                    PropertyPreviewSubtype::Null => "null",
+                    PropertyPreviewSubtype::Node => "node",
+                    PropertyPreviewSubtype::Regexp => "regexp",
+                    PropertyPreviewSubtype::Date => "date",
+                    PropertyPreviewSubtype::Map => "map",
+                    PropertyPreviewSubtype::Set => "set",
+                    PropertyPreviewSubtype::Weakmap => "weakmap",
+                    PropertyPreviewSubtype::Weakset => "weakset",
+                    PropertyPreviewSubtype::Iterator => "iterator",
+                    PropertyPreviewSubtype::Generator => "generator",
+                    PropertyPreviewSubtype::Error => "error",
+                    PropertyPreviewSubtype::Proxy => "proxy",
+                    PropertyPreviewSubtype::Promise => "promise",
+                    PropertyPreviewSubtype::Typedarray => "typedarray",
+                    PropertyPreviewSubtype::Arraybuffer => "arraybuffer",
+                    PropertyPreviewSubtype::Dataview => "dataview",
+                    PropertyPreviewSubtype::Webassemblymemory => "webassemblymemory",
+                    PropertyPreviewSubtype::Wasmvalue => "wasmvalue",
+                    PropertyPreviewSubtype::Trustedtype => "trustedtype",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PropertyPreviewSubtype {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "array" | "Array" => Ok(PropertyPreviewSubtype::Array),
+                    "null" | "Null" => Ok(PropertyPreviewSubtype::Null),
+                    "node" | "Node" => Ok(PropertyPreviewSubtype::Node),
+                    "regexp" | "Regexp" => Ok(PropertyPreviewSubtype::Regexp),
+                    "date" | "Date" => Ok(PropertyPreviewSubtype::Date),
+                    "map" | "Map" => Ok(PropertyPreviewSubtype::Map),
+                    "set" | "Set" => Ok(PropertyPreviewSubtype::Set),
+                    "weakmap" | "Weakmap" => Ok(PropertyPreviewSubtype::Weakmap),
+                    "weakset" | "Weakset" => Ok(PropertyPreviewSubtype::Weakset),
+                    "iterator" | "Iterator" => Ok(PropertyPreviewSubtype::Iterator),
+                    "generator" | "Generator" => Ok(PropertyPreviewSubtype::Generator),
+                    "error" | "Error" => Ok(PropertyPreviewSubtype::Error),
+                    "proxy" | "Proxy" => Ok(PropertyPreviewSubtype::Proxy),
+                    "promise" | "Promise" => Ok(PropertyPreviewSubtype::Promise),
+                    "typedarray" | "Typedarray" => Ok(PropertyPreviewSubtype::Typedarray),
+                    "arraybuffer" | "Arraybuffer" => Ok(PropertyPreviewSubtype::Arraybuffer),
+                    "dataview" | "Dataview" => Ok(PropertyPreviewSubtype::Dataview),
+                    "webassemblymemory" | "Webassemblymemory" => {
+                        Ok(PropertyPreviewSubtype::Webassemblymemory)
+                    }
+                    "wasmvalue" | "Wasmvalue" => Ok(PropertyPreviewSubtype::Wasmvalue),
+                    "trustedtype" | "Trustedtype" => Ok(PropertyPreviewSubtype::Trustedtype),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl PropertyPreview {
+            pub fn new(name: impl Into<String>, r#type: impl Into<PropertyPreviewType>) -> Self {
+                Self {
+                    name: name.into(),
+                    r#type: r#type.into(),
+                    value: None,
+                    value_preview: None,
+                    subtype: None,
+                }
+            }
+        }
+        impl PropertyPreview {
+            pub fn builder() -> PropertyPreviewBuilder {
+                PropertyPreviewBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PropertyPreviewBuilder {
+            name: Option<String>,
+            r#type: Option<PropertyPreviewType>,
+            value: Option<String>,
+            value_preview: Option<ObjectPreview>,
+            subtype: Option<PropertyPreviewSubtype>,
+        }
+        impl PropertyPreviewBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<PropertyPreviewType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn value_preview(mut self, value_preview: impl Into<ObjectPreview>) -> Self {
+                self.value_preview = Some(value_preview.into());
+                self
+            }
+            pub fn subtype(mut self, subtype: impl Into<PropertyPreviewSubtype>) -> Self {
+                self.subtype = Some(subtype.into());
+                self
+            }
+            pub fn build(self) -> Result<PropertyPreview, String> {
+                Ok(PropertyPreview {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    value: self.value,
+                    value_preview: self.value_preview,
+                    subtype: self.subtype,
+                })
+            }
+        }
+        impl PropertyPreview {
+            pub const IDENTIFIER: &'static str = "Runtime.PropertyPreview";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EntryPreview {
+            #[doc = "Preview of the key. Specified for map-like collection entries."]
+            #[serde(rename = "key")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub key: Option<ObjectPreview>,
+            #[doc = "Preview of the value."]
+            #[serde(rename = "value")]
+            pub value: ObjectPreview,
+        }
+        impl EntryPreview {
+            pub fn new(value: impl Into<ObjectPreview>) -> Self {
+                Self {
+                    value: value.into(),
+                    key: None,
+                }
+            }
+        }
+        impl EntryPreview {
+            pub fn builder() -> EntryPreviewBuilder {
+                EntryPreviewBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EntryPreviewBuilder {
+            key: Option<ObjectPreview>,
+            value: Option<ObjectPreview>,
+        }
+        impl EntryPreviewBuilder {
+            pub fn key(mut self, key: impl Into<ObjectPreview>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<ObjectPreview>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<EntryPreview, String> {
+                Ok(EntryPreview {
+                    key: self.key,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl EntryPreview {
+            pub const IDENTIFIER: &'static str = "Runtime.EntryPreview";
+        }
+        #[doc = "Object property descriptor.\n[PropertyDescriptor](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-PropertyDescriptor)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PropertyDescriptor {
+            #[doc = "Property name or symbol description."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "The value associated with the property."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<RemoteObject>,
+            #[doc = "True if the value associated with the property may be changed (data descriptors only)."]
+            #[serde(rename = "writable")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub writable: Option<bool>,
+            #[doc = "A function which serves as a getter for the property, or `undefined` if there is no getter\n(accessor descriptors only)."]
+            #[serde(rename = "get")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub get: Option<RemoteObject>,
+            #[doc = "A function which serves as a setter for the property, or `undefined` if there is no setter\n(accessor descriptors only)."]
+            #[serde(rename = "set")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub set: Option<RemoteObject>,
+            #[doc = "True if the type of this property descriptor may be changed and if the property may be\ndeleted from the corresponding object."]
+            #[serde(rename = "configurable")]
+            pub configurable: bool,
+            #[doc = "True if this property shows up during enumeration of the properties on the corresponding\nobject."]
+            #[serde(rename = "enumerable")]
+            pub enumerable: bool,
+            #[doc = "True if the result was thrown during the evaluation."]
+            #[serde(rename = "wasThrown")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub was_thrown: Option<bool>,
+            #[doc = "True if the property is owned for the object."]
+            #[serde(rename = "isOwn")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_own: Option<bool>,
+            #[doc = "Property symbol object, if the property is of the `symbol` type."]
+            #[serde(rename = "symbol")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub symbol: Option<RemoteObject>,
+        }
+        impl PropertyDescriptor {
+            pub fn new(
+                name: impl Into<String>,
+                configurable: impl Into<bool>,
+                enumerable: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    configurable: configurable.into(),
+                    enumerable: enumerable.into(),
+                    value: None,
+                    writable: None,
+                    get: None,
+                    set: None,
+                    was_thrown: None,
+                    is_own: None,
+                    symbol: None,
+                }
+            }
+        }
+        impl PropertyDescriptor {
+            pub fn builder() -> PropertyDescriptorBuilder {
+                PropertyDescriptorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PropertyDescriptorBuilder {
+            name: Option<String>,
+            value: Option<RemoteObject>,
+            writable: Option<bool>,
+            get: Option<RemoteObject>,
+            set: Option<RemoteObject>,
+            configurable: Option<bool>,
+            enumerable: Option<bool>,
+            was_thrown: Option<bool>,
+            is_own: Option<bool>,
+            symbol: Option<RemoteObject>,
+        }
+        impl PropertyDescriptorBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<RemoteObject>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn writable(mut self, writable: impl Into<bool>) -> Self {
+                self.writable = Some(writable.into());
+                self
+            }
+            pub fn get(mut self, get: impl Into<RemoteObject>) -> Self {
+                self.get = Some(get.into());
+                self
+            }
+            pub fn set(mut self, set: impl Into<RemoteObject>) -> Self {
+                self.set = Some(set.into());
+                self
+            }
+            pub fn configurable(mut self, configurable: impl Into<bool>) -> Self {
+                self.configurable = Some(configurable.into());
+                self
+            }
+            pub fn enumerable(mut self, enumerable: impl Into<bool>) -> Self {
+                self.enumerable = Some(enumerable.into());
+                self
+            }
+            pub fn was_thrown(mut self, was_thrown: impl Into<bool>) -> Self {
+                self.was_thrown = Some(was_thrown.into());
+                self
+            }
+            pub fn is_own(mut self, is_own: impl Into<bool>) -> Self {
+                self.is_own = Some(is_own.into());
+                self
+            }
+            pub fn symbol(mut self, symbol: impl Into<RemoteObject>) -> Self {
+                self.symbol = Some(symbol.into());
+                self
+            }
+            pub fn build(self) -> Result<PropertyDescriptor, String> {
+                Ok(PropertyDescriptor {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value,
+                    writable: self.writable,
+                    get: self.get,
+                    set: self.set,
+                    configurable: self.configurable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(configurable))
+                    })?,
+                    enumerable: self.enumerable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enumerable))
+                    })?,
+                    was_thrown: self.was_thrown,
+                    is_own: self.is_own,
+                    symbol: self.symbol,
+                })
+            }
+        }
+        impl PropertyDescriptor {
+            pub const IDENTIFIER: &'static str = "Runtime.PropertyDescriptor";
+        }
+        #[doc = "Object internal property descriptor. This property isn't normally visible in JavaScript code.\n[InternalPropertyDescriptor](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-InternalPropertyDescriptor)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct InternalPropertyDescriptor {
+            #[doc = "Conventional property name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "The value associated with the property."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<RemoteObject>,
+        }
+        impl InternalPropertyDescriptor {
+            pub fn new(name: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for InternalPropertyDescriptor {
+            fn from(url: T) -> Self {
+                InternalPropertyDescriptor::new(url)
+            }
+        }
+        impl InternalPropertyDescriptor {
+            pub fn builder() -> InternalPropertyDescriptorBuilder {
+                InternalPropertyDescriptorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InternalPropertyDescriptorBuilder {
+            name: Option<String>,
+            value: Option<RemoteObject>,
+        }
+        impl InternalPropertyDescriptorBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<RemoteObject>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<InternalPropertyDescriptor, String> {
+                Ok(InternalPropertyDescriptor {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value,
+                })
+            }
+        }
+        impl InternalPropertyDescriptor {
+            pub const IDENTIFIER: &'static str = "Runtime.InternalPropertyDescriptor";
+        }
+        #[doc = "Object private field descriptor.\n[PrivatePropertyDescriptor](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-PrivatePropertyDescriptor)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PrivatePropertyDescriptor {
+            #[doc = "Private property name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "The value associated with the private property."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<RemoteObject>,
+            #[doc = "A function which serves as a getter for the private property,\nor `undefined` if there is no getter (accessor descriptors only)."]
+            #[serde(rename = "get")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub get: Option<RemoteObject>,
+            #[doc = "A function which serves as a setter for the private property,\nor `undefined` if there is no setter (accessor descriptors only)."]
+            #[serde(rename = "set")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub set: Option<RemoteObject>,
+        }
+        impl PrivatePropertyDescriptor {
+            pub fn new(name: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: None,
+                    get: None,
+                    set: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for PrivatePropertyDescriptor {
+            fn from(url: T) -> Self {
+                PrivatePropertyDescriptor::new(url)
+            }
+        }
+        impl PrivatePropertyDescriptor {
+            pub fn builder() -> PrivatePropertyDescriptorBuilder {
+                PrivatePropertyDescriptorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PrivatePropertyDescriptorBuilder {
+            name: Option<String>,
+            value: Option<RemoteObject>,
+            get: Option<RemoteObject>,
+            set: Option<RemoteObject>,
+        }
+        impl PrivatePropertyDescriptorBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<RemoteObject>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn get(mut self, get: impl Into<RemoteObject>) -> Self {
+                self.get = Some(get.into());
+                self
+            }
+            pub fn set(mut self, set: impl Into<RemoteObject>) -> Self {
+                self.set = Some(set.into());
+                self
+            }
+            pub fn build(self) -> Result<PrivatePropertyDescriptor, String> {
+                Ok(PrivatePropertyDescriptor {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value,
+                    get: self.get,
+                    set: self.set,
+                })
+            }
+        }
+        impl PrivatePropertyDescriptor {
+            pub const IDENTIFIER: &'static str = "Runtime.PrivatePropertyDescriptor";
+        }
+        #[doc = "Represents function call argument. Either remote object id `objectId`, primitive `value`,\nunserializable primitive value or neither of (for undefined) them should be specified.\n[CallArgument](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-CallArgument)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CallArgument {
+            #[doc = "Primitive value or serializable javascript object."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<serde_json::Value>,
+            #[doc = "Primitive value which can not be JSON-stringified."]
+            #[serde(rename = "unserializableValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub unserializable_value: Option<UnserializableValue>,
+            #[doc = "Remote object handle."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<RemoteObjectId>,
+        }
+        impl CallArgument {
+            pub fn builder() -> CallArgumentBuilder {
+                CallArgumentBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CallArgumentBuilder {
+            value: Option<serde_json::Value>,
+            unserializable_value: Option<UnserializableValue>,
+            object_id: Option<RemoteObjectId>,
+        }
+        impl CallArgumentBuilder {
+            pub fn value(mut self, value: impl Into<serde_json::Value>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn unserializable_value(
+                mut self,
+                unserializable_value: impl Into<UnserializableValue>,
+            ) -> Self {
+                self.unserializable_value = Some(unserializable_value.into());
+                self
+            }
+            pub fn object_id(mut self, object_id: impl Into<RemoteObjectId>) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> CallArgument {
+                CallArgument {
+                    value: self.value,
+                    unserializable_value: self.unserializable_value,
+                    object_id: self.object_id,
+                }
+            }
+        }
+        impl CallArgument {
+            pub const IDENTIFIER: &'static str = "Runtime.CallArgument";
+        }
+        #[doc = "Id of an execution context.\n[ExecutionContextId](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-ExecutionContextId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Copy, Hash)]
+        pub struct ExecutionContextId(i64);
+        impl ExecutionContextId {
+            pub fn new(val: impl Into<i64>) -> Self {
+                ExecutionContextId(val.into())
+            }
+            pub fn inner(&self) -> &i64 {
+                &self.0
+            }
+        }
+        impl ExecutionContextId {
+            pub const IDENTIFIER: &'static str = "Runtime.ExecutionContextId";
+        }
+        #[doc = "Description of an isolated world.\n[ExecutionContextDescription](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-ExecutionContextDescription)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ExecutionContextDescription {
+            #[doc = "Unique id of the execution context. It can be used to specify in which execution context\nscript evaluation should be performed."]
+            #[serde(rename = "id")]
+            pub id: ExecutionContextId,
+            #[doc = "Execution context origin."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "Human readable name describing given context."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "A system-unique execution context identifier. Unlike the id, this is unique across\nmultiple processes, so can be reliably used to identify specific context while backend\nperforms a cross-process navigation."]
+            #[serde(rename = "uniqueId")]
+            pub unique_id: String,
+            #[doc = "Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'|'isolated'|'worker', frameId: string}"]
+            #[serde(rename = "auxData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub aux_data: Option<serde_json::Value>,
+        }
+        impl ExecutionContextDescription {
+            pub fn new(
+                id: impl Into<ExecutionContextId>,
+                origin: impl Into<String>,
+                name: impl Into<String>,
+                unique_id: impl Into<String>,
+            ) -> Self {
+                Self {
+                    id: id.into(),
+                    origin: origin.into(),
+                    name: name.into(),
+                    unique_id: unique_id.into(),
+                    aux_data: None,
+                }
+            }
+        }
+        impl ExecutionContextDescription {
+            pub fn builder() -> ExecutionContextDescriptionBuilder {
+                ExecutionContextDescriptionBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ExecutionContextDescriptionBuilder {
+            id: Option<ExecutionContextId>,
+            origin: Option<String>,
+            name: Option<String>,
+            unique_id: Option<String>,
+            aux_data: Option<serde_json::Value>,
+        }
+        impl ExecutionContextDescriptionBuilder {
+            pub fn id(mut self, id: impl Into<ExecutionContextId>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn unique_id(mut self, unique_id: impl Into<String>) -> Self {
+                self.unique_id = Some(unique_id.into());
+                self
+            }
+            pub fn aux_data(mut self, aux_data: impl Into<serde_json::Value>) -> Self {
+                self.aux_data = Some(aux_data.into());
+                self
+            }
+            pub fn build(self) -> Result<ExecutionContextDescription, String> {
+                Ok(ExecutionContextDescription {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    unique_id: self.unique_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(unique_id))
+                    })?,
+                    aux_data: self.aux_data,
+                })
+            }
+        }
+        impl ExecutionContextDescription {
+            pub const IDENTIFIER: &'static str = "Runtime.ExecutionContextDescription";
+        }
+        #[doc = "Detailed information about exception (or error) that was thrown during script compilation or\nexecution.\n[ExceptionDetails](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-ExceptionDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ExceptionDetails {
+            #[doc = "Exception id."]
+            #[serde(rename = "exceptionId")]
+            pub exception_id: i64,
+            #[doc = "Exception text, which should be used together with exception object when available."]
+            #[serde(rename = "text")]
+            pub text: String,
+            #[doc = "Line number of the exception location (0-based)."]
+            #[serde(rename = "lineNumber")]
+            pub line_number: i64,
+            #[doc = "Column number of the exception location (0-based)."]
+            #[serde(rename = "columnNumber")]
+            pub column_number: i64,
+            #[doc = "Script ID of the exception location."]
+            #[serde(rename = "scriptId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub script_id: Option<ScriptId>,
+            #[doc = "URL of the exception location, to be used when the script was not reported."]
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[doc = "JavaScript stack trace if available."]
+            #[serde(rename = "stackTrace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stack_trace: Option<StackTrace>,
+            #[doc = "Exception object if available."]
+            #[serde(rename = "exception")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception: Option<RemoteObject>,
+            #[doc = "Identifier of the context where exception happened."]
+            #[serde(rename = "executionContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub execution_context_id: Option<ExecutionContextId>,
+            #[doc = "Dictionary with entries of meta data that the client associated\nwith this exception, such as information about associated network\nrequests, etc."]
+            #[serde(rename = "exceptionMetaData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception_meta_data: Option<serde_json::Value>,
+        }
+        impl ExceptionDetails {
+            pub fn new(
+                exception_id: impl Into<i64>,
+                text: impl Into<String>,
+                line_number: impl Into<i64>,
+                column_number: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    exception_id: exception_id.into(),
+                    text: text.into(),
+                    line_number: line_number.into(),
+                    column_number: column_number.into(),
+                    script_id: None,
+                    url: None,
+                    stack_trace: None,
+                    exception: None,
+                    execution_context_id: None,
+                    exception_meta_data: None,
+                }
+            }
+        }
+        impl ExceptionDetails {
+            pub fn builder() -> ExceptionDetailsBuilder {
+                ExceptionDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ExceptionDetailsBuilder {
+            exception_id: Option<i64>,
+            text: Option<String>,
+            line_number: Option<i64>,
+            column_number: Option<i64>,
+            script_id: Option<ScriptId>,
+            url: Option<String>,
+            stack_trace: Option<StackTrace>,
+            exception: Option<RemoteObject>,
+            execution_context_id: Option<ExecutionContextId>,
+            exception_meta_data: Option<serde_json::Value>,
+        }
+        impl ExceptionDetailsBuilder {
+            pub fn exception_id(mut self, exception_id: impl Into<i64>) -> Self {
+                self.exception_id = Some(exception_id.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<i64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn script_id(mut self, script_id: impl Into<ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn stack_trace(mut self, stack_trace: impl Into<StackTrace>) -> Self {
+                self.stack_trace = Some(stack_trace.into());
+                self
+            }
+            pub fn exception(mut self, exception: impl Into<RemoteObject>) -> Self {
+                self.exception = Some(exception.into());
+                self
+            }
+            pub fn execution_context_id(
+                mut self,
+                execution_context_id: impl Into<ExecutionContextId>,
+            ) -> Self {
+                self.execution_context_id = Some(execution_context_id.into());
+                self
+            }
+            pub fn exception_meta_data(
+                mut self,
+                exception_meta_data: impl Into<serde_json::Value>,
+            ) -> Self {
+                self.exception_meta_data = Some(exception_meta_data.into());
+                self
+            }
+            pub fn build(self) -> Result<ExceptionDetails, String> {
+                Ok(ExceptionDetails {
+                    exception_id: self.exception_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(exception_id))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    column_number: self.column_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(column_number))
+                    })?,
+                    script_id: self.script_id,
+                    url: self.url,
+                    stack_trace: self.stack_trace,
+                    exception: self.exception,
+                    execution_context_id: self.execution_context_id,
+                    exception_meta_data: self.exception_meta_data,
+                })
+            }
+        }
+        impl ExceptionDetails {
+            pub const IDENTIFIER: &'static str = "Runtime.ExceptionDetails";
+        }
+        #[doc = "Number of milliseconds since epoch.\n[Timestamp](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-Timestamp)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct Timestamp(f64);
+        impl Timestamp {
+            pub fn new(val: impl Into<f64>) -> Self {
+                Timestamp(val.into())
+            }
+            pub fn inner(&self) -> &f64 {
+                &self.0
+            }
+        }
+        impl Timestamp {
+            pub const IDENTIFIER: &'static str = "Runtime.Timestamp";
+        }
+        #[doc = "Number of milliseconds.\n[TimeDelta](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-TimeDelta)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TimeDelta(f64);
+        impl TimeDelta {
+            pub fn new(val: impl Into<f64>) -> Self {
+                TimeDelta(val.into())
+            }
+            pub fn inner(&self) -> &f64 {
+                &self.0
+            }
+        }
+        impl TimeDelta {
+            pub const IDENTIFIER: &'static str = "Runtime.TimeDelta";
+        }
+        #[doc = "Stack entry for runtime errors and assertions.\n[CallFrame](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-CallFrame)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CallFrame {
+            #[doc = "JavaScript function name."]
+            #[serde(rename = "functionName")]
+            pub function_name: String,
+            #[doc = "JavaScript script id."]
+            #[serde(rename = "scriptId")]
+            pub script_id: ScriptId,
+            #[doc = "JavaScript script name or url."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "JavaScript script line number (0-based)."]
+            #[serde(rename = "lineNumber")]
+            pub line_number: i64,
+            #[doc = "JavaScript script column number (0-based)."]
+            #[serde(rename = "columnNumber")]
+            pub column_number: i64,
+        }
+        impl CallFrame {
+            pub fn builder() -> CallFrameBuilder {
+                CallFrameBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CallFrameBuilder {
+            function_name: Option<String>,
+            script_id: Option<ScriptId>,
+            url: Option<String>,
+            line_number: Option<i64>,
+            column_number: Option<i64>,
+        }
+        impl CallFrameBuilder {
+            pub fn function_name(mut self, function_name: impl Into<String>) -> Self {
+                self.function_name = Some(function_name.into());
+                self
+            }
+            pub fn script_id(mut self, script_id: impl Into<ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<i64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn build(self) -> Result<CallFrame, String> {
+                Ok(CallFrame {
+                    function_name: self.function_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(function_name))
+                    })?,
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    column_number: self.column_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(column_number))
+                    })?,
+                })
+            }
+        }
+        impl CallFrame {
+            pub const IDENTIFIER: &'static str = "Runtime.CallFrame";
+        }
+        #[doc = "Call frames for assertions or error messages.\n[StackTrace](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-StackTrace)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StackTrace {
+            #[doc = "String label of this stack trace. For async traces this may be a name of the function that\ninitiated the async call."]
+            #[serde(rename = "description")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub description: Option<String>,
+            #[doc = "JavaScript function name."]
+            #[serde(rename = "callFrames")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub call_frames: Vec<CallFrame>,
+            #[doc = "Asynchronous JavaScript stack trace that preceded this stack, if available."]
+            #[serde(rename = "parent")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent: Option<Box<StackTrace>>,
+            #[doc = "Asynchronous JavaScript stack trace that preceded this stack, if available."]
+            #[serde(rename = "parentId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent_id: Option<StackTraceId>,
+        }
+        impl StackTrace {
+            pub fn new(call_frames: Vec<CallFrame>) -> Self {
+                Self {
+                    call_frames,
+                    description: None,
+                    parent: None,
+                    parent_id: None,
+                }
+            }
+        }
+        impl StackTrace {
+            pub fn builder() -> StackTraceBuilder {
+                StackTraceBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StackTraceBuilder {
+            description: Option<String>,
+            call_frames: Option<Vec<CallFrame>>,
+            parent: Option<StackTrace>,
+            parent_id: Option<StackTraceId>,
+        }
+        impl StackTraceBuilder {
+            pub fn description(mut self, description: impl Into<String>) -> Self {
+                self.description = Some(description.into());
+                self
+            }
+            pub fn call_frame(mut self, call_frame: impl Into<CallFrame>) -> Self {
+                let v = self.call_frames.get_or_insert(Vec::new());
+                v.push(call_frame.into());
+                self
+            }
+            pub fn call_frames<I, S>(mut self, call_frames: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CallFrame>,
+            {
+                let v = self.call_frames.get_or_insert(Vec::new());
+                for val in call_frames {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn parent(mut self, parent: impl Into<StackTrace>) -> Self {
+                self.parent = Some(parent.into());
+                self
+            }
+            pub fn parent_id(mut self, parent_id: impl Into<StackTraceId>) -> Self {
+                self.parent_id = Some(parent_id.into());
+                self
+            }
+            pub fn build(self) -> Result<StackTrace, String> {
+                Ok(StackTrace {
+                    description: self.description,
+                    call_frames: self.call_frames.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(call_frames))
+                    })?,
+                    parent: self.parent.map(Box::new),
+                    parent_id: self.parent_id,
+                })
+            }
+        }
+        impl StackTrace {
+            pub const IDENTIFIER: &'static str = "Runtime.StackTrace";
+        }
+        #[doc = "Unique identifier of current debugger.\n[UniqueDebuggerId](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-UniqueDebuggerId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct UniqueDebuggerId(String);
+        impl UniqueDebuggerId {
+            pub fn new(val: impl Into<String>) -> Self {
+                UniqueDebuggerId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for UniqueDebuggerId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<UniqueDebuggerId> for String {
+            fn from(el: UniqueDebuggerId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for UniqueDebuggerId {
+            fn from(expr: String) -> Self {
+                UniqueDebuggerId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for UniqueDebuggerId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl UniqueDebuggerId {
+            pub const IDENTIFIER: &'static str = "Runtime.UniqueDebuggerId";
+        }
+        #[doc = "If `debuggerId` is set stack trace comes from another debugger and can be resolved there. This\nallows to track cross-debugger calls. See `Runtime.StackTrace` and `Debugger.paused` for usages.\n[StackTraceId](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-StackTraceId)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StackTraceId {
+            #[serde(rename = "id")]
+            pub id: String,
+            #[serde(rename = "debuggerId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub debugger_id: Option<UniqueDebuggerId>,
+        }
+        impl StackTraceId {
+            pub fn new(id: impl Into<String>) -> Self {
+                Self {
+                    id: id.into(),
+                    debugger_id: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for StackTraceId {
+            fn from(url: T) -> Self {
+                StackTraceId::new(url)
+            }
+        }
+        impl StackTraceId {
+            pub fn builder() -> StackTraceIdBuilder {
+                StackTraceIdBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StackTraceIdBuilder {
+            id: Option<String>,
+            debugger_id: Option<UniqueDebuggerId>,
+        }
+        impl StackTraceIdBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn debugger_id(mut self, debugger_id: impl Into<UniqueDebuggerId>) -> Self {
+                self.debugger_id = Some(debugger_id.into());
+                self
+            }
+            pub fn build(self) -> Result<StackTraceId, String> {
+                Ok(StackTraceId {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    debugger_id: self.debugger_id,
+                })
+            }
+        }
+        impl StackTraceId {
+            pub const IDENTIFIER: &'static str = "Runtime.StackTraceId";
+        }
+        #[doc = "Add handler to promise with given promise object id.\n[awaitPromise](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-awaitPromise)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AwaitPromiseParams {
+            #[doc = "Identifier of the promise."]
+            #[serde(rename = "promiseObjectId")]
+            pub promise_object_id: RemoteObjectId,
+            #[doc = "Whether the result is expected to be a JSON object that should be sent by value."]
+            #[serde(rename = "returnByValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub return_by_value: Option<bool>,
+            #[doc = "Whether preview should be generated for the result."]
+            #[serde(rename = "generatePreview")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub generate_preview: Option<bool>,
+        }
+        impl AwaitPromiseParams {
+            pub fn new(promise_object_id: impl Into<RemoteObjectId>) -> Self {
+                Self {
+                    promise_object_id: promise_object_id.into(),
+                    return_by_value: None,
+                    generate_preview: None,
+                }
+            }
+        }
+        impl AwaitPromiseParams {
+            pub fn builder() -> AwaitPromiseParamsBuilder {
+                AwaitPromiseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AwaitPromiseParamsBuilder {
+            promise_object_id: Option<RemoteObjectId>,
+            return_by_value: Option<bool>,
+            generate_preview: Option<bool>,
+        }
+        impl AwaitPromiseParamsBuilder {
+            pub fn promise_object_id(
+                mut self,
+                promise_object_id: impl Into<RemoteObjectId>,
+            ) -> Self {
+                self.promise_object_id = Some(promise_object_id.into());
+                self
+            }
+            pub fn return_by_value(mut self, return_by_value: impl Into<bool>) -> Self {
+                self.return_by_value = Some(return_by_value.into());
+                self
+            }
+            pub fn generate_preview(mut self, generate_preview: impl Into<bool>) -> Self {
+                self.generate_preview = Some(generate_preview.into());
+                self
+            }
+            pub fn build(self) -> Result<AwaitPromiseParams, String> {
+                Ok(AwaitPromiseParams {
+                    promise_object_id: self.promise_object_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(promise_object_id)
+                        )
+                    })?,
+                    return_by_value: self.return_by_value,
+                    generate_preview: self.generate_preview,
+                })
+            }
+        }
+        impl AwaitPromiseParams {
+            pub const IDENTIFIER: &'static str = "Runtime.awaitPromise";
+        }
+        impl chromiumoxide_types::Method for AwaitPromiseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AwaitPromiseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Add handler to promise with given promise object id.\n[awaitPromise](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-awaitPromise)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AwaitPromiseReturns {
+            #[doc = "Promise result. Will contain rejected value if promise was rejected."]
+            #[serde(rename = "result")]
+            pub result: RemoteObject,
+            #[doc = "Exception details if stack strace is available."]
+            #[serde(rename = "exceptionDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception_details: Option<ExceptionDetails>,
+        }
+        impl AwaitPromiseReturns {
+            pub fn new(result: impl Into<RemoteObject>) -> Self {
+                Self {
+                    result: result.into(),
+                    exception_details: None,
+                }
+            }
+        }
+        impl AwaitPromiseReturns {
+            pub fn builder() -> AwaitPromiseReturnsBuilder {
+                AwaitPromiseReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AwaitPromiseReturnsBuilder {
+            result: Option<RemoteObject>,
+            exception_details: Option<ExceptionDetails>,
+        }
+        impl AwaitPromiseReturnsBuilder {
+            pub fn result(mut self, result: impl Into<RemoteObject>) -> Self {
+                self.result = Some(result.into());
+                self
+            }
+            pub fn exception_details(
+                mut self,
+                exception_details: impl Into<ExceptionDetails>,
+            ) -> Self {
+                self.exception_details = Some(exception_details.into());
+                self
+            }
+            pub fn build(self) -> Result<AwaitPromiseReturns, String> {
+                Ok(AwaitPromiseReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                    exception_details: self.exception_details,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for AwaitPromiseParams {
+            type Response = AwaitPromiseReturns;
+        }
+        #[doc = "Calls function with given declaration on the given object. Object group of the result is\ninherited from the target object.\n[callFunctionOn](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-callFunctionOn)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CallFunctionOnParams {
+            #[doc = "Declaration of the function to call."]
+            #[serde(rename = "functionDeclaration")]
+            pub function_declaration: String,
+            #[doc = "Identifier of the object to call function on. Either objectId or executionContextId should\nbe specified."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<RemoteObjectId>,
+            #[doc = "Call arguments. All call arguments must belong to the same JavaScript world as the target\nobject."]
+            #[serde(rename = "arguments")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub arguments: Option<Vec<CallArgument>>,
+            #[doc = "In silent mode exceptions thrown during evaluation are not reported and do not pause\nexecution. Overrides `setPauseOnException` state."]
+            #[serde(rename = "silent")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub silent: Option<bool>,
+            #[doc = "Whether the result is expected to be a JSON object which should be sent by value.\nCan be overriden by `serializationOptions`."]
+            #[serde(rename = "returnByValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub return_by_value: Option<bool>,
+            #[doc = "Whether preview should be generated for the result."]
+            #[serde(rename = "generatePreview")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub generate_preview: Option<bool>,
+            #[doc = "Whether execution should be treated as initiated by user in the UI."]
+            #[serde(rename = "userGesture")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub user_gesture: Option<bool>,
+            #[doc = "Whether execution should `await` for resulting value and return once awaited promise is\nresolved."]
+            #[serde(rename = "awaitPromise")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub await_promise: Option<bool>,
+            #[doc = "Specifies execution context which global object will be used to call function on. Either\nexecutionContextId or objectId should be specified."]
+            #[serde(rename = "executionContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub execution_context_id: Option<ExecutionContextId>,
+            #[doc = "Symbolic group name that can be used to release multiple objects. If objectGroup is not\nspecified and objectId is, objectGroup will be inherited from object."]
+            #[serde(rename = "objectGroup")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_group: Option<String>,
+            #[doc = "Whether to throw an exception if side effect cannot be ruled out during evaluation."]
+            #[serde(rename = "throwOnSideEffect")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub throw_on_side_effect: Option<bool>,
+            #[doc = "An alternative way to specify the execution context to call function on.\nCompared to contextId that may be reused across processes, this is guaranteed to be\nsystem-unique, so it can be used to prevent accidental function call\nin context different than intended (e.g. as a result of navigation across process\nboundaries).\nThis is mutually exclusive with `executionContextId`."]
+            #[serde(rename = "uniqueContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub unique_context_id: Option<String>,
+            #[doc = "Specifies the result serialization. If provided, overrides\n`generatePreview` and `returnByValue`."]
+            #[serde(rename = "serializationOptions")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub serialization_options: Option<SerializationOptions>,
+        }
+        impl CallFunctionOnParams {
+            pub fn new(function_declaration: impl Into<String>) -> Self {
+                Self {
+                    function_declaration: function_declaration.into(),
+                    object_id: None,
+                    arguments: None,
+                    silent: None,
+                    return_by_value: None,
+                    generate_preview: None,
+                    user_gesture: None,
+                    await_promise: None,
+                    execution_context_id: None,
+                    object_group: None,
+                    throw_on_side_effect: None,
+                    unique_context_id: None,
+                    serialization_options: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for CallFunctionOnParams {
+            fn from(url: T) -> Self {
+                CallFunctionOnParams::new(url)
+            }
+        }
+        impl CallFunctionOnParams {
+            pub fn builder() -> CallFunctionOnParamsBuilder {
+                CallFunctionOnParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CallFunctionOnParamsBuilder {
+            function_declaration: Option<String>,
+            object_id: Option<RemoteObjectId>,
+            arguments: Option<Vec<CallArgument>>,
+            silent: Option<bool>,
+            return_by_value: Option<bool>,
+            generate_preview: Option<bool>,
+            user_gesture: Option<bool>,
+            await_promise: Option<bool>,
+            execution_context_id: Option<ExecutionContextId>,
+            object_group: Option<String>,
+            throw_on_side_effect: Option<bool>,
+            unique_context_id: Option<String>,
+            serialization_options: Option<SerializationOptions>,
+        }
+        impl CallFunctionOnParamsBuilder {
+            pub fn function_declaration(mut self, function_declaration: impl Into<String>) -> Self {
+                self.function_declaration = Some(function_declaration.into());
+                self
+            }
+            pub fn object_id(mut self, object_id: impl Into<RemoteObjectId>) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn argument(mut self, argument: impl Into<CallArgument>) -> Self {
+                let v = self.arguments.get_or_insert(Vec::new());
+                v.push(argument.into());
+                self
+            }
+            pub fn arguments<I, S>(mut self, arguments: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CallArgument>,
+            {
+                let v = self.arguments.get_or_insert(Vec::new());
+                for val in arguments {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn silent(mut self, silent: impl Into<bool>) -> Self {
+                self.silent = Some(silent.into());
+                self
+            }
+            pub fn return_by_value(mut self, return_by_value: impl Into<bool>) -> Self {
+                self.return_by_value = Some(return_by_value.into());
+                self
+            }
+            pub fn generate_preview(mut self, generate_preview: impl Into<bool>) -> Self {
+                self.generate_preview = Some(generate_preview.into());
+                self
+            }
+            pub fn user_gesture(mut self, user_gesture: impl Into<bool>) -> Self {
+                self.user_gesture = Some(user_gesture.into());
+                self
+            }
+            pub fn await_promise(mut self, await_promise: impl Into<bool>) -> Self {
+                self.await_promise = Some(await_promise.into());
+                self
+            }
+            pub fn execution_context_id(
+                mut self,
+                execution_context_id: impl Into<ExecutionContextId>,
+            ) -> Self {
+                self.execution_context_id = Some(execution_context_id.into());
+                self
+            }
+            pub fn object_group(mut self, object_group: impl Into<String>) -> Self {
+                self.object_group = Some(object_group.into());
+                self
+            }
+            pub fn throw_on_side_effect(mut self, throw_on_side_effect: impl Into<bool>) -> Self {
+                self.throw_on_side_effect = Some(throw_on_side_effect.into());
+                self
+            }
+            pub fn unique_context_id(mut self, unique_context_id: impl Into<String>) -> Self {
+                self.unique_context_id = Some(unique_context_id.into());
+                self
+            }
+            pub fn serialization_options(
+                mut self,
+                serialization_options: impl Into<SerializationOptions>,
+            ) -> Self {
+                self.serialization_options = Some(serialization_options.into());
+                self
+            }
+            pub fn build(self) -> Result<CallFunctionOnParams, String> {
+                Ok(CallFunctionOnParams {
+                    function_declaration: self.function_declaration.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(function_declaration)
+                        )
+                    })?,
+                    object_id: self.object_id,
+                    arguments: self.arguments,
+                    silent: self.silent,
+                    return_by_value: self.return_by_value,
+                    generate_preview: self.generate_preview,
+                    user_gesture: self.user_gesture,
+                    await_promise: self.await_promise,
+                    execution_context_id: self.execution_context_id,
+                    object_group: self.object_group,
+                    throw_on_side_effect: self.throw_on_side_effect,
+                    unique_context_id: self.unique_context_id,
+                    serialization_options: self.serialization_options,
+                })
+            }
+        }
+        impl CallFunctionOnParams {
+            pub const IDENTIFIER: &'static str = "Runtime.callFunctionOn";
+        }
+        impl chromiumoxide_types::Method for CallFunctionOnParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CallFunctionOnParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Calls function with given declaration on the given object. Object group of the result is\ninherited from the target object.\n[callFunctionOn](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-callFunctionOn)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CallFunctionOnReturns {
+            #[doc = "Call result."]
+            #[serde(rename = "result")]
+            pub result: RemoteObject,
+            #[doc = "Exception details."]
+            #[serde(rename = "exceptionDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception_details: Option<ExceptionDetails>,
+        }
+        impl CallFunctionOnReturns {
+            pub fn new(result: impl Into<RemoteObject>) -> Self {
+                Self {
+                    result: result.into(),
+                    exception_details: None,
+                }
+            }
+        }
+        impl CallFunctionOnReturns {
+            pub fn builder() -> CallFunctionOnReturnsBuilder {
+                CallFunctionOnReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CallFunctionOnReturnsBuilder {
+            result: Option<RemoteObject>,
+            exception_details: Option<ExceptionDetails>,
+        }
+        impl CallFunctionOnReturnsBuilder {
+            pub fn result(mut self, result: impl Into<RemoteObject>) -> Self {
+                self.result = Some(result.into());
+                self
+            }
+            pub fn exception_details(
+                mut self,
+                exception_details: impl Into<ExceptionDetails>,
+            ) -> Self {
+                self.exception_details = Some(exception_details.into());
+                self
+            }
+            pub fn build(self) -> Result<CallFunctionOnReturns, String> {
+                Ok(CallFunctionOnReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                    exception_details: self.exception_details,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CallFunctionOnParams {
+            type Response = CallFunctionOnReturns;
+        }
+        #[doc = "Compiles expression.\n[compileScript](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-compileScript)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CompileScriptParams {
+            #[doc = "Expression to compile."]
+            #[serde(rename = "expression")]
+            pub expression: String,
+            #[doc = "Source url to be set for the script."]
+            #[serde(rename = "sourceURL")]
+            pub source_url: String,
+            #[doc = "Specifies whether the compiled script should be persisted."]
+            #[serde(rename = "persistScript")]
+            pub persist_script: bool,
+            #[doc = "Specifies in which execution context to perform script run. If the parameter is omitted the\nevaluation will be performed in the context of the inspected page."]
+            #[serde(rename = "executionContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub execution_context_id: Option<ExecutionContextId>,
+        }
+        impl CompileScriptParams {
+            pub fn new(
+                expression: impl Into<String>,
+                source_url: impl Into<String>,
+                persist_script: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    expression: expression.into(),
+                    source_url: source_url.into(),
+                    persist_script: persist_script.into(),
+                    execution_context_id: None,
+                }
+            }
+        }
+        impl CompileScriptParams {
+            pub fn builder() -> CompileScriptParamsBuilder {
+                CompileScriptParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CompileScriptParamsBuilder {
+            expression: Option<String>,
+            source_url: Option<String>,
+            persist_script: Option<bool>,
+            execution_context_id: Option<ExecutionContextId>,
+        }
+        impl CompileScriptParamsBuilder {
+            pub fn expression(mut self, expression: impl Into<String>) -> Self {
+                self.expression = Some(expression.into());
+                self
+            }
+            pub fn source_url(mut self, source_url: impl Into<String>) -> Self {
+                self.source_url = Some(source_url.into());
+                self
+            }
+            pub fn persist_script(mut self, persist_script: impl Into<bool>) -> Self {
+                self.persist_script = Some(persist_script.into());
+                self
+            }
+            pub fn execution_context_id(
+                mut self,
+                execution_context_id: impl Into<ExecutionContextId>,
+            ) -> Self {
+                self.execution_context_id = Some(execution_context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CompileScriptParams, String> {
+                Ok(CompileScriptParams {
+                    expression: self.expression.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expression))
+                    })?,
+                    source_url: self.source_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source_url))
+                    })?,
+                    persist_script: self.persist_script.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(persist_script))
+                    })?,
+                    execution_context_id: self.execution_context_id,
+                })
+            }
+        }
+        impl CompileScriptParams {
+            pub const IDENTIFIER: &'static str = "Runtime.compileScript";
+        }
+        impl chromiumoxide_types::Method for CompileScriptParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CompileScriptParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Compiles expression.\n[compileScript](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-compileScript)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CompileScriptReturns {
+            #[doc = "Id of the script."]
+            #[serde(rename = "scriptId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub script_id: Option<ScriptId>,
+            #[doc = "Exception details."]
+            #[serde(rename = "exceptionDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception_details: Option<ExceptionDetails>,
+        }
+        impl CompileScriptReturns {
+            pub fn builder() -> CompileScriptReturnsBuilder {
+                CompileScriptReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CompileScriptReturnsBuilder {
+            script_id: Option<ScriptId>,
+            exception_details: Option<ExceptionDetails>,
+        }
+        impl CompileScriptReturnsBuilder {
+            pub fn script_id(mut self, script_id: impl Into<ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn exception_details(
+                mut self,
+                exception_details: impl Into<ExceptionDetails>,
+            ) -> Self {
+                self.exception_details = Some(exception_details.into());
+                self
+            }
+            pub fn build(self) -> CompileScriptReturns {
+                CompileScriptReturns {
+                    script_id: self.script_id,
+                    exception_details: self.exception_details,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for CompileScriptParams {
+            type Response = CompileScriptReturns;
+        }
+        #[doc = "Disables reporting of execution contexts creation.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Runtime.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables reporting of execution contexts creation.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Discards collected exceptions and console API calls.\n[discardConsoleEntries](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-discardConsoleEntries)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DiscardConsoleEntriesParams {}
+        impl DiscardConsoleEntriesParams {
+            pub const IDENTIFIER: &'static str = "Runtime.discardConsoleEntries";
+        }
+        impl chromiumoxide_types::Method for DiscardConsoleEntriesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DiscardConsoleEntriesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Discards collected exceptions and console API calls.\n[discardConsoleEntries](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-discardConsoleEntries)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DiscardConsoleEntriesReturns {}
+        impl chromiumoxide_types::Command for DiscardConsoleEntriesParams {
+            type Response = DiscardConsoleEntriesReturns;
+        }
+        #[doc = "Enables reporting of execution contexts creation by means of `executionContextCreated` event.\nWhen the reporting gets enabled the event will be sent immediately for each existing execution\ncontext.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Runtime.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables reporting of execution contexts creation by means of `executionContextCreated` event.\nWhen the reporting gets enabled the event will be sent immediately for each existing execution\ncontext.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Evaluates expression on global object.\n[evaluate](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-evaluate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EvaluateParams {
+            #[doc = "Expression to evaluate."]
+            #[serde(rename = "expression")]
+            pub expression: String,
+            #[doc = "Symbolic group name that can be used to release multiple objects."]
+            #[serde(rename = "objectGroup")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_group: Option<String>,
+            #[doc = "Determines whether Command Line API should be available during the evaluation."]
+            #[serde(rename = "includeCommandLineAPI")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_command_line_api: Option<bool>,
+            #[doc = "In silent mode exceptions thrown during evaluation are not reported and do not pause\nexecution. Overrides `setPauseOnException` state."]
+            #[serde(rename = "silent")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub silent: Option<bool>,
+            #[doc = "Specifies in which execution context to perform evaluation. If the parameter is omitted the\nevaluation will be performed in the context of the inspected page.\nThis is mutually exclusive with `uniqueContextId`, which offers an\nalternative way to identify the execution context that is more reliable\nin a multi-process environment."]
+            #[serde(rename = "contextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub context_id: Option<ExecutionContextId>,
+            #[doc = "Whether the result is expected to be a JSON object that should be sent by value."]
+            #[serde(rename = "returnByValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub return_by_value: Option<bool>,
+            #[doc = "Whether preview should be generated for the result."]
+            #[serde(rename = "generatePreview")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub generate_preview: Option<bool>,
+            #[doc = "Whether execution should be treated as initiated by user in the UI."]
+            #[serde(rename = "userGesture")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub user_gesture: Option<bool>,
+            #[doc = "Whether execution should `await` for resulting value and return once awaited promise is\nresolved."]
+            #[serde(rename = "awaitPromise")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub await_promise: Option<bool>,
+            #[doc = "Whether to throw an exception if side effect cannot be ruled out during evaluation.\nThis implies `disableBreaks` below."]
+            #[serde(rename = "throwOnSideEffect")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub throw_on_side_effect: Option<bool>,
+            #[doc = "Terminate execution after timing out (number of milliseconds)."]
+            #[serde(rename = "timeout")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub timeout: Option<TimeDelta>,
+            #[doc = "Disable breakpoints during execution."]
+            #[serde(rename = "disableBreaks")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub disable_breaks: Option<bool>,
+            #[doc = "Setting this flag to true enables `let` re-declaration and top-level `await`.\nNote that `let` variables can only be re-declared if they originate from\n`replMode` themselves."]
+            #[serde(rename = "replMode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub repl_mode: Option<bool>,
+            #[doc = "The Content Security Policy (CSP) for the target might block 'unsafe-eval'\nwhich includes eval(), Function(), setTimeout() and setInterval()\nwhen called with non-callable arguments. This flag bypasses CSP for this\nevaluation and allows unsafe-eval. Defaults to true."]
+            #[serde(rename = "allowUnsafeEvalBlockedByCSP")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub allow_unsafe_eval_blocked_by_csp: Option<bool>,
+            #[doc = "An alternative way to specify the execution context to evaluate in.\nCompared to contextId that may be reused across processes, this is guaranteed to be\nsystem-unique, so it can be used to prevent accidental evaluation of the expression\nin context different than intended (e.g. as a result of navigation across process\nboundaries).\nThis is mutually exclusive with `contextId`."]
+            #[serde(rename = "uniqueContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub unique_context_id: Option<String>,
+            #[doc = "Specifies the result serialization. If provided, overrides\n`generatePreview` and `returnByValue`."]
+            #[serde(rename = "serializationOptions")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub serialization_options: Option<SerializationOptions>,
+            #[doc = r" This is a manually added field that is not part of the protocol definition, hence ignored during serde operations."]
+            #[doc = r""]
+            #[doc = r" If set to true, this field indicates, that if the command resulted in a response value of type `function` this, `EvaluateParams` command should be executed as a `CallFunctionOnParams` instead."]
+            #[serde(skip)]
+            pub eval_as_function_fallback: Option<bool>,
+        }
+        impl EvaluateParams {
+            pub fn new(expression: impl Into<String>) -> Self {
+                Self {
+                    expression: expression.into(),
+                    object_group: None,
+                    include_command_line_api: None,
+                    silent: None,
+                    context_id: None,
+                    return_by_value: None,
+                    generate_preview: None,
+                    user_gesture: None,
+                    await_promise: None,
+                    throw_on_side_effect: None,
+                    timeout: None,
+                    disable_breaks: None,
+                    repl_mode: None,
+                    allow_unsafe_eval_blocked_by_csp: None,
+                    unique_context_id: None,
+                    serialization_options: None,
+                    eval_as_function_fallback: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for EvaluateParams {
+            fn from(url: T) -> Self {
+                EvaluateParams::new(url)
+            }
+        }
+        impl EvaluateParams {
+            pub fn builder() -> EvaluateParamsBuilder {
+                EvaluateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EvaluateParamsBuilder {
+            expression: Option<String>,
+            object_group: Option<String>,
+            include_command_line_api: Option<bool>,
+            silent: Option<bool>,
+            context_id: Option<ExecutionContextId>,
+            return_by_value: Option<bool>,
+            generate_preview: Option<bool>,
+            user_gesture: Option<bool>,
+            await_promise: Option<bool>,
+            throw_on_side_effect: Option<bool>,
+            timeout: Option<TimeDelta>,
+            disable_breaks: Option<bool>,
+            repl_mode: Option<bool>,
+            allow_unsafe_eval_blocked_by_csp: Option<bool>,
+            unique_context_id: Option<String>,
+            serialization_options: Option<SerializationOptions>,
+            eval_as_function_fallback: Option<bool>,
+        }
+        impl EvaluateParamsBuilder {
+            pub fn expression(mut self, expression: impl Into<String>) -> Self {
+                self.expression = Some(expression.into());
+                self
+            }
+            pub fn object_group(mut self, object_group: impl Into<String>) -> Self {
+                self.object_group = Some(object_group.into());
+                self
+            }
+            pub fn include_command_line_api(
+                mut self,
+                include_command_line_api: impl Into<bool>,
+            ) -> Self {
+                self.include_command_line_api = Some(include_command_line_api.into());
+                self
+            }
+            pub fn silent(mut self, silent: impl Into<bool>) -> Self {
+                self.silent = Some(silent.into());
+                self
+            }
+            pub fn context_id(mut self, context_id: impl Into<ExecutionContextId>) -> Self {
+                self.context_id = Some(context_id.into());
+                self
+            }
+            pub fn return_by_value(mut self, return_by_value: impl Into<bool>) -> Self {
+                self.return_by_value = Some(return_by_value.into());
+                self
+            }
+            pub fn generate_preview(mut self, generate_preview: impl Into<bool>) -> Self {
+                self.generate_preview = Some(generate_preview.into());
+                self
+            }
+            pub fn user_gesture(mut self, user_gesture: impl Into<bool>) -> Self {
+                self.user_gesture = Some(user_gesture.into());
+                self
+            }
+            pub fn await_promise(mut self, await_promise: impl Into<bool>) -> Self {
+                self.await_promise = Some(await_promise.into());
+                self
+            }
+            pub fn throw_on_side_effect(mut self, throw_on_side_effect: impl Into<bool>) -> Self {
+                self.throw_on_side_effect = Some(throw_on_side_effect.into());
+                self
+            }
+            pub fn timeout(mut self, timeout: impl Into<TimeDelta>) -> Self {
+                self.timeout = Some(timeout.into());
+                self
+            }
+            pub fn disable_breaks(mut self, disable_breaks: impl Into<bool>) -> Self {
+                self.disable_breaks = Some(disable_breaks.into());
+                self
+            }
+            pub fn repl_mode(mut self, repl_mode: impl Into<bool>) -> Self {
+                self.repl_mode = Some(repl_mode.into());
+                self
+            }
+            pub fn allow_unsafe_eval_blocked_by_csp(
+                mut self,
+                allow_unsafe_eval_blocked_by_csp: impl Into<bool>,
+            ) -> Self {
+                self.allow_unsafe_eval_blocked_by_csp =
+                    Some(allow_unsafe_eval_blocked_by_csp.into());
+                self
+            }
+            pub fn unique_context_id(mut self, unique_context_id: impl Into<String>) -> Self {
+                self.unique_context_id = Some(unique_context_id.into());
+                self
+            }
+            pub fn serialization_options(
+                mut self,
+                serialization_options: impl Into<SerializationOptions>,
+            ) -> Self {
+                self.serialization_options = Some(serialization_options.into());
+                self
+            }
+            pub fn eval_as_function_fallback(
+                mut self,
+                eval_as_function_fallback: impl Into<bool>,
+            ) -> Self {
+                self.eval_as_function_fallback = Some(eval_as_function_fallback.into());
+                self
+            }
+            pub fn build(self) -> Result<EvaluateParams, String> {
+                Ok(EvaluateParams {
+                    expression: self.expression.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expression))
+                    })?,
+                    object_group: self.object_group,
+                    include_command_line_api: self.include_command_line_api,
+                    silent: self.silent,
+                    context_id: self.context_id,
+                    return_by_value: self.return_by_value,
+                    generate_preview: self.generate_preview,
+                    user_gesture: self.user_gesture,
+                    await_promise: self.await_promise,
+                    throw_on_side_effect: self.throw_on_side_effect,
+                    timeout: self.timeout,
+                    disable_breaks: self.disable_breaks,
+                    repl_mode: self.repl_mode,
+                    allow_unsafe_eval_blocked_by_csp: self.allow_unsafe_eval_blocked_by_csp,
+                    unique_context_id: self.unique_context_id,
+                    serialization_options: self.serialization_options,
+                    eval_as_function_fallback: self.eval_as_function_fallback,
+                })
+            }
+        }
+        impl EvaluateParams {
+            pub const IDENTIFIER: &'static str = "Runtime.evaluate";
+        }
+        impl chromiumoxide_types::Method for EvaluateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EvaluateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Evaluates expression on global object.\n[evaluate](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-evaluate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EvaluateReturns {
+            #[doc = "Evaluation result."]
+            #[serde(rename = "result")]
+            pub result: RemoteObject,
+            #[doc = "Exception details."]
+            #[serde(rename = "exceptionDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception_details: Option<ExceptionDetails>,
+            #[doc = r" This is a manually added field that is not part of the protocol definition, hence ignored during serde operations."]
+            #[doc = r""]
+            #[doc = r" If set to true, this field indicates, that if the command resulted in a response value of type `function` this, `EvaluateParams` command should be executed as a `CallFunctionOnParams` instead."]
+            #[serde(skip)]
+            pub eval_as_function_fallback: Option<bool>,
+        }
+        impl EvaluateReturns {
+            pub fn new(result: impl Into<RemoteObject>) -> Self {
+                Self {
+                    result: result.into(),
+                    exception_details: None,
+                    eval_as_function_fallback: None,
+                }
+            }
+        }
+        impl EvaluateReturns {
+            pub fn builder() -> EvaluateReturnsBuilder {
+                EvaluateReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EvaluateReturnsBuilder {
+            result: Option<RemoteObject>,
+            exception_details: Option<ExceptionDetails>,
+            eval_as_function_fallback: Option<bool>,
+        }
+        impl EvaluateReturnsBuilder {
+            pub fn result(mut self, result: impl Into<RemoteObject>) -> Self {
+                self.result = Some(result.into());
+                self
+            }
+            pub fn exception_details(
+                mut self,
+                exception_details: impl Into<ExceptionDetails>,
+            ) -> Self {
+                self.exception_details = Some(exception_details.into());
+                self
+            }
+            pub fn eval_as_function_fallback(
+                mut self,
+                eval_as_function_fallback: impl Into<bool>,
+            ) -> Self {
+                self.eval_as_function_fallback = Some(eval_as_function_fallback.into());
+                self
+            }
+            pub fn build(self) -> Result<EvaluateReturns, String> {
+                Ok(EvaluateReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                    exception_details: self.exception_details,
+                    eval_as_function_fallback: self.eval_as_function_fallback,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for EvaluateParams {
+            type Response = EvaluateReturns;
+        }
+        #[doc = "Returns the isolate id.\n[getIsolateId](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getIsolateId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetIsolateIdParams {}
+        impl GetIsolateIdParams {
+            pub const IDENTIFIER: &'static str = "Runtime.getIsolateId";
+        }
+        impl chromiumoxide_types::Method for GetIsolateIdParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetIsolateIdParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the isolate id.\n[getIsolateId](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getIsolateId)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetIsolateIdReturns {
+            #[doc = "The isolate id."]
+            #[serde(rename = "id")]
+            pub id: String,
+        }
+        impl GetIsolateIdReturns {
+            pub fn new(id: impl Into<String>) -> Self {
+                Self { id: id.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetIsolateIdReturns {
+            fn from(url: T) -> Self {
+                GetIsolateIdReturns::new(url)
+            }
+        }
+        impl GetIsolateIdReturns {
+            pub fn builder() -> GetIsolateIdReturnsBuilder {
+                GetIsolateIdReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetIsolateIdReturnsBuilder {
+            id: Option<String>,
+        }
+        impl GetIsolateIdReturnsBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetIsolateIdReturns, String> {
+                Ok(GetIsolateIdReturns {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetIsolateIdParams {
+            type Response = GetIsolateIdReturns;
+        }
+        #[doc = "Returns the JavaScript heap usage.\nIt is the total usage of the corresponding isolate not scoped to a particular Runtime.\n[getHeapUsage](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getHeapUsage)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetHeapUsageParams {}
+        impl GetHeapUsageParams {
+            pub const IDENTIFIER: &'static str = "Runtime.getHeapUsage";
+        }
+        impl chromiumoxide_types::Method for GetHeapUsageParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetHeapUsageParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the JavaScript heap usage.\nIt is the total usage of the corresponding isolate not scoped to a particular Runtime.\n[getHeapUsage](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getHeapUsage)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetHeapUsageReturns {
+            #[doc = "Used JavaScript heap size in bytes."]
+            #[serde(rename = "usedSize")]
+            pub used_size: f64,
+            #[doc = "Allocated JavaScript heap size in bytes."]
+            #[serde(rename = "totalSize")]
+            pub total_size: f64,
+            #[doc = "Used size in bytes in the embedder's garbage-collected heap."]
+            #[serde(rename = "embedderHeapUsedSize")]
+            pub embedder_heap_used_size: f64,
+            #[doc = "Size in bytes of backing storage for array buffers and external strings."]
+            #[serde(rename = "backingStorageSize")]
+            pub backing_storage_size: f64,
+        }
+        impl GetHeapUsageReturns {
+            pub fn new(
+                used_size: impl Into<f64>,
+                total_size: impl Into<f64>,
+                embedder_heap_used_size: impl Into<f64>,
+                backing_storage_size: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    used_size: used_size.into(),
+                    total_size: total_size.into(),
+                    embedder_heap_used_size: embedder_heap_used_size.into(),
+                    backing_storage_size: backing_storage_size.into(),
+                }
+            }
+        }
+        impl GetHeapUsageReturns {
+            pub fn builder() -> GetHeapUsageReturnsBuilder {
+                GetHeapUsageReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetHeapUsageReturnsBuilder {
+            used_size: Option<f64>,
+            total_size: Option<f64>,
+            embedder_heap_used_size: Option<f64>,
+            backing_storage_size: Option<f64>,
+        }
+        impl GetHeapUsageReturnsBuilder {
+            pub fn used_size(mut self, used_size: impl Into<f64>) -> Self {
+                self.used_size = Some(used_size.into());
+                self
+            }
+            pub fn total_size(mut self, total_size: impl Into<f64>) -> Self {
+                self.total_size = Some(total_size.into());
+                self
+            }
+            pub fn embedder_heap_used_size(
+                mut self,
+                embedder_heap_used_size: impl Into<f64>,
+            ) -> Self {
+                self.embedder_heap_used_size = Some(embedder_heap_used_size.into());
+                self
+            }
+            pub fn backing_storage_size(mut self, backing_storage_size: impl Into<f64>) -> Self {
+                self.backing_storage_size = Some(backing_storage_size.into());
+                self
+            }
+            pub fn build(self) -> Result<GetHeapUsageReturns, String> {
+                Ok(GetHeapUsageReturns {
+                    used_size: self.used_size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(used_size))
+                    })?,
+                    total_size: self.total_size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(total_size))
+                    })?,
+                    embedder_heap_used_size: self.embedder_heap_used_size.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(embedder_heap_used_size)
+                        )
+                    })?,
+                    backing_storage_size: self.backing_storage_size.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(backing_storage_size)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetHeapUsageParams {
+            type Response = GetHeapUsageReturns;
+        }
+        #[doc = "Returns properties of a given object. Object group of the result is inherited from the target\nobject.\n[getProperties](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getProperties)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetPropertiesParams {
+            #[doc = "Identifier of the object to return properties for."]
+            #[serde(rename = "objectId")]
+            pub object_id: RemoteObjectId,
+            #[doc = "If true, returns properties belonging only to the element itself, not to its prototype\nchain."]
+            #[serde(rename = "ownProperties")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub own_properties: Option<bool>,
+            #[doc = "If true, returns accessor properties (with getter/setter) only; internal properties are not\nreturned either."]
+            #[serde(rename = "accessorPropertiesOnly")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub accessor_properties_only: Option<bool>,
+            #[doc = "Whether preview should be generated for the results."]
+            #[serde(rename = "generatePreview")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub generate_preview: Option<bool>,
+            #[doc = "If true, returns non-indexed properties only."]
+            #[serde(rename = "nonIndexedPropertiesOnly")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub non_indexed_properties_only: Option<bool>,
+        }
+        impl GetPropertiesParams {
+            pub fn new(object_id: impl Into<RemoteObjectId>) -> Self {
+                Self {
+                    object_id: object_id.into(),
+                    own_properties: None,
+                    accessor_properties_only: None,
+                    generate_preview: None,
+                    non_indexed_properties_only: None,
+                }
+            }
+        }
+        impl GetPropertiesParams {
+            pub fn builder() -> GetPropertiesParamsBuilder {
+                GetPropertiesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPropertiesParamsBuilder {
+            object_id: Option<RemoteObjectId>,
+            own_properties: Option<bool>,
+            accessor_properties_only: Option<bool>,
+            generate_preview: Option<bool>,
+            non_indexed_properties_only: Option<bool>,
+        }
+        impl GetPropertiesParamsBuilder {
+            pub fn object_id(mut self, object_id: impl Into<RemoteObjectId>) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn own_properties(mut self, own_properties: impl Into<bool>) -> Self {
+                self.own_properties = Some(own_properties.into());
+                self
+            }
+            pub fn accessor_properties_only(
+                mut self,
+                accessor_properties_only: impl Into<bool>,
+            ) -> Self {
+                self.accessor_properties_only = Some(accessor_properties_only.into());
+                self
+            }
+            pub fn generate_preview(mut self, generate_preview: impl Into<bool>) -> Self {
+                self.generate_preview = Some(generate_preview.into());
+                self
+            }
+            pub fn non_indexed_properties_only(
+                mut self,
+                non_indexed_properties_only: impl Into<bool>,
+            ) -> Self {
+                self.non_indexed_properties_only = Some(non_indexed_properties_only.into());
+                self
+            }
+            pub fn build(self) -> Result<GetPropertiesParams, String> {
+                Ok(GetPropertiesParams {
+                    object_id: self.object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_id))
+                    })?,
+                    own_properties: self.own_properties,
+                    accessor_properties_only: self.accessor_properties_only,
+                    generate_preview: self.generate_preview,
+                    non_indexed_properties_only: self.non_indexed_properties_only,
+                })
+            }
+        }
+        impl GetPropertiesParams {
+            pub const IDENTIFIER: &'static str = "Runtime.getProperties";
+        }
+        impl chromiumoxide_types::Method for GetPropertiesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetPropertiesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns properties of a given object. Object group of the result is inherited from the target\nobject.\n[getProperties](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getProperties)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetPropertiesReturns {
+            #[doc = "Object properties."]
+            #[serde(rename = "result")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub result: Vec<PropertyDescriptor>,
+            #[doc = "Internal object properties (only of the element itself)."]
+            #[serde(rename = "internalProperties")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub internal_properties: Option<Vec<InternalPropertyDescriptor>>,
+            #[doc = "Object private properties."]
+            #[serde(rename = "privateProperties")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub private_properties: Option<Vec<PrivatePropertyDescriptor>>,
+            #[doc = "Exception details."]
+            #[serde(rename = "exceptionDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception_details: Option<ExceptionDetails>,
+        }
+        impl GetPropertiesReturns {
+            pub fn new(result: Vec<PropertyDescriptor>) -> Self {
+                Self {
+                    result,
+                    internal_properties: None,
+                    private_properties: None,
+                    exception_details: None,
+                }
+            }
+        }
+        impl GetPropertiesReturns {
+            pub fn builder() -> GetPropertiesReturnsBuilder {
+                GetPropertiesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPropertiesReturnsBuilder {
+            result: Option<Vec<PropertyDescriptor>>,
+            internal_properties: Option<Vec<InternalPropertyDescriptor>>,
+            private_properties: Option<Vec<PrivatePropertyDescriptor>>,
+            exception_details: Option<ExceptionDetails>,
+        }
+        impl GetPropertiesReturnsBuilder {
+            pub fn result(mut self, result: impl Into<PropertyDescriptor>) -> Self {
+                let v = self.result.get_or_insert(Vec::new());
+                v.push(result.into());
+                self
+            }
+            pub fn results<I, S>(mut self, results: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PropertyDescriptor>,
+            {
+                let v = self.result.get_or_insert(Vec::new());
+                for val in results {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn internal_propertie(
+                mut self,
+                internal_propertie: impl Into<InternalPropertyDescriptor>,
+            ) -> Self {
+                let v = self.internal_properties.get_or_insert(Vec::new());
+                v.push(internal_propertie.into());
+                self
+            }
+            pub fn internal_properties<I, S>(mut self, internal_properties: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<InternalPropertyDescriptor>,
+            {
+                let v = self.internal_properties.get_or_insert(Vec::new());
+                for val in internal_properties {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn private_propertie(
+                mut self,
+                private_propertie: impl Into<PrivatePropertyDescriptor>,
+            ) -> Self {
+                let v = self.private_properties.get_or_insert(Vec::new());
+                v.push(private_propertie.into());
+                self
+            }
+            pub fn private_properties<I, S>(mut self, private_properties: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PrivatePropertyDescriptor>,
+            {
+                let v = self.private_properties.get_or_insert(Vec::new());
+                for val in private_properties {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn exception_details(
+                mut self,
+                exception_details: impl Into<ExceptionDetails>,
+            ) -> Self {
+                self.exception_details = Some(exception_details.into());
+                self
+            }
+            pub fn build(self) -> Result<GetPropertiesReturns, String> {
+                Ok(GetPropertiesReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                    internal_properties: self.internal_properties,
+                    private_properties: self.private_properties,
+                    exception_details: self.exception_details,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetPropertiesParams {
+            type Response = GetPropertiesReturns;
+        }
+        #[doc = "Returns all let, const and class variables from global scope.\n[globalLexicalScopeNames](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-globalLexicalScopeNames)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GlobalLexicalScopeNamesParams {
+            #[doc = "Specifies in which execution context to lookup global scope variables."]
+            #[serde(rename = "executionContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub execution_context_id: Option<ExecutionContextId>,
+        }
+        impl GlobalLexicalScopeNamesParams {
+            pub fn builder() -> GlobalLexicalScopeNamesParamsBuilder {
+                GlobalLexicalScopeNamesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GlobalLexicalScopeNamesParamsBuilder {
+            execution_context_id: Option<ExecutionContextId>,
+        }
+        impl GlobalLexicalScopeNamesParamsBuilder {
+            pub fn execution_context_id(
+                mut self,
+                execution_context_id: impl Into<ExecutionContextId>,
+            ) -> Self {
+                self.execution_context_id = Some(execution_context_id.into());
+                self
+            }
+            pub fn build(self) -> GlobalLexicalScopeNamesParams {
+                GlobalLexicalScopeNamesParams {
+                    execution_context_id: self.execution_context_id,
+                }
+            }
+        }
+        impl GlobalLexicalScopeNamesParams {
+            pub const IDENTIFIER: &'static str = "Runtime.globalLexicalScopeNames";
+        }
+        impl chromiumoxide_types::Method for GlobalLexicalScopeNamesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GlobalLexicalScopeNamesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns all let, const and class variables from global scope.\n[globalLexicalScopeNames](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-globalLexicalScopeNames)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GlobalLexicalScopeNamesReturns {
+            #[serde(rename = "names")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub names: Vec<String>,
+        }
+        impl GlobalLexicalScopeNamesReturns {
+            pub fn new(names: Vec<String>) -> Self {
+                Self { names }
+            }
+        }
+        impl GlobalLexicalScopeNamesReturns {
+            pub fn builder() -> GlobalLexicalScopeNamesReturnsBuilder {
+                GlobalLexicalScopeNamesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GlobalLexicalScopeNamesReturnsBuilder {
+            names: Option<Vec<String>>,
+        }
+        impl GlobalLexicalScopeNamesReturnsBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                let v = self.names.get_or_insert(Vec::new());
+                v.push(name.into());
+                self
+            }
+            pub fn names<I, S>(mut self, names: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.names.get_or_insert(Vec::new());
+                for val in names {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GlobalLexicalScopeNamesReturns, String> {
+                Ok(GlobalLexicalScopeNamesReturns {
+                    names: self.names.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(names))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GlobalLexicalScopeNamesParams {
+            type Response = GlobalLexicalScopeNamesReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct QueryObjectsParams {
+            #[doc = "Identifier of the prototype to return objects for."]
+            #[serde(rename = "prototypeObjectId")]
+            pub prototype_object_id: RemoteObjectId,
+            #[doc = "Symbolic group name that can be used to release the results."]
+            #[serde(rename = "objectGroup")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_group: Option<String>,
+        }
+        impl QueryObjectsParams {
+            pub fn new(prototype_object_id: impl Into<RemoteObjectId>) -> Self {
+                Self {
+                    prototype_object_id: prototype_object_id.into(),
+                    object_group: None,
+                }
+            }
+        }
+        impl QueryObjectsParams {
+            pub fn builder() -> QueryObjectsParamsBuilder {
+                QueryObjectsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct QueryObjectsParamsBuilder {
+            prototype_object_id: Option<RemoteObjectId>,
+            object_group: Option<String>,
+        }
+        impl QueryObjectsParamsBuilder {
+            pub fn prototype_object_id(
+                mut self,
+                prototype_object_id: impl Into<RemoteObjectId>,
+            ) -> Self {
+                self.prototype_object_id = Some(prototype_object_id.into());
+                self
+            }
+            pub fn object_group(mut self, object_group: impl Into<String>) -> Self {
+                self.object_group = Some(object_group.into());
+                self
+            }
+            pub fn build(self) -> Result<QueryObjectsParams, String> {
+                Ok(QueryObjectsParams {
+                    prototype_object_id: self.prototype_object_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(prototype_object_id)
+                        )
+                    })?,
+                    object_group: self.object_group,
+                })
+            }
+        }
+        impl QueryObjectsParams {
+            pub const IDENTIFIER: &'static str = "Runtime.queryObjects";
+        }
+        impl chromiumoxide_types::Method for QueryObjectsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for QueryObjectsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct QueryObjectsReturns {
+            #[doc = "Array with objects."]
+            #[serde(rename = "objects")]
+            pub objects: RemoteObject,
+        }
+        impl QueryObjectsReturns {
+            pub fn new(objects: impl Into<RemoteObject>) -> Self {
+                Self {
+                    objects: objects.into(),
+                }
+            }
+        }
+        impl QueryObjectsReturns {
+            pub fn builder() -> QueryObjectsReturnsBuilder {
+                QueryObjectsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct QueryObjectsReturnsBuilder {
+            objects: Option<RemoteObject>,
+        }
+        impl QueryObjectsReturnsBuilder {
+            pub fn objects(mut self, objects: impl Into<RemoteObject>) -> Self {
+                self.objects = Some(objects.into());
+                self
+            }
+            pub fn build(self) -> Result<QueryObjectsReturns, String> {
+                Ok(QueryObjectsReturns {
+                    objects: self.objects.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(objects))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for QueryObjectsParams {
+            type Response = QueryObjectsReturns;
+        }
+        #[doc = "Releases remote object with given id.\n[releaseObject](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-releaseObject)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReleaseObjectParams {
+            #[doc = "Identifier of the object to release."]
+            #[serde(rename = "objectId")]
+            pub object_id: RemoteObjectId,
+        }
+        impl ReleaseObjectParams {
+            pub fn new(object_id: impl Into<RemoteObjectId>) -> Self {
+                Self {
+                    object_id: object_id.into(),
+                }
+            }
+        }
+        impl ReleaseObjectParams {
+            pub fn builder() -> ReleaseObjectParamsBuilder {
+                ReleaseObjectParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReleaseObjectParamsBuilder {
+            object_id: Option<RemoteObjectId>,
+        }
+        impl ReleaseObjectParamsBuilder {
+            pub fn object_id(mut self, object_id: impl Into<RemoteObjectId>) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ReleaseObjectParams, String> {
+                Ok(ReleaseObjectParams {
+                    object_id: self.object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_id))
+                    })?,
+                })
+            }
+        }
+        impl ReleaseObjectParams {
+            pub const IDENTIFIER: &'static str = "Runtime.releaseObject";
+        }
+        impl chromiumoxide_types::Method for ReleaseObjectParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ReleaseObjectParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Releases remote object with given id.\n[releaseObject](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-releaseObject)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ReleaseObjectReturns {}
+        impl chromiumoxide_types::Command for ReleaseObjectParams {
+            type Response = ReleaseObjectReturns;
+        }
+        #[doc = "Releases all remote objects that belong to a given group.\n[releaseObjectGroup](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-releaseObjectGroup)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReleaseObjectGroupParams {
+            #[doc = "Symbolic object group name."]
+            #[serde(rename = "objectGroup")]
+            pub object_group: String,
+        }
+        impl ReleaseObjectGroupParams {
+            pub fn new(object_group: impl Into<String>) -> Self {
+                Self {
+                    object_group: object_group.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for ReleaseObjectGroupParams {
+            fn from(url: T) -> Self {
+                ReleaseObjectGroupParams::new(url)
+            }
+        }
+        impl ReleaseObjectGroupParams {
+            pub fn builder() -> ReleaseObjectGroupParamsBuilder {
+                ReleaseObjectGroupParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReleaseObjectGroupParamsBuilder {
+            object_group: Option<String>,
+        }
+        impl ReleaseObjectGroupParamsBuilder {
+            pub fn object_group(mut self, object_group: impl Into<String>) -> Self {
+                self.object_group = Some(object_group.into());
+                self
+            }
+            pub fn build(self) -> Result<ReleaseObjectGroupParams, String> {
+                Ok(ReleaseObjectGroupParams {
+                    object_group: self.object_group.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_group))
+                    })?,
+                })
+            }
+        }
+        impl ReleaseObjectGroupParams {
+            pub const IDENTIFIER: &'static str = "Runtime.releaseObjectGroup";
+        }
+        impl chromiumoxide_types::Method for ReleaseObjectGroupParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ReleaseObjectGroupParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Releases all remote objects that belong to a given group.\n[releaseObjectGroup](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-releaseObjectGroup)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ReleaseObjectGroupReturns {}
+        impl chromiumoxide_types::Command for ReleaseObjectGroupParams {
+            type Response = ReleaseObjectGroupReturns;
+        }
+        #[doc = "Tells inspected instance to run if it was waiting for debugger to attach.\n[runIfWaitingForDebugger](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-runIfWaitingForDebugger)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RunIfWaitingForDebuggerParams {}
+        impl RunIfWaitingForDebuggerParams {
+            pub const IDENTIFIER: &'static str = "Runtime.runIfWaitingForDebugger";
+        }
+        impl chromiumoxide_types::Method for RunIfWaitingForDebuggerParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RunIfWaitingForDebuggerParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Tells inspected instance to run if it was waiting for debugger to attach.\n[runIfWaitingForDebugger](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-runIfWaitingForDebugger)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RunIfWaitingForDebuggerReturns {}
+        impl chromiumoxide_types::Command for RunIfWaitingForDebuggerParams {
+            type Response = RunIfWaitingForDebuggerReturns;
+        }
+        #[doc = "Runs script with given id in a given context.\n[runScript](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-runScript)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RunScriptParams {
+            #[doc = "Id of the script to run."]
+            #[serde(rename = "scriptId")]
+            pub script_id: ScriptId,
+            #[doc = "Specifies in which execution context to perform script run. If the parameter is omitted the\nevaluation will be performed in the context of the inspected page."]
+            #[serde(rename = "executionContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub execution_context_id: Option<ExecutionContextId>,
+            #[doc = "Symbolic group name that can be used to release multiple objects."]
+            #[serde(rename = "objectGroup")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_group: Option<String>,
+            #[doc = "In silent mode exceptions thrown during evaluation are not reported and do not pause\nexecution. Overrides `setPauseOnException` state."]
+            #[serde(rename = "silent")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub silent: Option<bool>,
+            #[doc = "Determines whether Command Line API should be available during the evaluation."]
+            #[serde(rename = "includeCommandLineAPI")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_command_line_api: Option<bool>,
+            #[doc = "Whether the result is expected to be a JSON object which should be sent by value."]
+            #[serde(rename = "returnByValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub return_by_value: Option<bool>,
+            #[doc = "Whether preview should be generated for the result."]
+            #[serde(rename = "generatePreview")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub generate_preview: Option<bool>,
+            #[doc = "Whether execution should `await` for resulting value and return once awaited promise is\nresolved."]
+            #[serde(rename = "awaitPromise")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub await_promise: Option<bool>,
+        }
+        impl RunScriptParams {
+            pub fn new(script_id: impl Into<ScriptId>) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                    execution_context_id: None,
+                    object_group: None,
+                    silent: None,
+                    include_command_line_api: None,
+                    return_by_value: None,
+                    generate_preview: None,
+                    await_promise: None,
+                }
+            }
+        }
+        impl RunScriptParams {
+            pub fn builder() -> RunScriptParamsBuilder {
+                RunScriptParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RunScriptParamsBuilder {
+            script_id: Option<ScriptId>,
+            execution_context_id: Option<ExecutionContextId>,
+            object_group: Option<String>,
+            silent: Option<bool>,
+            include_command_line_api: Option<bool>,
+            return_by_value: Option<bool>,
+            generate_preview: Option<bool>,
+            await_promise: Option<bool>,
+        }
+        impl RunScriptParamsBuilder {
+            pub fn script_id(mut self, script_id: impl Into<ScriptId>) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn execution_context_id(
+                mut self,
+                execution_context_id: impl Into<ExecutionContextId>,
+            ) -> Self {
+                self.execution_context_id = Some(execution_context_id.into());
+                self
+            }
+            pub fn object_group(mut self, object_group: impl Into<String>) -> Self {
+                self.object_group = Some(object_group.into());
+                self
+            }
+            pub fn silent(mut self, silent: impl Into<bool>) -> Self {
+                self.silent = Some(silent.into());
+                self
+            }
+            pub fn include_command_line_api(
+                mut self,
+                include_command_line_api: impl Into<bool>,
+            ) -> Self {
+                self.include_command_line_api = Some(include_command_line_api.into());
+                self
+            }
+            pub fn return_by_value(mut self, return_by_value: impl Into<bool>) -> Self {
+                self.return_by_value = Some(return_by_value.into());
+                self
+            }
+            pub fn generate_preview(mut self, generate_preview: impl Into<bool>) -> Self {
+                self.generate_preview = Some(generate_preview.into());
+                self
+            }
+            pub fn await_promise(mut self, await_promise: impl Into<bool>) -> Self {
+                self.await_promise = Some(await_promise.into());
+                self
+            }
+            pub fn build(self) -> Result<RunScriptParams, String> {
+                Ok(RunScriptParams {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    execution_context_id: self.execution_context_id,
+                    object_group: self.object_group,
+                    silent: self.silent,
+                    include_command_line_api: self.include_command_line_api,
+                    return_by_value: self.return_by_value,
+                    generate_preview: self.generate_preview,
+                    await_promise: self.await_promise,
+                })
+            }
+        }
+        impl RunScriptParams {
+            pub const IDENTIFIER: &'static str = "Runtime.runScript";
+        }
+        impl chromiumoxide_types::Method for RunScriptParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RunScriptParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Runs script with given id in a given context.\n[runScript](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-runScript)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RunScriptReturns {
+            #[doc = "Run result."]
+            #[serde(rename = "result")]
+            pub result: RemoteObject,
+            #[doc = "Exception details."]
+            #[serde(rename = "exceptionDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception_details: Option<ExceptionDetails>,
+        }
+        impl RunScriptReturns {
+            pub fn new(result: impl Into<RemoteObject>) -> Self {
+                Self {
+                    result: result.into(),
+                    exception_details: None,
+                }
+            }
+        }
+        impl RunScriptReturns {
+            pub fn builder() -> RunScriptReturnsBuilder {
+                RunScriptReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RunScriptReturnsBuilder {
+            result: Option<RemoteObject>,
+            exception_details: Option<ExceptionDetails>,
+        }
+        impl RunScriptReturnsBuilder {
+            pub fn result(mut self, result: impl Into<RemoteObject>) -> Self {
+                self.result = Some(result.into());
+                self
+            }
+            pub fn exception_details(
+                mut self,
+                exception_details: impl Into<ExceptionDetails>,
+            ) -> Self {
+                self.exception_details = Some(exception_details.into());
+                self
+            }
+            pub fn build(self) -> Result<RunScriptReturns, String> {
+                Ok(RunScriptReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                    exception_details: self.exception_details,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for RunScriptParams {
+            type Response = RunScriptReturns;
+        }
+        #[doc = "Enables or disables async call stacks tracking.\n[setAsyncCallStackDepth](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-setAsyncCallStackDepth)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAsyncCallStackDepthParams {
+            #[doc = "Maximum depth of async call stacks. Setting to `0` will effectively disable collecting async\ncall stacks (default)."]
+            #[serde(rename = "maxDepth")]
+            pub max_depth: i64,
+        }
+        impl SetAsyncCallStackDepthParams {
+            pub fn new(max_depth: impl Into<i64>) -> Self {
+                Self {
+                    max_depth: max_depth.into(),
+                }
+            }
+        }
+        impl SetAsyncCallStackDepthParams {
+            pub fn builder() -> SetAsyncCallStackDepthParamsBuilder {
+                SetAsyncCallStackDepthParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAsyncCallStackDepthParamsBuilder {
+            max_depth: Option<i64>,
+        }
+        impl SetAsyncCallStackDepthParamsBuilder {
+            pub fn max_depth(mut self, max_depth: impl Into<i64>) -> Self {
+                self.max_depth = Some(max_depth.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAsyncCallStackDepthParams, String> {
+                Ok(SetAsyncCallStackDepthParams {
+                    max_depth: self.max_depth.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(max_depth))
+                    })?,
+                })
+            }
+        }
+        impl SetAsyncCallStackDepthParams {
+            pub const IDENTIFIER: &'static str = "Runtime.setAsyncCallStackDepth";
+        }
+        impl chromiumoxide_types::Method for SetAsyncCallStackDepthParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAsyncCallStackDepthParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables or disables async call stacks tracking.\n[setAsyncCallStackDepth](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-setAsyncCallStackDepth)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAsyncCallStackDepthReturns {}
+        impl chromiumoxide_types::Command for SetAsyncCallStackDepthParams {
+            type Response = SetAsyncCallStackDepthReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetCustomObjectFormatterEnabledParams {
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetCustomObjectFormatterEnabledParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetCustomObjectFormatterEnabledParams {
+            pub fn builder() -> SetCustomObjectFormatterEnabledParamsBuilder {
+                SetCustomObjectFormatterEnabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetCustomObjectFormatterEnabledParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetCustomObjectFormatterEnabledParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetCustomObjectFormatterEnabledParams, String> {
+                Ok(SetCustomObjectFormatterEnabledParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetCustomObjectFormatterEnabledParams {
+            pub const IDENTIFIER: &'static str = "Runtime.setCustomObjectFormatterEnabled";
+        }
+        impl chromiumoxide_types::Method for SetCustomObjectFormatterEnabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetCustomObjectFormatterEnabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetCustomObjectFormatterEnabledReturns {}
+        impl chromiumoxide_types::Command for SetCustomObjectFormatterEnabledParams {
+            type Response = SetCustomObjectFormatterEnabledReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetMaxCallStackSizeToCaptureParams {
+            #[serde(rename = "size")]
+            pub size: i64,
+        }
+        impl SetMaxCallStackSizeToCaptureParams {
+            pub fn new(size: impl Into<i64>) -> Self {
+                Self { size: size.into() }
+            }
+        }
+        impl SetMaxCallStackSizeToCaptureParams {
+            pub fn builder() -> SetMaxCallStackSizeToCaptureParamsBuilder {
+                SetMaxCallStackSizeToCaptureParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetMaxCallStackSizeToCaptureParamsBuilder {
+            size: Option<i64>,
+        }
+        impl SetMaxCallStackSizeToCaptureParamsBuilder {
+            pub fn size(mut self, size: impl Into<i64>) -> Self {
+                self.size = Some(size.into());
+                self
+            }
+            pub fn build(self) -> Result<SetMaxCallStackSizeToCaptureParams, String> {
+                Ok(SetMaxCallStackSizeToCaptureParams {
+                    size: self.size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(size))
+                    })?,
+                })
+            }
+        }
+        impl SetMaxCallStackSizeToCaptureParams {
+            pub const IDENTIFIER: &'static str = "Runtime.setMaxCallStackSizeToCapture";
+        }
+        impl chromiumoxide_types::Method for SetMaxCallStackSizeToCaptureParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetMaxCallStackSizeToCaptureParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetMaxCallStackSizeToCaptureReturns {}
+        impl chromiumoxide_types::Command for SetMaxCallStackSizeToCaptureParams {
+            type Response = SetMaxCallStackSizeToCaptureReturns;
+        }
+        #[doc = "Terminate current or next JavaScript execution.\nWill cancel the termination when the outer-most script execution ends.\n[terminateExecution](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-terminateExecution)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TerminateExecutionParams {}
+        impl TerminateExecutionParams {
+            pub const IDENTIFIER: &'static str = "Runtime.terminateExecution";
+        }
+        impl chromiumoxide_types::Method for TerminateExecutionParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TerminateExecutionParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Terminate current or next JavaScript execution.\nWill cancel the termination when the outer-most script execution ends.\n[terminateExecution](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-terminateExecution)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TerminateExecutionReturns {}
+        impl chromiumoxide_types::Command for TerminateExecutionParams {
+            type Response = TerminateExecutionReturns;
+        }
+        #[doc = "If executionContextId is empty, adds binding with the given name on the\nglobal objects of all inspected contexts, including those created later,\nbindings survive reloads.\nBinding function takes exactly one argument, this argument should be string,\nin case of any other input, function throws an exception.\nEach binding function call produces Runtime.bindingCalled notification.\n[addBinding](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-addBinding)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddBindingParams {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "If specified, the binding is exposed to the executionContext with\nmatching name, even for contexts created after the binding is added.\nSee also `ExecutionContext.name` and `worldName` parameter to\n`Page.addScriptToEvaluateOnNewDocument`.\nThis parameter is mutually exclusive with `executionContextId`."]
+            #[serde(rename = "executionContextName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub execution_context_name: Option<String>,
+        }
+        impl AddBindingParams {
+            pub fn new(name: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    execution_context_name: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for AddBindingParams {
+            fn from(url: T) -> Self {
+                AddBindingParams::new(url)
+            }
+        }
+        impl AddBindingParams {
+            pub fn builder() -> AddBindingParamsBuilder {
+                AddBindingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddBindingParamsBuilder {
+            name: Option<String>,
+            execution_context_name: Option<String>,
+        }
+        impl AddBindingParamsBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn execution_context_name(
+                mut self,
+                execution_context_name: impl Into<String>,
+            ) -> Self {
+                self.execution_context_name = Some(execution_context_name.into());
+                self
+            }
+            pub fn build(self) -> Result<AddBindingParams, String> {
+                Ok(AddBindingParams {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    execution_context_name: self.execution_context_name,
+                })
+            }
+        }
+        impl AddBindingParams {
+            pub const IDENTIFIER: &'static str = "Runtime.addBinding";
+        }
+        impl chromiumoxide_types::Method for AddBindingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddBindingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "If executionContextId is empty, adds binding with the given name on the\nglobal objects of all inspected contexts, including those created later,\nbindings survive reloads.\nBinding function takes exactly one argument, this argument should be string,\nin case of any other input, function throws an exception.\nEach binding function call produces Runtime.bindingCalled notification.\n[addBinding](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-addBinding)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct AddBindingReturns {}
+        impl chromiumoxide_types::Command for AddBindingParams {
+            type Response = AddBindingReturns;
+        }
+        #[doc = "This method does not remove binding function from global object but\nunsubscribes current runtime agent from Runtime.bindingCalled notifications.\n[removeBinding](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-removeBinding)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveBindingParams {
+            #[serde(rename = "name")]
+            pub name: String,
+        }
+        impl RemoveBindingParams {
+            pub fn new(name: impl Into<String>) -> Self {
+                Self { name: name.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for RemoveBindingParams {
+            fn from(url: T) -> Self {
+                RemoveBindingParams::new(url)
+            }
+        }
+        impl RemoveBindingParams {
+            pub fn builder() -> RemoveBindingParamsBuilder {
+                RemoveBindingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveBindingParamsBuilder {
+            name: Option<String>,
+        }
+        impl RemoveBindingParamsBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveBindingParams, String> {
+                Ok(RemoveBindingParams {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                })
+            }
+        }
+        impl RemoveBindingParams {
+            pub const IDENTIFIER: &'static str = "Runtime.removeBinding";
+        }
+        impl chromiumoxide_types::Method for RemoveBindingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveBindingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "This method does not remove binding function from global object but\nunsubscribes current runtime agent from Runtime.bindingCalled notifications.\n[removeBinding](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-removeBinding)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveBindingReturns {}
+        impl chromiumoxide_types::Command for RemoveBindingParams {
+            type Response = RemoveBindingReturns;
+        }
+        #[doc = "This method tries to lookup and populate exception details for a\nJavaScript Error object.\nNote that the stackTrace portion of the resulting exceptionDetails will\nonly be populated if the Runtime domain was enabled at the time when the\nError was thrown.\n[getExceptionDetails](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getExceptionDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetExceptionDetailsParams {
+            #[doc = "The error object for which to resolve the exception details."]
+            #[serde(rename = "errorObjectId")]
+            pub error_object_id: RemoteObjectId,
+        }
+        impl GetExceptionDetailsParams {
+            pub fn new(error_object_id: impl Into<RemoteObjectId>) -> Self {
+                Self {
+                    error_object_id: error_object_id.into(),
+                }
+            }
+        }
+        impl GetExceptionDetailsParams {
+            pub fn builder() -> GetExceptionDetailsParamsBuilder {
+                GetExceptionDetailsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetExceptionDetailsParamsBuilder {
+            error_object_id: Option<RemoteObjectId>,
+        }
+        impl GetExceptionDetailsParamsBuilder {
+            pub fn error_object_id(mut self, error_object_id: impl Into<RemoteObjectId>) -> Self {
+                self.error_object_id = Some(error_object_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetExceptionDetailsParams, String> {
+                Ok(GetExceptionDetailsParams {
+                    error_object_id: self.error_object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(error_object_id))
+                    })?,
+                })
+            }
+        }
+        impl GetExceptionDetailsParams {
+            pub const IDENTIFIER: &'static str = "Runtime.getExceptionDetails";
+        }
+        impl chromiumoxide_types::Method for GetExceptionDetailsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetExceptionDetailsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "This method tries to lookup and populate exception details for a\nJavaScript Error object.\nNote that the stackTrace portion of the resulting exceptionDetails will\nonly be populated if the Runtime domain was enabled at the time when the\nError was thrown.\n[getExceptionDetails](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getExceptionDetails)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetExceptionDetailsReturns {
+            #[serde(rename = "exceptionDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exception_details: Option<ExceptionDetails>,
+        }
+        impl GetExceptionDetailsReturns {
+            pub fn builder() -> GetExceptionDetailsReturnsBuilder {
+                GetExceptionDetailsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetExceptionDetailsReturnsBuilder {
+            exception_details: Option<ExceptionDetails>,
+        }
+        impl GetExceptionDetailsReturnsBuilder {
+            pub fn exception_details(
+                mut self,
+                exception_details: impl Into<ExceptionDetails>,
+            ) -> Self {
+                self.exception_details = Some(exception_details.into());
+                self
+            }
+            pub fn build(self) -> GetExceptionDetailsReturns {
+                GetExceptionDetailsReturns {
+                    exception_details: self.exception_details,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for GetExceptionDetailsParams {
+            type Response = GetExceptionDetailsReturns;
+        }
+        #[doc = "Notification is issued every time when binding is called.\n[bindingCalled](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#event-bindingCalled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventBindingCalled {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "payload")]
+            pub payload: String,
+            #[doc = "Identifier of the context where the call was made."]
+            #[serde(rename = "executionContextId")]
+            pub execution_context_id: ExecutionContextId,
+        }
+        impl EventBindingCalled {
+            pub const IDENTIFIER: &'static str = "Runtime.bindingCalled";
+        }
+        impl chromiumoxide_types::Method for EventBindingCalled {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventBindingCalled {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when console API was called.\n[consoleAPICalled](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#event-consoleAPICalled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventConsoleApiCalled {
+            #[doc = "Type of the call."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: ConsoleApiCalledType,
+            #[doc = "Call arguments."]
+            #[serde(rename = "args")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub args: Vec<RemoteObject>,
+            #[doc = "Identifier of the context where the call was made."]
+            #[serde(rename = "executionContextId")]
+            pub execution_context_id: ExecutionContextId,
+            #[doc = "Call timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: Timestamp,
+            #[doc = "Stack trace captured when the call was made. The async stack chain is automatically reported for\nthe following call types: `assert`, `error`, `trace`, `warning`. For other types the async call\nchain can be retrieved using `Debugger.getStackTrace` and `stackTrace.parentId` field."]
+            #[serde(rename = "stackTrace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stack_trace: Option<StackTrace>,
+            #[doc = "Console context descriptor for calls on non-default console context (not console.*):\n'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call\non named context."]
+            #[serde(rename = "context")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub context: Option<String>,
+        }
+        #[doc = "Type of the call."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ConsoleApiCalledType {
+            #[serde(rename = "log")]
+            Log,
+            #[serde(rename = "debug")]
+            Debug,
+            #[serde(rename = "info")]
+            Info,
+            #[serde(rename = "error")]
+            Error,
+            #[serde(rename = "warning")]
+            Warning,
+            #[serde(rename = "dir")]
+            Dir,
+            #[serde(rename = "dirxml")]
+            Dirxml,
+            #[serde(rename = "table")]
+            Table,
+            #[serde(rename = "trace")]
+            Trace,
+            #[serde(rename = "clear")]
+            Clear,
+            #[serde(rename = "startGroup")]
+            StartGroup,
+            #[serde(rename = "startGroupCollapsed")]
+            StartGroupCollapsed,
+            #[serde(rename = "endGroup")]
+            EndGroup,
+            #[serde(rename = "assert")]
+            Assert,
+            #[serde(rename = "profile")]
+            Profile,
+            #[serde(rename = "profileEnd")]
+            ProfileEnd,
+            #[serde(rename = "count")]
+            Count,
+            #[serde(rename = "timeEnd")]
+            TimeEnd,
+        }
+        impl AsRef<str> for ConsoleApiCalledType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ConsoleApiCalledType::Log => "log",
+                    ConsoleApiCalledType::Debug => "debug",
+                    ConsoleApiCalledType::Info => "info",
+                    ConsoleApiCalledType::Error => "error",
+                    ConsoleApiCalledType::Warning => "warning",
+                    ConsoleApiCalledType::Dir => "dir",
+                    ConsoleApiCalledType::Dirxml => "dirxml",
+                    ConsoleApiCalledType::Table => "table",
+                    ConsoleApiCalledType::Trace => "trace",
+                    ConsoleApiCalledType::Clear => "clear",
+                    ConsoleApiCalledType::StartGroup => "startGroup",
+                    ConsoleApiCalledType::StartGroupCollapsed => "startGroupCollapsed",
+                    ConsoleApiCalledType::EndGroup => "endGroup",
+                    ConsoleApiCalledType::Assert => "assert",
+                    ConsoleApiCalledType::Profile => "profile",
+                    ConsoleApiCalledType::ProfileEnd => "profileEnd",
+                    ConsoleApiCalledType::Count => "count",
+                    ConsoleApiCalledType::TimeEnd => "timeEnd",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ConsoleApiCalledType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "log" | "Log" => Ok(ConsoleApiCalledType::Log),
+                    "debug" | "Debug" => Ok(ConsoleApiCalledType::Debug),
+                    "info" | "Info" => Ok(ConsoleApiCalledType::Info),
+                    "error" | "Error" => Ok(ConsoleApiCalledType::Error),
+                    "warning" | "Warning" => Ok(ConsoleApiCalledType::Warning),
+                    "dir" | "Dir" => Ok(ConsoleApiCalledType::Dir),
+                    "dirxml" | "Dirxml" => Ok(ConsoleApiCalledType::Dirxml),
+                    "table" | "Table" => Ok(ConsoleApiCalledType::Table),
+                    "trace" | "Trace" => Ok(ConsoleApiCalledType::Trace),
+                    "clear" | "Clear" => Ok(ConsoleApiCalledType::Clear),
+                    "startGroup" | "StartGroup" | "startgroup" => {
+                        Ok(ConsoleApiCalledType::StartGroup)
+                    }
+                    "startGroupCollapsed" | "StartGroupCollapsed" | "startgroupcollapsed" => {
+                        Ok(ConsoleApiCalledType::StartGroupCollapsed)
+                    }
+                    "endGroup" | "EndGroup" | "endgroup" => Ok(ConsoleApiCalledType::EndGroup),
+                    "assert" | "Assert" => Ok(ConsoleApiCalledType::Assert),
+                    "profile" | "Profile" => Ok(ConsoleApiCalledType::Profile),
+                    "profileEnd" | "ProfileEnd" | "profileend" => {
+                        Ok(ConsoleApiCalledType::ProfileEnd)
+                    }
+                    "count" | "Count" => Ok(ConsoleApiCalledType::Count),
+                    "timeEnd" | "TimeEnd" | "timeend" => Ok(ConsoleApiCalledType::TimeEnd),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EventConsoleApiCalled {
+            pub const IDENTIFIER: &'static str = "Runtime.consoleAPICalled";
+        }
+        impl chromiumoxide_types::Method for EventConsoleApiCalled {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventConsoleApiCalled {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when unhandled exception was revoked.\n[exceptionRevoked](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#event-exceptionRevoked)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventExceptionRevoked {
+            #[doc = "Reason describing why exception was revoked."]
+            #[serde(rename = "reason")]
+            pub reason: String,
+            #[doc = "The id of revoked exception, as reported in `exceptionThrown`."]
+            #[serde(rename = "exceptionId")]
+            pub exception_id: i64,
+        }
+        impl EventExceptionRevoked {
+            pub const IDENTIFIER: &'static str = "Runtime.exceptionRevoked";
+        }
+        impl chromiumoxide_types::Method for EventExceptionRevoked {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventExceptionRevoked {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when exception was thrown and unhandled.\n[exceptionThrown](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#event-exceptionThrown)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventExceptionThrown {
+            #[doc = "Timestamp of the exception."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: Timestamp,
+            #[serde(rename = "exceptionDetails")]
+            pub exception_details: ExceptionDetails,
+        }
+        impl EventExceptionThrown {
+            pub const IDENTIFIER: &'static str = "Runtime.exceptionThrown";
+        }
+        impl chromiumoxide_types::Method for EventExceptionThrown {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventExceptionThrown {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when new execution context is created.\n[executionContextCreated](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#event-executionContextCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventExecutionContextCreated {
+            #[doc = "A newly created execution context."]
+            #[serde(rename = "context")]
+            pub context: ExecutionContextDescription,
+        }
+        impl EventExecutionContextCreated {
+            pub const IDENTIFIER: &'static str = "Runtime.executionContextCreated";
+        }
+        impl chromiumoxide_types::Method for EventExecutionContextCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventExecutionContextCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when execution context is destroyed.\n[executionContextDestroyed](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#event-executionContextDestroyed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventExecutionContextDestroyed {
+            #[doc = "Unique Id of the destroyed context"]
+            #[serde(rename = "executionContextUniqueId")]
+            pub execution_context_unique_id: String,
+        }
+        impl EventExecutionContextDestroyed {
+            pub const IDENTIFIER: &'static str = "Runtime.executionContextDestroyed";
+        }
+        impl chromiumoxide_types::Method for EventExecutionContextDestroyed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventExecutionContextDestroyed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when all executionContexts were cleared in browser\n[executionContextsCleared](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#event-executionContextsCleared)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventExecutionContextsCleared {}
+        impl EventExecutionContextsCleared {
+            pub const IDENTIFIER: &'static str = "Runtime.executionContextsCleared";
+        }
+        impl chromiumoxide_types::Method for EventExecutionContextsCleared {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventExecutionContextsCleared {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when object should be inspected (for example, as a result of inspect() command line API\ncall).\n[inspectRequested](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#event-inspectRequested)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventInspectRequested {
+            #[serde(rename = "object")]
+            pub object: RemoteObject,
+            #[serde(rename = "hints")]
+            pub hints: serde_json::Value,
+            #[doc = "Identifier of the context where the call was made."]
+            #[serde(rename = "executionContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub execution_context_id: Option<ExecutionContextId>,
+        }
+        impl EventInspectRequested {
+            pub const IDENTIFIER: &'static str = "Runtime.inspectRequested";
+        }
+        impl chromiumoxide_types::Method for EventInspectRequested {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventInspectRequested {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+}
+#[allow(clippy::wrong_self_convention)]
+pub mod browser_protocol {
+    #[doc = r" The version of this protocol definition"]
+    pub const VERSION: &str = "1.3";
+    pub mod accessibility {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Unique accessibility node identifier.\n[AXNodeId](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#type-AXNodeId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct AxNodeId(String);
+        impl AxNodeId {
+            pub fn new(val: impl Into<String>) -> Self {
+                AxNodeId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for AxNodeId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<AxNodeId> for String {
+            fn from(el: AxNodeId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for AxNodeId {
+            fn from(expr: String) -> Self {
+                AxNodeId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for AxNodeId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl AxNodeId {
+            pub const IDENTIFIER: &'static str = "Accessibility.AXNodeId";
+        }
+        #[doc = "Enum of possible property types."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AxValueType {
+            #[serde(rename = "boolean")]
+            Boolean,
+            #[serde(rename = "tristate")]
+            Tristate,
+            #[serde(rename = "booleanOrUndefined")]
+            BooleanOrUndefined,
+            #[serde(rename = "idref")]
+            Idref,
+            #[serde(rename = "idrefList")]
+            IdrefList,
+            #[serde(rename = "integer")]
+            Integer,
+            #[serde(rename = "node")]
+            Node,
+            #[serde(rename = "nodeList")]
+            NodeList,
+            #[serde(rename = "number")]
+            Number,
+            #[serde(rename = "string")]
+            String,
+            #[serde(rename = "computedString")]
+            ComputedString,
+            #[serde(rename = "token")]
+            Token,
+            #[serde(rename = "tokenList")]
+            TokenList,
+            #[serde(rename = "domRelation")]
+            DomRelation,
+            #[serde(rename = "role")]
+            Role,
+            #[serde(rename = "internalRole")]
+            InternalRole,
+            #[serde(rename = "valueUndefined")]
+            ValueUndefined,
+        }
+        impl AsRef<str> for AxValueType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AxValueType::Boolean => "boolean",
+                    AxValueType::Tristate => "tristate",
+                    AxValueType::BooleanOrUndefined => "booleanOrUndefined",
+                    AxValueType::Idref => "idref",
+                    AxValueType::IdrefList => "idrefList",
+                    AxValueType::Integer => "integer",
+                    AxValueType::Node => "node",
+                    AxValueType::NodeList => "nodeList",
+                    AxValueType::Number => "number",
+                    AxValueType::String => "string",
+                    AxValueType::ComputedString => "computedString",
+                    AxValueType::Token => "token",
+                    AxValueType::TokenList => "tokenList",
+                    AxValueType::DomRelation => "domRelation",
+                    AxValueType::Role => "role",
+                    AxValueType::InternalRole => "internalRole",
+                    AxValueType::ValueUndefined => "valueUndefined",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AxValueType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "boolean" | "Boolean" => Ok(AxValueType::Boolean),
+                    "tristate" | "Tristate" => Ok(AxValueType::Tristate),
+                    "booleanOrUndefined" | "BooleanOrUndefined" | "booleanorundefined" => {
+                        Ok(AxValueType::BooleanOrUndefined)
+                    }
+                    "idref" | "Idref" => Ok(AxValueType::Idref),
+                    "idrefList" | "IdrefList" | "idreflist" => Ok(AxValueType::IdrefList),
+                    "integer" | "Integer" => Ok(AxValueType::Integer),
+                    "node" | "Node" => Ok(AxValueType::Node),
+                    "nodeList" | "NodeList" | "nodelist" => Ok(AxValueType::NodeList),
+                    "number" | "Number" => Ok(AxValueType::Number),
+                    "string" | "String" => Ok(AxValueType::String),
+                    "computedString" | "ComputedString" | "computedstring" => {
+                        Ok(AxValueType::ComputedString)
+                    }
+                    "token" | "Token" => Ok(AxValueType::Token),
+                    "tokenList" | "TokenList" | "tokenlist" => Ok(AxValueType::TokenList),
+                    "domRelation" | "DomRelation" | "domrelation" => Ok(AxValueType::DomRelation),
+                    "role" | "Role" => Ok(AxValueType::Role),
+                    "internalRole" | "InternalRole" | "internalrole" => {
+                        Ok(AxValueType::InternalRole)
+                    }
+                    "valueUndefined" | "ValueUndefined" | "valueundefined" => {
+                        Ok(AxValueType::ValueUndefined)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Enum of possible property sources."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AxValueSourceType {
+            #[serde(rename = "attribute")]
+            Attribute,
+            #[serde(rename = "implicit")]
+            Implicit,
+            #[serde(rename = "style")]
+            Style,
+            #[serde(rename = "contents")]
+            Contents,
+            #[serde(rename = "placeholder")]
+            Placeholder,
+            #[serde(rename = "relatedElement")]
+            RelatedElement,
+        }
+        impl AsRef<str> for AxValueSourceType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AxValueSourceType::Attribute => "attribute",
+                    AxValueSourceType::Implicit => "implicit",
+                    AxValueSourceType::Style => "style",
+                    AxValueSourceType::Contents => "contents",
+                    AxValueSourceType::Placeholder => "placeholder",
+                    AxValueSourceType::RelatedElement => "relatedElement",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AxValueSourceType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "attribute" | "Attribute" => Ok(AxValueSourceType::Attribute),
+                    "implicit" | "Implicit" => Ok(AxValueSourceType::Implicit),
+                    "style" | "Style" => Ok(AxValueSourceType::Style),
+                    "contents" | "Contents" => Ok(AxValueSourceType::Contents),
+                    "placeholder" | "Placeholder" => Ok(AxValueSourceType::Placeholder),
+                    "relatedElement" | "RelatedElement" | "relatedelement" => {
+                        Ok(AxValueSourceType::RelatedElement)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Enum of possible native property sources (as a subtype of a particular AXValueSourceType)."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AxValueNativeSourceType {
+            #[serde(rename = "description")]
+            Description,
+            #[serde(rename = "figcaption")]
+            Figcaption,
+            #[serde(rename = "label")]
+            Label,
+            #[serde(rename = "labelfor")]
+            Labelfor,
+            #[serde(rename = "labelwrapped")]
+            Labelwrapped,
+            #[serde(rename = "legend")]
+            Legend,
+            #[serde(rename = "rubyannotation")]
+            Rubyannotation,
+            #[serde(rename = "tablecaption")]
+            Tablecaption,
+            #[serde(rename = "title")]
+            Title,
+            #[serde(rename = "other")]
+            Other,
+        }
+        impl AsRef<str> for AxValueNativeSourceType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AxValueNativeSourceType::Description => "description",
+                    AxValueNativeSourceType::Figcaption => "figcaption",
+                    AxValueNativeSourceType::Label => "label",
+                    AxValueNativeSourceType::Labelfor => "labelfor",
+                    AxValueNativeSourceType::Labelwrapped => "labelwrapped",
+                    AxValueNativeSourceType::Legend => "legend",
+                    AxValueNativeSourceType::Rubyannotation => "rubyannotation",
+                    AxValueNativeSourceType::Tablecaption => "tablecaption",
+                    AxValueNativeSourceType::Title => "title",
+                    AxValueNativeSourceType::Other => "other",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AxValueNativeSourceType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "description" | "Description" => Ok(AxValueNativeSourceType::Description),
+                    "figcaption" | "Figcaption" => Ok(AxValueNativeSourceType::Figcaption),
+                    "label" | "Label" => Ok(AxValueNativeSourceType::Label),
+                    "labelfor" | "Labelfor" => Ok(AxValueNativeSourceType::Labelfor),
+                    "labelwrapped" | "Labelwrapped" => Ok(AxValueNativeSourceType::Labelwrapped),
+                    "legend" | "Legend" => Ok(AxValueNativeSourceType::Legend),
+                    "rubyannotation" | "Rubyannotation" => {
+                        Ok(AxValueNativeSourceType::Rubyannotation)
+                    }
+                    "tablecaption" | "Tablecaption" => Ok(AxValueNativeSourceType::Tablecaption),
+                    "title" | "Title" => Ok(AxValueNativeSourceType::Title),
+                    "other" | "Other" => Ok(AxValueNativeSourceType::Other),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "A single source for a computed AX property.\n[AXValueSource](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#type-AXValueSource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AxValueSource {
+            #[doc = "What type of source this is."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: AxValueSourceType,
+            #[doc = "The value of this property source."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<AxValue>,
+            #[doc = "The name of the relevant attribute, if any."]
+            #[serde(rename = "attribute")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub attribute: Option<String>,
+            #[doc = "The value of the relevant attribute, if any."]
+            #[serde(rename = "attributeValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub attribute_value: Option<AxValue>,
+            #[doc = "Whether this source is superseded by a higher priority source."]
+            #[serde(rename = "superseded")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub superseded: Option<bool>,
+            #[doc = "The native markup source for this value, e.g. a `<label>` element."]
+            #[serde(rename = "nativeSource")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub native_source: Option<AxValueNativeSourceType>,
+            #[doc = "The value, such as a node or node list, of the native source."]
+            #[serde(rename = "nativeSourceValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub native_source_value: Option<AxValue>,
+            #[doc = "Whether the value for this property is invalid."]
+            #[serde(rename = "invalid")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub invalid: Option<bool>,
+            #[doc = "Reason for the value being invalid, if it is."]
+            #[serde(rename = "invalidReason")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub invalid_reason: Option<String>,
+        }
+        impl AxValueSource {
+            pub fn new(r#type: impl Into<AxValueSourceType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    value: None,
+                    attribute: None,
+                    attribute_value: None,
+                    superseded: None,
+                    native_source: None,
+                    native_source_value: None,
+                    invalid: None,
+                    invalid_reason: None,
+                }
+            }
+        }
+        impl AxValueSource {
+            pub fn builder() -> AxValueSourceBuilder {
+                AxValueSourceBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AxValueSourceBuilder {
+            r#type: Option<AxValueSourceType>,
+            value: Option<AxValue>,
+            attribute: Option<String>,
+            attribute_value: Option<AxValue>,
+            superseded: Option<bool>,
+            native_source: Option<AxValueNativeSourceType>,
+            native_source_value: Option<AxValue>,
+            invalid: Option<bool>,
+            invalid_reason: Option<String>,
+        }
+        impl AxValueSourceBuilder {
+            pub fn r#type(mut self, r#type: impl Into<AxValueSourceType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<AxValue>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn attribute(mut self, attribute: impl Into<String>) -> Self {
+                self.attribute = Some(attribute.into());
+                self
+            }
+            pub fn attribute_value(mut self, attribute_value: impl Into<AxValue>) -> Self {
+                self.attribute_value = Some(attribute_value.into());
+                self
+            }
+            pub fn superseded(mut self, superseded: impl Into<bool>) -> Self {
+                self.superseded = Some(superseded.into());
+                self
+            }
+            pub fn native_source(
+                mut self,
+                native_source: impl Into<AxValueNativeSourceType>,
+            ) -> Self {
+                self.native_source = Some(native_source.into());
+                self
+            }
+            pub fn native_source_value(mut self, native_source_value: impl Into<AxValue>) -> Self {
+                self.native_source_value = Some(native_source_value.into());
+                self
+            }
+            pub fn invalid(mut self, invalid: impl Into<bool>) -> Self {
+                self.invalid = Some(invalid.into());
+                self
+            }
+            pub fn invalid_reason(mut self, invalid_reason: impl Into<String>) -> Self {
+                self.invalid_reason = Some(invalid_reason.into());
+                self
+            }
+            pub fn build(self) -> Result<AxValueSource, String> {
+                Ok(AxValueSource {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    value: self.value,
+                    attribute: self.attribute,
+                    attribute_value: self.attribute_value,
+                    superseded: self.superseded,
+                    native_source: self.native_source,
+                    native_source_value: self.native_source_value,
+                    invalid: self.invalid,
+                    invalid_reason: self.invalid_reason,
+                })
+            }
+        }
+        impl AxValueSource {
+            pub const IDENTIFIER: &'static str = "Accessibility.AXValueSource";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AxRelatedNode {
+            #[doc = "The BackendNodeId of the related DOM node."]
+            #[serde(rename = "backendDOMNodeId")]
+            pub backend_dom_node_id: super::dom::BackendNodeId,
+            #[doc = "The IDRef value provided, if any."]
+            #[serde(rename = "idref")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub idref: Option<String>,
+            #[doc = "The text alternative of this node in the current context."]
+            #[serde(rename = "text")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub text: Option<String>,
+        }
+        impl AxRelatedNode {
+            pub fn new(backend_dom_node_id: impl Into<super::dom::BackendNodeId>) -> Self {
+                Self {
+                    backend_dom_node_id: backend_dom_node_id.into(),
+                    idref: None,
+                    text: None,
+                }
+            }
+        }
+        impl AxRelatedNode {
+            pub fn builder() -> AxRelatedNodeBuilder {
+                AxRelatedNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AxRelatedNodeBuilder {
+            backend_dom_node_id: Option<super::dom::BackendNodeId>,
+            idref: Option<String>,
+            text: Option<String>,
+        }
+        impl AxRelatedNodeBuilder {
+            pub fn backend_dom_node_id(
+                mut self,
+                backend_dom_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_dom_node_id = Some(backend_dom_node_id.into());
+                self
+            }
+            pub fn idref(mut self, idref: impl Into<String>) -> Self {
+                self.idref = Some(idref.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn build(self) -> Result<AxRelatedNode, String> {
+                Ok(AxRelatedNode {
+                    backend_dom_node_id: self.backend_dom_node_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(backend_dom_node_id)
+                        )
+                    })?,
+                    idref: self.idref,
+                    text: self.text,
+                })
+            }
+        }
+        impl AxRelatedNode {
+            pub const IDENTIFIER: &'static str = "Accessibility.AXRelatedNode";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AxProperty {
+            #[doc = "The name of this property."]
+            #[serde(rename = "name")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub name: AxPropertyName,
+            #[doc = "The value of this property."]
+            #[serde(rename = "value")]
+            pub value: AxValue,
+        }
+        impl AxProperty {
+            pub fn new(name: impl Into<AxPropertyName>, value: impl Into<AxValue>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl AxProperty {
+            pub fn builder() -> AxPropertyBuilder {
+                AxPropertyBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AxPropertyBuilder {
+            name: Option<AxPropertyName>,
+            value: Option<AxValue>,
+        }
+        impl AxPropertyBuilder {
+            pub fn name(mut self, name: impl Into<AxPropertyName>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<AxValue>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<AxProperty, String> {
+                Ok(AxProperty {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl AxProperty {
+            pub const IDENTIFIER: &'static str = "Accessibility.AXProperty";
+        }
+        #[doc = "A single computed AX property.\n[AXValue](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#type-AXValue)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AxValue {
+            #[doc = "The type of this value."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: AxValueType,
+            #[doc = "The computed value of this property."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<serde_json::Value>,
+            #[doc = "One or more related nodes, if applicable."]
+            #[serde(rename = "relatedNodes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub related_nodes: Option<Vec<AxRelatedNode>>,
+            #[doc = "The sources which contributed to the computation of this property."]
+            #[serde(rename = "sources")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub sources: Option<Vec<AxValueSource>>,
+        }
+        impl AxValue {
+            pub fn new(r#type: impl Into<AxValueType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    value: None,
+                    related_nodes: None,
+                    sources: None,
+                }
+            }
+        }
+        impl AxValue {
+            pub fn builder() -> AxValueBuilder {
+                AxValueBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AxValueBuilder {
+            r#type: Option<AxValueType>,
+            value: Option<serde_json::Value>,
+            related_nodes: Option<Vec<AxRelatedNode>>,
+            sources: Option<Vec<AxValueSource>>,
+        }
+        impl AxValueBuilder {
+            pub fn r#type(mut self, r#type: impl Into<AxValueType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<serde_json::Value>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn related_node(mut self, related_node: impl Into<AxRelatedNode>) -> Self {
+                let v = self.related_nodes.get_or_insert(Vec::new());
+                v.push(related_node.into());
+                self
+            }
+            pub fn related_nodes<I, S>(mut self, related_nodes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AxRelatedNode>,
+            {
+                let v = self.related_nodes.get_or_insert(Vec::new());
+                for val in related_nodes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn source(mut self, source: impl Into<AxValueSource>) -> Self {
+                let v = self.sources.get_or_insert(Vec::new());
+                v.push(source.into());
+                self
+            }
+            pub fn sources<I, S>(mut self, sources: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AxValueSource>,
+            {
+                let v = self.sources.get_or_insert(Vec::new());
+                for val in sources {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<AxValue, String> {
+                Ok(AxValue {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    value: self.value,
+                    related_nodes: self.related_nodes,
+                    sources: self.sources,
+                })
+            }
+        }
+        impl AxValue {
+            pub const IDENTIFIER: &'static str = "Accessibility.AXValue";
+        }
+        #[doc = "Values of AXProperty name:\n- from 'busy' to 'roledescription': states which apply to every AX node\n- from 'live' to 'root': attributes which apply to nodes in live regions\n- from 'autocomplete' to 'valuetext': attributes which apply to widgets\n- from 'checked' to 'selected': states which apply to widgets\n- from 'activedescendant' to 'owns': relationships between elements other than parent/child/sibling\n- from 'activeFullscreenElement' to 'uninteresting': reasons why this noode is hidden"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AxPropertyName {
+            #[serde(rename = "actions")]
+            Actions,
+            #[serde(rename = "busy")]
+            Busy,
+            #[serde(rename = "disabled")]
+            Disabled,
+            #[serde(rename = "editable")]
+            Editable,
+            #[serde(rename = "focusable")]
+            Focusable,
+            #[serde(rename = "focused")]
+            Focused,
+            #[serde(rename = "hidden")]
+            Hidden,
+            #[serde(rename = "hiddenRoot")]
+            HiddenRoot,
+            #[serde(rename = "invalid")]
+            Invalid,
+            #[serde(rename = "keyshortcuts")]
+            Keyshortcuts,
+            #[serde(rename = "settable")]
+            Settable,
+            #[serde(rename = "roledescription")]
+            Roledescription,
+            #[serde(rename = "live")]
+            Live,
+            #[serde(rename = "atomic")]
+            Atomic,
+            #[serde(rename = "relevant")]
+            Relevant,
+            #[serde(rename = "root")]
+            Root,
+            #[serde(rename = "autocomplete")]
+            Autocomplete,
+            #[serde(rename = "hasPopup")]
+            HasPopup,
+            #[serde(rename = "level")]
+            Level,
+            #[serde(rename = "multiselectable")]
+            Multiselectable,
+            #[serde(rename = "orientation")]
+            Orientation,
+            #[serde(rename = "multiline")]
+            Multiline,
+            #[serde(rename = "readonly")]
+            Readonly,
+            #[serde(rename = "required")]
+            Required,
+            #[serde(rename = "valuemin")]
+            Valuemin,
+            #[serde(rename = "valuemax")]
+            Valuemax,
+            #[serde(rename = "valuetext")]
+            Valuetext,
+            #[serde(rename = "checked")]
+            Checked,
+            #[serde(rename = "expanded")]
+            Expanded,
+            #[serde(rename = "modal")]
+            Modal,
+            #[serde(rename = "pressed")]
+            Pressed,
+            #[serde(rename = "selected")]
+            Selected,
+            #[serde(rename = "activedescendant")]
+            Activedescendant,
+            #[serde(rename = "controls")]
+            Controls,
+            #[serde(rename = "describedby")]
+            Describedby,
+            #[serde(rename = "details")]
+            Details,
+            #[serde(rename = "errormessage")]
+            Errormessage,
+            #[serde(rename = "flowto")]
+            Flowto,
+            #[serde(rename = "labelledby")]
+            Labelledby,
+            #[serde(rename = "owns")]
+            Owns,
+            #[serde(rename = "url")]
+            Url,
+            #[doc = "LINT.IfChange(AXIgnoredReason)"]
+            #[serde(rename = "activeFullscreenElement")]
+            ActiveFullscreenElement,
+            #[serde(rename = "activeModalDialog")]
+            ActiveModalDialog,
+            #[serde(rename = "activeAriaModalDialog")]
+            ActiveAriaModalDialog,
+            #[serde(rename = "ariaHiddenElement")]
+            AriaHiddenElement,
+            #[serde(rename = "ariaHiddenSubtree")]
+            AriaHiddenSubtree,
+            #[serde(rename = "emptyAlt")]
+            EmptyAlt,
+            #[serde(rename = "emptyText")]
+            EmptyText,
+            #[serde(rename = "inertElement")]
+            InertElement,
+            #[serde(rename = "inertSubtree")]
+            InertSubtree,
+            #[serde(rename = "labelContainer")]
+            LabelContainer,
+            #[serde(rename = "labelFor")]
+            LabelFor,
+            #[serde(rename = "notRendered")]
+            NotRendered,
+            #[serde(rename = "notVisible")]
+            NotVisible,
+            #[serde(rename = "presentationalRole")]
+            PresentationalRole,
+            #[serde(rename = "probablyPresentational")]
+            ProbablyPresentational,
+            #[serde(rename = "inactiveCarouselTabContent")]
+            InactiveCarouselTabContent,
+            #[serde(rename = "uninteresting")]
+            Uninteresting,
+        }
+        impl AsRef<str> for AxPropertyName {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AxPropertyName::Actions => "actions",
+                    AxPropertyName::Busy => "busy",
+                    AxPropertyName::Disabled => "disabled",
+                    AxPropertyName::Editable => "editable",
+                    AxPropertyName::Focusable => "focusable",
+                    AxPropertyName::Focused => "focused",
+                    AxPropertyName::Hidden => "hidden",
+                    AxPropertyName::HiddenRoot => "hiddenRoot",
+                    AxPropertyName::Invalid => "invalid",
+                    AxPropertyName::Keyshortcuts => "keyshortcuts",
+                    AxPropertyName::Settable => "settable",
+                    AxPropertyName::Roledescription => "roledescription",
+                    AxPropertyName::Live => "live",
+                    AxPropertyName::Atomic => "atomic",
+                    AxPropertyName::Relevant => "relevant",
+                    AxPropertyName::Root => "root",
+                    AxPropertyName::Autocomplete => "autocomplete",
+                    AxPropertyName::HasPopup => "hasPopup",
+                    AxPropertyName::Level => "level",
+                    AxPropertyName::Multiselectable => "multiselectable",
+                    AxPropertyName::Orientation => "orientation",
+                    AxPropertyName::Multiline => "multiline",
+                    AxPropertyName::Readonly => "readonly",
+                    AxPropertyName::Required => "required",
+                    AxPropertyName::Valuemin => "valuemin",
+                    AxPropertyName::Valuemax => "valuemax",
+                    AxPropertyName::Valuetext => "valuetext",
+                    AxPropertyName::Checked => "checked",
+                    AxPropertyName::Expanded => "expanded",
+                    AxPropertyName::Modal => "modal",
+                    AxPropertyName::Pressed => "pressed",
+                    AxPropertyName::Selected => "selected",
+                    AxPropertyName::Activedescendant => "activedescendant",
+                    AxPropertyName::Controls => "controls",
+                    AxPropertyName::Describedby => "describedby",
+                    AxPropertyName::Details => "details",
+                    AxPropertyName::Errormessage => "errormessage",
+                    AxPropertyName::Flowto => "flowto",
+                    AxPropertyName::Labelledby => "labelledby",
+                    AxPropertyName::Owns => "owns",
+                    AxPropertyName::Url => "url",
+                    AxPropertyName::ActiveFullscreenElement => "activeFullscreenElement",
+                    AxPropertyName::ActiveModalDialog => "activeModalDialog",
+                    AxPropertyName::ActiveAriaModalDialog => "activeAriaModalDialog",
+                    AxPropertyName::AriaHiddenElement => "ariaHiddenElement",
+                    AxPropertyName::AriaHiddenSubtree => "ariaHiddenSubtree",
+                    AxPropertyName::EmptyAlt => "emptyAlt",
+                    AxPropertyName::EmptyText => "emptyText",
+                    AxPropertyName::InertElement => "inertElement",
+                    AxPropertyName::InertSubtree => "inertSubtree",
+                    AxPropertyName::LabelContainer => "labelContainer",
+                    AxPropertyName::LabelFor => "labelFor",
+                    AxPropertyName::NotRendered => "notRendered",
+                    AxPropertyName::NotVisible => "notVisible",
+                    AxPropertyName::PresentationalRole => "presentationalRole",
+                    AxPropertyName::ProbablyPresentational => "probablyPresentational",
+                    AxPropertyName::InactiveCarouselTabContent => "inactiveCarouselTabContent",
+                    AxPropertyName::Uninteresting => "uninteresting",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AxPropertyName {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "actions" | "Actions" => Ok(AxPropertyName::Actions),
+                    "busy" | "Busy" => Ok(AxPropertyName::Busy),
+                    "disabled" | "Disabled" => Ok(AxPropertyName::Disabled),
+                    "editable" | "Editable" => Ok(AxPropertyName::Editable),
+                    "focusable" | "Focusable" => Ok(AxPropertyName::Focusable),
+                    "focused" | "Focused" => Ok(AxPropertyName::Focused),
+                    "hidden" | "Hidden" => Ok(AxPropertyName::Hidden),
+                    "hiddenRoot" | "HiddenRoot" | "hiddenroot" => Ok(AxPropertyName::HiddenRoot),
+                    "invalid" | "Invalid" => Ok(AxPropertyName::Invalid),
+                    "keyshortcuts" | "Keyshortcuts" => Ok(AxPropertyName::Keyshortcuts),
+                    "settable" | "Settable" => Ok(AxPropertyName::Settable),
+                    "roledescription" | "Roledescription" => Ok(AxPropertyName::Roledescription),
+                    "live" | "Live" => Ok(AxPropertyName::Live),
+                    "atomic" | "Atomic" => Ok(AxPropertyName::Atomic),
+                    "relevant" | "Relevant" => Ok(AxPropertyName::Relevant),
+                    "root" | "Root" => Ok(AxPropertyName::Root),
+                    "autocomplete" | "Autocomplete" => Ok(AxPropertyName::Autocomplete),
+                    "hasPopup" | "HasPopup" | "haspopup" => Ok(AxPropertyName::HasPopup),
+                    "level" | "Level" => Ok(AxPropertyName::Level),
+                    "multiselectable" | "Multiselectable" => Ok(AxPropertyName::Multiselectable),
+                    "orientation" | "Orientation" => Ok(AxPropertyName::Orientation),
+                    "multiline" | "Multiline" => Ok(AxPropertyName::Multiline),
+                    "readonly" | "Readonly" => Ok(AxPropertyName::Readonly),
+                    "required" | "Required" => Ok(AxPropertyName::Required),
+                    "valuemin" | "Valuemin" => Ok(AxPropertyName::Valuemin),
+                    "valuemax" | "Valuemax" => Ok(AxPropertyName::Valuemax),
+                    "valuetext" | "Valuetext" => Ok(AxPropertyName::Valuetext),
+                    "checked" | "Checked" => Ok(AxPropertyName::Checked),
+                    "expanded" | "Expanded" => Ok(AxPropertyName::Expanded),
+                    "modal" | "Modal" => Ok(AxPropertyName::Modal),
+                    "pressed" | "Pressed" => Ok(AxPropertyName::Pressed),
+                    "selected" | "Selected" => Ok(AxPropertyName::Selected),
+                    "activedescendant" | "Activedescendant" => Ok(AxPropertyName::Activedescendant),
+                    "controls" | "Controls" => Ok(AxPropertyName::Controls),
+                    "describedby" | "Describedby" => Ok(AxPropertyName::Describedby),
+                    "details" | "Details" => Ok(AxPropertyName::Details),
+                    "errormessage" | "Errormessage" => Ok(AxPropertyName::Errormessage),
+                    "flowto" | "Flowto" => Ok(AxPropertyName::Flowto),
+                    "labelledby" | "Labelledby" => Ok(AxPropertyName::Labelledby),
+                    "owns" | "Owns" => Ok(AxPropertyName::Owns),
+                    "url" | "Url" => Ok(AxPropertyName::Url),
+                    "activeFullscreenElement"
+                    | "ActiveFullscreenElement"
+                    | "activefullscreenelement" => Ok(AxPropertyName::ActiveFullscreenElement),
+                    "activeModalDialog" | "ActiveModalDialog" | "activemodaldialog" => {
+                        Ok(AxPropertyName::ActiveModalDialog)
+                    }
+                    "activeAriaModalDialog" | "ActiveAriaModalDialog" | "activeariamodaldialog" => {
+                        Ok(AxPropertyName::ActiveAriaModalDialog)
+                    }
+                    "ariaHiddenElement" | "AriaHiddenElement" | "ariahiddenelement" => {
+                        Ok(AxPropertyName::AriaHiddenElement)
+                    }
+                    "ariaHiddenSubtree" | "AriaHiddenSubtree" | "ariahiddensubtree" => {
+                        Ok(AxPropertyName::AriaHiddenSubtree)
+                    }
+                    "emptyAlt" | "EmptyAlt" | "emptyalt" => Ok(AxPropertyName::EmptyAlt),
+                    "emptyText" | "EmptyText" | "emptytext" => Ok(AxPropertyName::EmptyText),
+                    "inertElement" | "InertElement" | "inertelement" => {
+                        Ok(AxPropertyName::InertElement)
+                    }
+                    "inertSubtree" | "InertSubtree" | "inertsubtree" => {
+                        Ok(AxPropertyName::InertSubtree)
+                    }
+                    "labelContainer" | "LabelContainer" | "labelcontainer" => {
+                        Ok(AxPropertyName::LabelContainer)
+                    }
+                    "labelFor" | "LabelFor" | "labelfor" => Ok(AxPropertyName::LabelFor),
+                    "notRendered" | "NotRendered" | "notrendered" => {
+                        Ok(AxPropertyName::NotRendered)
+                    }
+                    "notVisible" | "NotVisible" | "notvisible" => Ok(AxPropertyName::NotVisible),
+                    "presentationalRole" | "PresentationalRole" | "presentationalrole" => {
+                        Ok(AxPropertyName::PresentationalRole)
+                    }
+                    "probablyPresentational"
+                    | "ProbablyPresentational"
+                    | "probablypresentational" => Ok(AxPropertyName::ProbablyPresentational),
+                    "inactiveCarouselTabContent"
+                    | "InactiveCarouselTabContent"
+                    | "inactivecarouseltabcontent" => {
+                        Ok(AxPropertyName::InactiveCarouselTabContent)
+                    }
+                    "uninteresting" | "Uninteresting" => Ok(AxPropertyName::Uninteresting),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "LINT.ThenChange(//third_party/blink/renderer/modules/accessibility/ax_enums.cc:AXIgnoredReason)\nA node in the accessibility tree.\n[AXNode](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#type-AXNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AxNode {
+            #[doc = "Unique identifier for this node."]
+            #[serde(rename = "nodeId")]
+            pub node_id: AxNodeId,
+            #[doc = "Whether this node is ignored for accessibility"]
+            #[serde(rename = "ignored")]
+            pub ignored: bool,
+            #[doc = "Collection of reasons why this node is hidden."]
+            #[serde(rename = "ignoredReasons")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub ignored_reasons: Option<Vec<AxProperty>>,
+            #[doc = "This `Node`'s role, whether explicit or implicit."]
+            #[serde(rename = "role")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub role: Option<AxValue>,
+            #[doc = "This `Node`'s Chrome raw role."]
+            #[serde(rename = "chromeRole")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub chrome_role: Option<AxValue>,
+            #[doc = "The accessible name for this `Node`."]
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<AxValue>,
+            #[doc = "The accessible description for this `Node`."]
+            #[serde(rename = "description")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub description: Option<AxValue>,
+            #[doc = "The value for this `Node`."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<AxValue>,
+            #[doc = "All other properties"]
+            #[serde(rename = "properties")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub properties: Option<Vec<AxProperty>>,
+            #[doc = "ID for this node's parent."]
+            #[serde(rename = "parentId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent_id: Option<AxNodeId>,
+            #[doc = "IDs for each of this node's child nodes."]
+            #[serde(rename = "childIds")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub child_ids: Option<Vec<AxNodeId>>,
+            #[doc = "The backend ID for the associated DOM node, if any."]
+            #[serde(rename = "backendDOMNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_dom_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "The frame ID for the frame associated with this nodes document."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+        }
+        impl AxNode {
+            pub fn new(node_id: impl Into<AxNodeId>, ignored: impl Into<bool>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    ignored: ignored.into(),
+                    ignored_reasons: None,
+                    role: None,
+                    chrome_role: None,
+                    name: None,
+                    description: None,
+                    value: None,
+                    properties: None,
+                    parent_id: None,
+                    child_ids: None,
+                    backend_dom_node_id: None,
+                    frame_id: None,
+                }
+            }
+        }
+        impl AxNode {
+            pub fn builder() -> AxNodeBuilder {
+                AxNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AxNodeBuilder {
+            node_id: Option<AxNodeId>,
+            ignored: Option<bool>,
+            ignored_reasons: Option<Vec<AxProperty>>,
+            role: Option<AxValue>,
+            chrome_role: Option<AxValue>,
+            name: Option<AxValue>,
+            description: Option<AxValue>,
+            value: Option<AxValue>,
+            properties: Option<Vec<AxProperty>>,
+            parent_id: Option<AxNodeId>,
+            child_ids: Option<Vec<AxNodeId>>,
+            backend_dom_node_id: Option<super::dom::BackendNodeId>,
+            frame_id: Option<super::page::FrameId>,
+        }
+        impl AxNodeBuilder {
+            pub fn node_id(mut self, node_id: impl Into<AxNodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn ignored(mut self, ignored: impl Into<bool>) -> Self {
+                self.ignored = Some(ignored.into());
+                self
+            }
+            pub fn ignored_reason(mut self, ignored_reason: impl Into<AxProperty>) -> Self {
+                let v = self.ignored_reasons.get_or_insert(Vec::new());
+                v.push(ignored_reason.into());
+                self
+            }
+            pub fn ignored_reasons<I, S>(mut self, ignored_reasons: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AxProperty>,
+            {
+                let v = self.ignored_reasons.get_or_insert(Vec::new());
+                for val in ignored_reasons {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn role(mut self, role: impl Into<AxValue>) -> Self {
+                self.role = Some(role.into());
+                self
+            }
+            pub fn chrome_role(mut self, chrome_role: impl Into<AxValue>) -> Self {
+                self.chrome_role = Some(chrome_role.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<AxValue>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn description(mut self, description: impl Into<AxValue>) -> Self {
+                self.description = Some(description.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<AxValue>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn propertie(mut self, propertie: impl Into<AxProperty>) -> Self {
+                let v = self.properties.get_or_insert(Vec::new());
+                v.push(propertie.into());
+                self
+            }
+            pub fn properties<I, S>(mut self, properties: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AxProperty>,
+            {
+                let v = self.properties.get_or_insert(Vec::new());
+                for val in properties {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn parent_id(mut self, parent_id: impl Into<AxNodeId>) -> Self {
+                self.parent_id = Some(parent_id.into());
+                self
+            }
+            pub fn child_id(mut self, child_id: impl Into<AxNodeId>) -> Self {
+                let v = self.child_ids.get_or_insert(Vec::new());
+                v.push(child_id.into());
+                self
+            }
+            pub fn child_ids<I, S>(mut self, child_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AxNodeId>,
+            {
+                let v = self.child_ids.get_or_insert(Vec::new());
+                for val in child_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn backend_dom_node_id(
+                mut self,
+                backend_dom_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_dom_node_id = Some(backend_dom_node_id.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AxNode, String> {
+                Ok(AxNode {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    ignored: self.ignored.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ignored))
+                    })?,
+                    ignored_reasons: self.ignored_reasons,
+                    role: self.role,
+                    chrome_role: self.chrome_role,
+                    name: self.name,
+                    description: self.description,
+                    value: self.value,
+                    properties: self.properties,
+                    parent_id: self.parent_id,
+                    child_ids: self.child_ids,
+                    backend_dom_node_id: self.backend_dom_node_id,
+                    frame_id: self.frame_id,
+                })
+            }
+        }
+        impl AxNode {
+            pub const IDENTIFIER: &'static str = "Accessibility.AXNode";
+        }
+        #[doc = "Disables the accessibility domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Accessibility.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables the accessibility domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables the accessibility domain which causes `AXNodeId`s to remain consistent between method calls.\nThis turns on accessibility for the page, which can impact performance until accessibility is disabled.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Accessibility.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables the accessibility domain which causes `AXNodeId`s to remain consistent between method calls.\nThis turns on accessibility for the page, which can impact performance until accessibility is disabled.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.\n[getPartialAXTree](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-getPartialAXTree)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetPartialAxTreeParams {
+            #[doc = "Identifier of the node to get the partial accessibility tree for."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<super::dom::NodeId>,
+            #[doc = "Identifier of the backend node to get the partial accessibility tree for."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "JavaScript object id of the node wrapper to get the partial accessibility tree for."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            #[doc = "Whether to fetch this node's ancestors, siblings and children. Defaults to true."]
+            #[serde(rename = "fetchRelatives")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub fetch_relatives: Option<bool>,
+        }
+        impl GetPartialAxTreeParams {
+            pub fn builder() -> GetPartialAxTreeParamsBuilder {
+                GetPartialAxTreeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPartialAxTreeParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            fetch_relatives: Option<bool>,
+        }
+        impl GetPartialAxTreeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn fetch_relatives(mut self, fetch_relatives: impl Into<bool>) -> Self {
+                self.fetch_relatives = Some(fetch_relatives.into());
+                self
+            }
+            pub fn build(self) -> GetPartialAxTreeParams {
+                GetPartialAxTreeParams {
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                    fetch_relatives: self.fetch_relatives,
+                }
+            }
+        }
+        impl GetPartialAxTreeParams {
+            pub const IDENTIFIER: &'static str = "Accessibility.getPartialAXTree";
+        }
+        impl chromiumoxide_types::Method for GetPartialAxTreeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetPartialAxTreeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.\n[getPartialAXTree](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-getPartialAXTree)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetPartialAxTreeReturns {
+            #[doc = "The `Accessibility.AXNode` for this DOM node, if it exists, plus its ancestors, siblings and\nchildren, if requested."]
+            #[serde(rename = "nodes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub nodes: Vec<AxNode>,
+        }
+        impl GetPartialAxTreeReturns {
+            pub fn new(nodes: Vec<AxNode>) -> Self {
+                Self { nodes }
+            }
+        }
+        impl GetPartialAxTreeReturns {
+            pub fn builder() -> GetPartialAxTreeReturnsBuilder {
+                GetPartialAxTreeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPartialAxTreeReturnsBuilder {
+            nodes: Option<Vec<AxNode>>,
+        }
+        impl GetPartialAxTreeReturnsBuilder {
+            pub fn node(mut self, node: impl Into<AxNode>) -> Self {
+                let v = self.nodes.get_or_insert(Vec::new());
+                v.push(node.into());
+                self
+            }
+            pub fn nodes<I, S>(mut self, nodes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AxNode>,
+            {
+                let v = self.nodes.get_or_insert(Vec::new());
+                for val in nodes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetPartialAxTreeReturns, String> {
+                Ok(GetPartialAxTreeReturns {
+                    nodes: self.nodes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(nodes))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetPartialAxTreeParams {
+            type Response = GetPartialAxTreeReturns;
+        }
+        #[doc = "Fetches the entire accessibility tree for the root Document\n[getFullAXTree](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-getFullAXTree)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetFullAxTreeParams {
+            #[doc = "The maximum depth at which descendants of the root node should be retrieved.\nIf omitted, the full tree is returned."]
+            #[serde(rename = "depth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub depth: Option<i64>,
+            #[doc = "The frame for whose document the AX tree should be retrieved.\nIf omitted, the root frame is used."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+        }
+        impl GetFullAxTreeParams {
+            pub fn builder() -> GetFullAxTreeParamsBuilder {
+                GetFullAxTreeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetFullAxTreeParamsBuilder {
+            depth: Option<i64>,
+            frame_id: Option<super::page::FrameId>,
+        }
+        impl GetFullAxTreeParamsBuilder {
+            pub fn depth(mut self, depth: impl Into<i64>) -> Self {
+                self.depth = Some(depth.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> GetFullAxTreeParams {
+                GetFullAxTreeParams {
+                    depth: self.depth,
+                    frame_id: self.frame_id,
+                }
+            }
+        }
+        impl GetFullAxTreeParams {
+            pub const IDENTIFIER: &'static str = "Accessibility.getFullAXTree";
+        }
+        impl chromiumoxide_types::Method for GetFullAxTreeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetFullAxTreeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fetches the entire accessibility tree for the root Document\n[getFullAXTree](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-getFullAXTree)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetFullAxTreeReturns {
+            #[serde(rename = "nodes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub nodes: Vec<AxNode>,
+        }
+        impl GetFullAxTreeReturns {
+            pub fn new(nodes: Vec<AxNode>) -> Self {
+                Self { nodes }
+            }
+        }
+        impl GetFullAxTreeReturns {
+            pub fn builder() -> GetFullAxTreeReturnsBuilder {
+                GetFullAxTreeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetFullAxTreeReturnsBuilder {
+            nodes: Option<Vec<AxNode>>,
+        }
+        impl GetFullAxTreeReturnsBuilder {
+            pub fn node(mut self, node: impl Into<AxNode>) -> Self {
+                let v = self.nodes.get_or_insert(Vec::new());
+                v.push(node.into());
+                self
+            }
+            pub fn nodes<I, S>(mut self, nodes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AxNode>,
+            {
+                let v = self.nodes.get_or_insert(Vec::new());
+                for val in nodes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetFullAxTreeReturns, String> {
+                Ok(GetFullAxTreeReturns {
+                    nodes: self.nodes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(nodes))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetFullAxTreeParams {
+            type Response = GetFullAxTreeReturns;
+        }
+        #[doc = "Fetches the root node.\nRequires `enable()` to have been called previously.\n[getRootAXNode](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-getRootAXNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetRootAxNodeParams {
+            #[doc = "The frame in whose document the node resides.\nIf omitted, the root frame is used."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+        }
+        impl GetRootAxNodeParams {
+            pub fn builder() -> GetRootAxNodeParamsBuilder {
+                GetRootAxNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetRootAxNodeParamsBuilder {
+            frame_id: Option<super::page::FrameId>,
+        }
+        impl GetRootAxNodeParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> GetRootAxNodeParams {
+                GetRootAxNodeParams {
+                    frame_id: self.frame_id,
+                }
+            }
+        }
+        impl GetRootAxNodeParams {
+            pub const IDENTIFIER: &'static str = "Accessibility.getRootAXNode";
+        }
+        impl chromiumoxide_types::Method for GetRootAxNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetRootAxNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fetches the root node.\nRequires `enable()` to have been called previously.\n[getRootAXNode](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-getRootAXNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetRootAxNodeReturns {
+            #[serde(rename = "node")]
+            pub node: AxNode,
+        }
+        impl GetRootAxNodeReturns {
+            pub fn new(node: impl Into<AxNode>) -> Self {
+                Self { node: node.into() }
+            }
+        }
+        impl GetRootAxNodeReturns {
+            pub fn builder() -> GetRootAxNodeReturnsBuilder {
+                GetRootAxNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetRootAxNodeReturnsBuilder {
+            node: Option<AxNode>,
+        }
+        impl GetRootAxNodeReturnsBuilder {
+            pub fn node(mut self, node: impl Into<AxNode>) -> Self {
+                self.node = Some(node.into());
+                self
+            }
+            pub fn build(self) -> Result<GetRootAxNodeReturns, String> {
+                Ok(GetRootAxNodeReturns {
+                    node: self.node.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetRootAxNodeParams {
+            type Response = GetRootAxNodeReturns;
+        }
+        #[doc = "Fetches a node and all ancestors up to and including the root.\nRequires `enable()` to have been called previously.\n[getAXNodeAndAncestors](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-getAXNodeAndAncestors)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetAxNodeAndAncestorsParams {
+            #[doc = "Identifier of the node to get."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<super::dom::NodeId>,
+            #[doc = "Identifier of the backend node to get."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "JavaScript object id of the node wrapper to get."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl GetAxNodeAndAncestorsParams {
+            pub fn builder() -> GetAxNodeAndAncestorsParamsBuilder {
+                GetAxNodeAndAncestorsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAxNodeAndAncestorsParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl GetAxNodeAndAncestorsParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> GetAxNodeAndAncestorsParams {
+                GetAxNodeAndAncestorsParams {
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                }
+            }
+        }
+        impl GetAxNodeAndAncestorsParams {
+            pub const IDENTIFIER: &'static str = "Accessibility.getAXNodeAndAncestors";
+        }
+        impl chromiumoxide_types::Method for GetAxNodeAndAncestorsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetAxNodeAndAncestorsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fetches a node and all ancestors up to and including the root.\nRequires `enable()` to have been called previously.\n[getAXNodeAndAncestors](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-getAXNodeAndAncestors)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAxNodeAndAncestorsReturns {
+            #[serde(rename = "nodes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub nodes: Vec<AxNode>,
+        }
+        impl GetAxNodeAndAncestorsReturns {
+            pub fn new(nodes: Vec<AxNode>) -> Self {
+                Self { nodes }
+            }
+        }
+        impl GetAxNodeAndAncestorsReturns {
+            pub fn builder() -> GetAxNodeAndAncestorsReturnsBuilder {
+                GetAxNodeAndAncestorsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAxNodeAndAncestorsReturnsBuilder {
+            nodes: Option<Vec<AxNode>>,
+        }
+        impl GetAxNodeAndAncestorsReturnsBuilder {
+            pub fn node(mut self, node: impl Into<AxNode>) -> Self {
+                let v = self.nodes.get_or_insert(Vec::new());
+                v.push(node.into());
+                self
+            }
+            pub fn nodes<I, S>(mut self, nodes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AxNode>,
+            {
+                let v = self.nodes.get_or_insert(Vec::new());
+                for val in nodes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetAxNodeAndAncestorsReturns, String> {
+                Ok(GetAxNodeAndAncestorsReturns {
+                    nodes: self.nodes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(nodes))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetAxNodeAndAncestorsParams {
+            type Response = GetAxNodeAndAncestorsReturns;
+        }
+        #[doc = "Fetches a particular accessibility node by AXNodeId.\nRequires `enable()` to have been called previously.\n[getChildAXNodes](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-getChildAXNodes)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetChildAxNodesParams {
+            #[serde(rename = "id")]
+            pub id: AxNodeId,
+            #[doc = "The frame in whose document the node resides.\nIf omitted, the root frame is used."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+        }
+        impl GetChildAxNodesParams {
+            pub fn new(id: impl Into<AxNodeId>) -> Self {
+                Self {
+                    id: id.into(),
+                    frame_id: None,
+                }
+            }
+        }
+        impl GetChildAxNodesParams {
+            pub fn builder() -> GetChildAxNodesParamsBuilder {
+                GetChildAxNodesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetChildAxNodesParamsBuilder {
+            id: Option<AxNodeId>,
+            frame_id: Option<super::page::FrameId>,
+        }
+        impl GetChildAxNodesParamsBuilder {
+            pub fn id(mut self, id: impl Into<AxNodeId>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetChildAxNodesParams, String> {
+                Ok(GetChildAxNodesParams {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    frame_id: self.frame_id,
+                })
+            }
+        }
+        impl GetChildAxNodesParams {
+            pub const IDENTIFIER: &'static str = "Accessibility.getChildAXNodes";
+        }
+        impl chromiumoxide_types::Method for GetChildAxNodesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetChildAxNodesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fetches a particular accessibility node by AXNodeId.\nRequires `enable()` to have been called previously.\n[getChildAXNodes](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-getChildAXNodes)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetChildAxNodesReturns {
+            #[serde(rename = "nodes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub nodes: Vec<AxNode>,
+        }
+        impl GetChildAxNodesReturns {
+            pub fn new(nodes: Vec<AxNode>) -> Self {
+                Self { nodes }
+            }
+        }
+        impl GetChildAxNodesReturns {
+            pub fn builder() -> GetChildAxNodesReturnsBuilder {
+                GetChildAxNodesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetChildAxNodesReturnsBuilder {
+            nodes: Option<Vec<AxNode>>,
+        }
+        impl GetChildAxNodesReturnsBuilder {
+            pub fn node(mut self, node: impl Into<AxNode>) -> Self {
+                let v = self.nodes.get_or_insert(Vec::new());
+                v.push(node.into());
+                self
+            }
+            pub fn nodes<I, S>(mut self, nodes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AxNode>,
+            {
+                let v = self.nodes.get_or_insert(Vec::new());
+                for val in nodes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetChildAxNodesReturns, String> {
+                Ok(GetChildAxNodesReturns {
+                    nodes: self.nodes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(nodes))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetChildAxNodesParams {
+            type Response = GetChildAxNodesReturns;
+        }
+        #[doc = "Query a DOM node's accessibility subtree for accessible name and role.\nThis command computes the name and role for all nodes in the subtree, including those that are\nignored for accessibility, and returns those that match the specified name and role. If no DOM\nnode is specified, or the DOM node does not exist, the command returns an error. If neither\n`accessibleName` or `role` is specified, it returns all the accessibility nodes in the subtree.\n[queryAXTree](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-queryAXTree)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct QueryAxTreeParams {
+            #[doc = "Identifier of the node for the root to query."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<super::dom::NodeId>,
+            #[doc = "Identifier of the backend node for the root to query."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "JavaScript object id of the node wrapper for the root to query."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            #[doc = "Find nodes with this computed name."]
+            #[serde(rename = "accessibleName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub accessible_name: Option<String>,
+            #[doc = "Find nodes with this computed role."]
+            #[serde(rename = "role")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub role: Option<String>,
+        }
+        impl QueryAxTreeParams {
+            pub fn builder() -> QueryAxTreeParamsBuilder {
+                QueryAxTreeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct QueryAxTreeParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            accessible_name: Option<String>,
+            role: Option<String>,
+        }
+        impl QueryAxTreeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn accessible_name(mut self, accessible_name: impl Into<String>) -> Self {
+                self.accessible_name = Some(accessible_name.into());
+                self
+            }
+            pub fn role(mut self, role: impl Into<String>) -> Self {
+                self.role = Some(role.into());
+                self
+            }
+            pub fn build(self) -> QueryAxTreeParams {
+                QueryAxTreeParams {
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                    accessible_name: self.accessible_name,
+                    role: self.role,
+                }
+            }
+        }
+        impl QueryAxTreeParams {
+            pub const IDENTIFIER: &'static str = "Accessibility.queryAXTree";
+        }
+        impl chromiumoxide_types::Method for QueryAxTreeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for QueryAxTreeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Query a DOM node's accessibility subtree for accessible name and role.\nThis command computes the name and role for all nodes in the subtree, including those that are\nignored for accessibility, and returns those that match the specified name and role. If no DOM\nnode is specified, or the DOM node does not exist, the command returns an error. If neither\n`accessibleName` or `role` is specified, it returns all the accessibility nodes in the subtree.\n[queryAXTree](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#method-queryAXTree)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct QueryAxTreeReturns {
+            #[doc = "A list of `Accessibility.AXNode` matching the specified attributes,\nincluding nodes that are ignored for accessibility."]
+            #[serde(rename = "nodes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub nodes: Vec<AxNode>,
+        }
+        impl QueryAxTreeReturns {
+            pub fn new(nodes: Vec<AxNode>) -> Self {
+                Self { nodes }
+            }
+        }
+        impl QueryAxTreeReturns {
+            pub fn builder() -> QueryAxTreeReturnsBuilder {
+                QueryAxTreeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct QueryAxTreeReturnsBuilder {
+            nodes: Option<Vec<AxNode>>,
+        }
+        impl QueryAxTreeReturnsBuilder {
+            pub fn node(mut self, node: impl Into<AxNode>) -> Self {
+                let v = self.nodes.get_or_insert(Vec::new());
+                v.push(node.into());
+                self
+            }
+            pub fn nodes<I, S>(mut self, nodes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AxNode>,
+            {
+                let v = self.nodes.get_or_insert(Vec::new());
+                for val in nodes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<QueryAxTreeReturns, String> {
+                Ok(QueryAxTreeReturns {
+                    nodes: self.nodes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(nodes))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for QueryAxTreeParams {
+            type Response = QueryAxTreeReturns;
+        }
+        #[doc = "The loadComplete event mirrors the load complete event sent by the browser to assistive\ntechnology when the web page has finished loading.\n[loadComplete](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#event-loadComplete)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventLoadComplete {
+            #[doc = "New document root node."]
+            #[serde(rename = "root")]
+            pub root: AxNode,
+        }
+        impl EventLoadComplete {
+            pub const IDENTIFIER: &'static str = "Accessibility.loadComplete";
+        }
+        impl chromiumoxide_types::Method for EventLoadComplete {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventLoadComplete {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "The nodesUpdated event is sent every time a previously requested node has changed the in tree.\n[nodesUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#event-nodesUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventNodesUpdated {
+            #[doc = "Updated node data."]
+            #[serde(rename = "nodes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub nodes: Vec<AxNode>,
+        }
+        impl EventNodesUpdated {
+            pub const IDENTIFIER: &'static str = "Accessibility.nodesUpdated";
+        }
+        impl chromiumoxide_types::Method for EventNodesUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventNodesUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod animation {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Animation instance.\n[Animation](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#type-Animation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Animation {
+            #[doc = "`Animation`'s id."]
+            #[serde(rename = "id")]
+            pub id: String,
+            #[doc = "`Animation`'s name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "`Animation`'s internal paused state."]
+            #[serde(rename = "pausedState")]
+            pub paused_state: bool,
+            #[doc = "`Animation`'s play state."]
+            #[serde(rename = "playState")]
+            pub play_state: String,
+            #[doc = "`Animation`'s playback rate."]
+            #[serde(rename = "playbackRate")]
+            pub playback_rate: f64,
+            #[doc = "`Animation`'s start time.\nMilliseconds for time based animations and\npercentage [0 - 100] for scroll driven animations\n(i.e. when viewOrScrollTimeline exists)."]
+            #[serde(rename = "startTime")]
+            pub start_time: f64,
+            #[doc = "`Animation`'s current time."]
+            #[serde(rename = "currentTime")]
+            pub current_time: f64,
+            #[doc = "Animation type of `Animation`."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: AnimationType,
+            #[doc = "`Animation`'s source animation node."]
+            #[serde(rename = "source")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source: Option<AnimationEffect>,
+            #[doc = "A unique ID for `Animation` representing the sources that triggered this CSS\nanimation/transition."]
+            #[serde(rename = "cssId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub css_id: Option<String>,
+            #[doc = "View or scroll timeline"]
+            #[serde(rename = "viewOrScrollTimeline")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub view_or_scroll_timeline: Option<ViewOrScrollTimeline>,
+        }
+        #[doc = "Animation type of `Animation`."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AnimationType {
+            #[serde(rename = "CSSTransition")]
+            CssTransition,
+            #[serde(rename = "CSSAnimation")]
+            CssAnimation,
+            #[serde(rename = "WebAnimation")]
+            WebAnimation,
+        }
+        impl AsRef<str> for AnimationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AnimationType::CssTransition => "CSSTransition",
+                    AnimationType::CssAnimation => "CSSAnimation",
+                    AnimationType::WebAnimation => "WebAnimation",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AnimationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "CSSTransition" | "CssTransition" | "csstransition" => {
+                        Ok(AnimationType::CssTransition)
+                    }
+                    "CSSAnimation" | "CssAnimation" | "cssanimation" => {
+                        Ok(AnimationType::CssAnimation)
+                    }
+                    "WebAnimation" | "webanimation" => Ok(AnimationType::WebAnimation),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl Animation {
+            pub fn builder() -> AnimationBuilder {
+                AnimationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AnimationBuilder {
+            id: Option<String>,
+            name: Option<String>,
+            paused_state: Option<bool>,
+            play_state: Option<String>,
+            playback_rate: Option<f64>,
+            start_time: Option<f64>,
+            current_time: Option<f64>,
+            r#type: Option<AnimationType>,
+            source: Option<AnimationEffect>,
+            css_id: Option<String>,
+            view_or_scroll_timeline: Option<ViewOrScrollTimeline>,
+        }
+        impl AnimationBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn paused_state(mut self, paused_state: impl Into<bool>) -> Self {
+                self.paused_state = Some(paused_state.into());
+                self
+            }
+            pub fn play_state(mut self, play_state: impl Into<String>) -> Self {
+                self.play_state = Some(play_state.into());
+                self
+            }
+            pub fn playback_rate(mut self, playback_rate: impl Into<f64>) -> Self {
+                self.playback_rate = Some(playback_rate.into());
+                self
+            }
+            pub fn start_time(mut self, start_time: impl Into<f64>) -> Self {
+                self.start_time = Some(start_time.into());
+                self
+            }
+            pub fn current_time(mut self, current_time: impl Into<f64>) -> Self {
+                self.current_time = Some(current_time.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<AnimationType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn source(mut self, source: impl Into<AnimationEffect>) -> Self {
+                self.source = Some(source.into());
+                self
+            }
+            pub fn css_id(mut self, css_id: impl Into<String>) -> Self {
+                self.css_id = Some(css_id.into());
+                self
+            }
+            pub fn view_or_scroll_timeline(
+                mut self,
+                view_or_scroll_timeline: impl Into<ViewOrScrollTimeline>,
+            ) -> Self {
+                self.view_or_scroll_timeline = Some(view_or_scroll_timeline.into());
+                self
+            }
+            pub fn build(self) -> Result<Animation, String> {
+                Ok(Animation {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    paused_state: self.paused_state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(paused_state))
+                    })?,
+                    play_state: self.play_state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(play_state))
+                    })?,
+                    playback_rate: self.playback_rate.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(playback_rate))
+                    })?,
+                    start_time: self.start_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start_time))
+                    })?,
+                    current_time: self.current_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(current_time))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    source: self.source,
+                    css_id: self.css_id,
+                    view_or_scroll_timeline: self.view_or_scroll_timeline,
+                })
+            }
+        }
+        impl Animation {
+            pub const IDENTIFIER: &'static str = "Animation.Animation";
+        }
+        #[doc = "Timeline instance\n[ViewOrScrollTimeline](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#type-ViewOrScrollTimeline)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ViewOrScrollTimeline {
+            #[doc = "Scroll container node"]
+            #[serde(rename = "sourceNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "Represents the starting scroll position of the timeline\nas a length offset in pixels from scroll origin."]
+            #[serde(rename = "startOffset")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub start_offset: Option<f64>,
+            #[doc = "Represents the ending scroll position of the timeline\nas a length offset in pixels from scroll origin."]
+            #[serde(rename = "endOffset")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub end_offset: Option<f64>,
+            #[doc = "The element whose principal box's visibility in the\nscrollport defined the progress of the timeline.\nDoes not exist for animations with ScrollTimeline"]
+            #[serde(rename = "subjectNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub subject_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "Orientation of the scroll"]
+            #[serde(rename = "axis")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub axis: super::dom::ScrollOrientation,
+        }
+        impl ViewOrScrollTimeline {
+            pub fn new(axis: impl Into<super::dom::ScrollOrientation>) -> Self {
+                Self {
+                    axis: axis.into(),
+                    source_node_id: None,
+                    start_offset: None,
+                    end_offset: None,
+                    subject_node_id: None,
+                }
+            }
+        }
+        impl ViewOrScrollTimeline {
+            pub fn builder() -> ViewOrScrollTimelineBuilder {
+                ViewOrScrollTimelineBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ViewOrScrollTimelineBuilder {
+            source_node_id: Option<super::dom::BackendNodeId>,
+            start_offset: Option<f64>,
+            end_offset: Option<f64>,
+            subject_node_id: Option<super::dom::BackendNodeId>,
+            axis: Option<super::dom::ScrollOrientation>,
+        }
+        impl ViewOrScrollTimelineBuilder {
+            pub fn source_node_id(
+                mut self,
+                source_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.source_node_id = Some(source_node_id.into());
+                self
+            }
+            pub fn start_offset(mut self, start_offset: impl Into<f64>) -> Self {
+                self.start_offset = Some(start_offset.into());
+                self
+            }
+            pub fn end_offset(mut self, end_offset: impl Into<f64>) -> Self {
+                self.end_offset = Some(end_offset.into());
+                self
+            }
+            pub fn subject_node_id(
+                mut self,
+                subject_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.subject_node_id = Some(subject_node_id.into());
+                self
+            }
+            pub fn axis(mut self, axis: impl Into<super::dom::ScrollOrientation>) -> Self {
+                self.axis = Some(axis.into());
+                self
+            }
+            pub fn build(self) -> Result<ViewOrScrollTimeline, String> {
+                Ok(ViewOrScrollTimeline {
+                    source_node_id: self.source_node_id,
+                    start_offset: self.start_offset,
+                    end_offset: self.end_offset,
+                    subject_node_id: self.subject_node_id,
+                    axis: self.axis.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(axis))
+                    })?,
+                })
+            }
+        }
+        impl ViewOrScrollTimeline {
+            pub const IDENTIFIER: &'static str = "Animation.ViewOrScrollTimeline";
+        }
+        #[doc = "AnimationEffect instance\n[AnimationEffect](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#type-AnimationEffect)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AnimationEffect {
+            #[doc = "`AnimationEffect`'s delay."]
+            #[serde(rename = "delay")]
+            pub delay: f64,
+            #[doc = "`AnimationEffect`'s end delay."]
+            #[serde(rename = "endDelay")]
+            pub end_delay: f64,
+            #[doc = "`AnimationEffect`'s iteration start."]
+            #[serde(rename = "iterationStart")]
+            pub iteration_start: f64,
+            #[doc = "`AnimationEffect`'s iterations. Omitted if the value is infinite."]
+            #[serde(rename = "iterations")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub iterations: Option<f64>,
+            #[doc = "`AnimationEffect`'s iteration duration.\nMilliseconds for time based animations and\npercentage [0 - 100] for scroll driven animations\n(i.e. when viewOrScrollTimeline exists)."]
+            #[serde(rename = "duration")]
+            pub duration: f64,
+            #[doc = "`AnimationEffect`'s playback direction."]
+            #[serde(rename = "direction")]
+            pub direction: String,
+            #[doc = "`AnimationEffect`'s fill mode."]
+            #[serde(rename = "fill")]
+            pub fill: String,
+            #[doc = "`AnimationEffect`'s target node."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "`AnimationEffect`'s keyframes."]
+            #[serde(rename = "keyframesRule")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub keyframes_rule: Option<KeyframesRule>,
+            #[doc = "`AnimationEffect`'s timing function."]
+            #[serde(rename = "easing")]
+            pub easing: String,
+        }
+        impl AnimationEffect {
+            pub fn builder() -> AnimationEffectBuilder {
+                AnimationEffectBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AnimationEffectBuilder {
+            delay: Option<f64>,
+            end_delay: Option<f64>,
+            iteration_start: Option<f64>,
+            iterations: Option<f64>,
+            duration: Option<f64>,
+            direction: Option<String>,
+            fill: Option<String>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+            keyframes_rule: Option<KeyframesRule>,
+            easing: Option<String>,
+        }
+        impl AnimationEffectBuilder {
+            pub fn delay(mut self, delay: impl Into<f64>) -> Self {
+                self.delay = Some(delay.into());
+                self
+            }
+            pub fn end_delay(mut self, end_delay: impl Into<f64>) -> Self {
+                self.end_delay = Some(end_delay.into());
+                self
+            }
+            pub fn iteration_start(mut self, iteration_start: impl Into<f64>) -> Self {
+                self.iteration_start = Some(iteration_start.into());
+                self
+            }
+            pub fn iterations(mut self, iterations: impl Into<f64>) -> Self {
+                self.iterations = Some(iterations.into());
+                self
+            }
+            pub fn duration(mut self, duration: impl Into<f64>) -> Self {
+                self.duration = Some(duration.into());
+                self
+            }
+            pub fn direction(mut self, direction: impl Into<String>) -> Self {
+                self.direction = Some(direction.into());
+                self
+            }
+            pub fn fill(mut self, fill: impl Into<String>) -> Self {
+                self.fill = Some(fill.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn keyframes_rule(mut self, keyframes_rule: impl Into<KeyframesRule>) -> Self {
+                self.keyframes_rule = Some(keyframes_rule.into());
+                self
+            }
+            pub fn easing(mut self, easing: impl Into<String>) -> Self {
+                self.easing = Some(easing.into());
+                self
+            }
+            pub fn build(self) -> Result<AnimationEffect, String> {
+                Ok(AnimationEffect {
+                    delay: self.delay.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(delay))
+                    })?,
+                    end_delay: self.end_delay.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(end_delay))
+                    })?,
+                    iteration_start: self.iteration_start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(iteration_start))
+                    })?,
+                    iterations: self.iterations,
+                    duration: self.duration.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(duration))
+                    })?,
+                    direction: self.direction.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(direction))
+                    })?,
+                    fill: self.fill.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(fill))
+                    })?,
+                    backend_node_id: self.backend_node_id,
+                    keyframes_rule: self.keyframes_rule,
+                    easing: self.easing.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(easing))
+                    })?,
+                })
+            }
+        }
+        impl AnimationEffect {
+            pub const IDENTIFIER: &'static str = "Animation.AnimationEffect";
+        }
+        #[doc = "Keyframes Rule\n[KeyframesRule](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#type-KeyframesRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct KeyframesRule {
+            #[doc = "CSS keyframed animation's name."]
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[doc = "List of animation keyframes."]
+            #[serde(rename = "keyframes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub keyframes: Vec<KeyframeStyle>,
+        }
+        impl KeyframesRule {
+            pub fn new(keyframes: Vec<KeyframeStyle>) -> Self {
+                Self {
+                    keyframes,
+                    name: None,
+                }
+            }
+        }
+        impl KeyframesRule {
+            pub fn builder() -> KeyframesRuleBuilder {
+                KeyframesRuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct KeyframesRuleBuilder {
+            name: Option<String>,
+            keyframes: Option<Vec<KeyframeStyle>>,
+        }
+        impl KeyframesRuleBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn keyframe(mut self, keyframe: impl Into<KeyframeStyle>) -> Self {
+                let v = self.keyframes.get_or_insert(Vec::new());
+                v.push(keyframe.into());
+                self
+            }
+            pub fn keyframes<I, S>(mut self, keyframes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<KeyframeStyle>,
+            {
+                let v = self.keyframes.get_or_insert(Vec::new());
+                for val in keyframes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<KeyframesRule, String> {
+                Ok(KeyframesRule {
+                    name: self.name,
+                    keyframes: self.keyframes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(keyframes))
+                    })?,
+                })
+            }
+        }
+        impl KeyframesRule {
+            pub const IDENTIFIER: &'static str = "Animation.KeyframesRule";
+        }
+        #[doc = "Keyframe Style\n[KeyframeStyle](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#type-KeyframeStyle)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct KeyframeStyle {
+            #[doc = "Keyframe's time offset."]
+            #[serde(rename = "offset")]
+            pub offset: String,
+            #[doc = "`AnimationEffect`'s timing function."]
+            #[serde(rename = "easing")]
+            pub easing: String,
+        }
+        impl KeyframeStyle {
+            pub fn new(offset: impl Into<String>, easing: impl Into<String>) -> Self {
+                Self {
+                    offset: offset.into(),
+                    easing: easing.into(),
+                }
+            }
+        }
+        impl KeyframeStyle {
+            pub fn builder() -> KeyframeStyleBuilder {
+                KeyframeStyleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct KeyframeStyleBuilder {
+            offset: Option<String>,
+            easing: Option<String>,
+        }
+        impl KeyframeStyleBuilder {
+            pub fn offset(mut self, offset: impl Into<String>) -> Self {
+                self.offset = Some(offset.into());
+                self
+            }
+            pub fn easing(mut self, easing: impl Into<String>) -> Self {
+                self.easing = Some(easing.into());
+                self
+            }
+            pub fn build(self) -> Result<KeyframeStyle, String> {
+                Ok(KeyframeStyle {
+                    offset: self.offset.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(offset))
+                    })?,
+                    easing: self.easing.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(easing))
+                    })?,
+                })
+            }
+        }
+        impl KeyframeStyle {
+            pub const IDENTIFIER: &'static str = "Animation.KeyframeStyle";
+        }
+        #[doc = "Disables animation domain notifications.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Animation.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables animation domain notifications.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables animation domain notifications.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Animation.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables animation domain notifications.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Returns the current time of the an animation.\n[getCurrentTime](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-getCurrentTime)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCurrentTimeParams {
+            #[doc = "Id of animation."]
+            #[serde(rename = "id")]
+            pub id: String,
+        }
+        impl GetCurrentTimeParams {
+            pub fn new(id: impl Into<String>) -> Self {
+                Self { id: id.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetCurrentTimeParams {
+            fn from(url: T) -> Self {
+                GetCurrentTimeParams::new(url)
+            }
+        }
+        impl GetCurrentTimeParams {
+            pub fn builder() -> GetCurrentTimeParamsBuilder {
+                GetCurrentTimeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCurrentTimeParamsBuilder {
+            id: Option<String>,
+        }
+        impl GetCurrentTimeParamsBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetCurrentTimeParams, String> {
+                Ok(GetCurrentTimeParams {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                })
+            }
+        }
+        impl GetCurrentTimeParams {
+            pub const IDENTIFIER: &'static str = "Animation.getCurrentTime";
+        }
+        impl chromiumoxide_types::Method for GetCurrentTimeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetCurrentTimeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the current time of the an animation.\n[getCurrentTime](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-getCurrentTime)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCurrentTimeReturns {
+            #[doc = "Current time of the page."]
+            #[serde(rename = "currentTime")]
+            pub current_time: f64,
+        }
+        impl GetCurrentTimeReturns {
+            pub fn new(current_time: impl Into<f64>) -> Self {
+                Self {
+                    current_time: current_time.into(),
+                }
+            }
+        }
+        impl GetCurrentTimeReturns {
+            pub fn builder() -> GetCurrentTimeReturnsBuilder {
+                GetCurrentTimeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCurrentTimeReturnsBuilder {
+            current_time: Option<f64>,
+        }
+        impl GetCurrentTimeReturnsBuilder {
+            pub fn current_time(mut self, current_time: impl Into<f64>) -> Self {
+                self.current_time = Some(current_time.into());
+                self
+            }
+            pub fn build(self) -> Result<GetCurrentTimeReturns, String> {
+                Ok(GetCurrentTimeReturns {
+                    current_time: self.current_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(current_time))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetCurrentTimeParams {
+            type Response = GetCurrentTimeReturns;
+        }
+        #[doc = "Gets the playback rate of the document timeline.\n[getPlaybackRate](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-getPlaybackRate)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetPlaybackRateParams {}
+        impl GetPlaybackRateParams {
+            pub const IDENTIFIER: &'static str = "Animation.getPlaybackRate";
+        }
+        impl chromiumoxide_types::Method for GetPlaybackRateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetPlaybackRateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets the playback rate of the document timeline.\n[getPlaybackRate](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-getPlaybackRate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetPlaybackRateReturns {
+            #[doc = "Playback rate for animations on page."]
+            #[serde(rename = "playbackRate")]
+            pub playback_rate: f64,
+        }
+        impl GetPlaybackRateReturns {
+            pub fn new(playback_rate: impl Into<f64>) -> Self {
+                Self {
+                    playback_rate: playback_rate.into(),
+                }
+            }
+        }
+        impl GetPlaybackRateReturns {
+            pub fn builder() -> GetPlaybackRateReturnsBuilder {
+                GetPlaybackRateReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPlaybackRateReturnsBuilder {
+            playback_rate: Option<f64>,
+        }
+        impl GetPlaybackRateReturnsBuilder {
+            pub fn playback_rate(mut self, playback_rate: impl Into<f64>) -> Self {
+                self.playback_rate = Some(playback_rate.into());
+                self
+            }
+            pub fn build(self) -> Result<GetPlaybackRateReturns, String> {
+                Ok(GetPlaybackRateReturns {
+                    playback_rate: self.playback_rate.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(playback_rate))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetPlaybackRateParams {
+            type Response = GetPlaybackRateReturns;
+        }
+        #[doc = "Releases a set of animations to no longer be manipulated.\n[releaseAnimations](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-releaseAnimations)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReleaseAnimationsParams {
+            #[doc = "List of animation ids to seek."]
+            #[serde(rename = "animations")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub animations: Vec<String>,
+        }
+        impl ReleaseAnimationsParams {
+            pub fn new(animations: Vec<String>) -> Self {
+                Self { animations }
+            }
+        }
+        impl ReleaseAnimationsParams {
+            pub fn builder() -> ReleaseAnimationsParamsBuilder {
+                ReleaseAnimationsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReleaseAnimationsParamsBuilder {
+            animations: Option<Vec<String>>,
+        }
+        impl ReleaseAnimationsParamsBuilder {
+            pub fn animation(mut self, animation: impl Into<String>) -> Self {
+                let v = self.animations.get_or_insert(Vec::new());
+                v.push(animation.into());
+                self
+            }
+            pub fn animations<I, S>(mut self, animations: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.animations.get_or_insert(Vec::new());
+                for val in animations {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ReleaseAnimationsParams, String> {
+                Ok(ReleaseAnimationsParams {
+                    animations: self.animations.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(animations))
+                    })?,
+                })
+            }
+        }
+        impl ReleaseAnimationsParams {
+            pub const IDENTIFIER: &'static str = "Animation.releaseAnimations";
+        }
+        impl chromiumoxide_types::Method for ReleaseAnimationsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ReleaseAnimationsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Releases a set of animations to no longer be manipulated.\n[releaseAnimations](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-releaseAnimations)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ReleaseAnimationsReturns {}
+        impl chromiumoxide_types::Command for ReleaseAnimationsParams {
+            type Response = ReleaseAnimationsReturns;
+        }
+        #[doc = "Gets the remote object of the Animation.\n[resolveAnimation](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-resolveAnimation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ResolveAnimationParams {
+            #[doc = "Animation id."]
+            #[serde(rename = "animationId")]
+            pub animation_id: String,
+        }
+        impl ResolveAnimationParams {
+            pub fn new(animation_id: impl Into<String>) -> Self {
+                Self {
+                    animation_id: animation_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for ResolveAnimationParams {
+            fn from(url: T) -> Self {
+                ResolveAnimationParams::new(url)
+            }
+        }
+        impl ResolveAnimationParams {
+            pub fn builder() -> ResolveAnimationParamsBuilder {
+                ResolveAnimationParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResolveAnimationParamsBuilder {
+            animation_id: Option<String>,
+        }
+        impl ResolveAnimationParamsBuilder {
+            pub fn animation_id(mut self, animation_id: impl Into<String>) -> Self {
+                self.animation_id = Some(animation_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ResolveAnimationParams, String> {
+                Ok(ResolveAnimationParams {
+                    animation_id: self.animation_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(animation_id))
+                    })?,
+                })
+            }
+        }
+        impl ResolveAnimationParams {
+            pub const IDENTIFIER: &'static str = "Animation.resolveAnimation";
+        }
+        impl chromiumoxide_types::Method for ResolveAnimationParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ResolveAnimationParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets the remote object of the Animation.\n[resolveAnimation](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-resolveAnimation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ResolveAnimationReturns {
+            #[doc = "Corresponding remote object."]
+            #[serde(rename = "remoteObject")]
+            pub remote_object: super::super::js_protocol::runtime::RemoteObject,
+        }
+        impl ResolveAnimationReturns {
+            pub fn new(
+                remote_object: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                Self {
+                    remote_object: remote_object.into(),
+                }
+            }
+        }
+        impl ResolveAnimationReturns {
+            pub fn builder() -> ResolveAnimationReturnsBuilder {
+                ResolveAnimationReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResolveAnimationReturnsBuilder {
+            remote_object: Option<super::super::js_protocol::runtime::RemoteObject>,
+        }
+        impl ResolveAnimationReturnsBuilder {
+            pub fn remote_object(
+                mut self,
+                remote_object: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                self.remote_object = Some(remote_object.into());
+                self
+            }
+            pub fn build(self) -> Result<ResolveAnimationReturns, String> {
+                Ok(ResolveAnimationReturns {
+                    remote_object: self.remote_object.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(remote_object))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for ResolveAnimationParams {
+            type Response = ResolveAnimationReturns;
+        }
+        #[doc = "Seek a set of animations to a particular time within each animation.\n[seekAnimations](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-seekAnimations)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SeekAnimationsParams {
+            #[doc = "List of animation ids to seek."]
+            #[serde(rename = "animations")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub animations: Vec<String>,
+            #[doc = "Set the current time of each animation."]
+            #[serde(rename = "currentTime")]
+            pub current_time: f64,
+        }
+        impl SeekAnimationsParams {
+            pub fn new(animations: Vec<String>, current_time: impl Into<f64>) -> Self {
+                Self {
+                    animations,
+                    current_time: current_time.into(),
+                }
+            }
+        }
+        impl SeekAnimationsParams {
+            pub fn builder() -> SeekAnimationsParamsBuilder {
+                SeekAnimationsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SeekAnimationsParamsBuilder {
+            animations: Option<Vec<String>>,
+            current_time: Option<f64>,
+        }
+        impl SeekAnimationsParamsBuilder {
+            pub fn animation(mut self, animation: impl Into<String>) -> Self {
+                let v = self.animations.get_or_insert(Vec::new());
+                v.push(animation.into());
+                self
+            }
+            pub fn animations<I, S>(mut self, animations: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.animations.get_or_insert(Vec::new());
+                for val in animations {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn current_time(mut self, current_time: impl Into<f64>) -> Self {
+                self.current_time = Some(current_time.into());
+                self
+            }
+            pub fn build(self) -> Result<SeekAnimationsParams, String> {
+                Ok(SeekAnimationsParams {
+                    animations: self.animations.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(animations))
+                    })?,
+                    current_time: self.current_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(current_time))
+                    })?,
+                })
+            }
+        }
+        impl SeekAnimationsParams {
+            pub const IDENTIFIER: &'static str = "Animation.seekAnimations";
+        }
+        impl chromiumoxide_types::Method for SeekAnimationsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SeekAnimationsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Seek a set of animations to a particular time within each animation.\n[seekAnimations](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-seekAnimations)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SeekAnimationsReturns {}
+        impl chromiumoxide_types::Command for SeekAnimationsParams {
+            type Response = SeekAnimationsReturns;
+        }
+        #[doc = "Sets the paused state of a set of animations.\n[setPaused](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-setPaused)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPausedParams {
+            #[doc = "Animations to set the pause state of."]
+            #[serde(rename = "animations")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub animations: Vec<String>,
+            #[doc = "Paused state to set to."]
+            #[serde(rename = "paused")]
+            pub paused: bool,
+        }
+        impl SetPausedParams {
+            pub fn new(animations: Vec<String>, paused: impl Into<bool>) -> Self {
+                Self {
+                    animations,
+                    paused: paused.into(),
+                }
+            }
+        }
+        impl SetPausedParams {
+            pub fn builder() -> SetPausedParamsBuilder {
+                SetPausedParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPausedParamsBuilder {
+            animations: Option<Vec<String>>,
+            paused: Option<bool>,
+        }
+        impl SetPausedParamsBuilder {
+            pub fn animation(mut self, animation: impl Into<String>) -> Self {
+                let v = self.animations.get_or_insert(Vec::new());
+                v.push(animation.into());
+                self
+            }
+            pub fn animations<I, S>(mut self, animations: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.animations.get_or_insert(Vec::new());
+                for val in animations {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn paused(mut self, paused: impl Into<bool>) -> Self {
+                self.paused = Some(paused.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPausedParams, String> {
+                Ok(SetPausedParams {
+                    animations: self.animations.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(animations))
+                    })?,
+                    paused: self.paused.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(paused))
+                    })?,
+                })
+            }
+        }
+        impl SetPausedParams {
+            pub const IDENTIFIER: &'static str = "Animation.setPaused";
+        }
+        impl chromiumoxide_types::Method for SetPausedParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPausedParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets the paused state of a set of animations.\n[setPaused](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-setPaused)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPausedReturns {}
+        impl chromiumoxide_types::Command for SetPausedParams {
+            type Response = SetPausedReturns;
+        }
+        #[doc = "Sets the playback rate of the document timeline.\n[setPlaybackRate](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-setPlaybackRate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPlaybackRateParams {
+            #[doc = "Playback rate for animations on page"]
+            #[serde(rename = "playbackRate")]
+            pub playback_rate: f64,
+        }
+        impl SetPlaybackRateParams {
+            pub fn new(playback_rate: impl Into<f64>) -> Self {
+                Self {
+                    playback_rate: playback_rate.into(),
+                }
+            }
+        }
+        impl SetPlaybackRateParams {
+            pub fn builder() -> SetPlaybackRateParamsBuilder {
+                SetPlaybackRateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPlaybackRateParamsBuilder {
+            playback_rate: Option<f64>,
+        }
+        impl SetPlaybackRateParamsBuilder {
+            pub fn playback_rate(mut self, playback_rate: impl Into<f64>) -> Self {
+                self.playback_rate = Some(playback_rate.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPlaybackRateParams, String> {
+                Ok(SetPlaybackRateParams {
+                    playback_rate: self.playback_rate.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(playback_rate))
+                    })?,
+                })
+            }
+        }
+        impl SetPlaybackRateParams {
+            pub const IDENTIFIER: &'static str = "Animation.setPlaybackRate";
+        }
+        impl chromiumoxide_types::Method for SetPlaybackRateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPlaybackRateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets the playback rate of the document timeline.\n[setPlaybackRate](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-setPlaybackRate)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPlaybackRateReturns {}
+        impl chromiumoxide_types::Command for SetPlaybackRateParams {
+            type Response = SetPlaybackRateReturns;
+        }
+        #[doc = "Sets the timing of an animation node.\n[setTiming](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-setTiming)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetTimingParams {
+            #[doc = "Animation id."]
+            #[serde(rename = "animationId")]
+            pub animation_id: String,
+            #[doc = "Duration of the animation."]
+            #[serde(rename = "duration")]
+            pub duration: f64,
+            #[doc = "Delay of the animation."]
+            #[serde(rename = "delay")]
+            pub delay: f64,
+        }
+        impl SetTimingParams {
+            pub fn new(
+                animation_id: impl Into<String>,
+                duration: impl Into<f64>,
+                delay: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    animation_id: animation_id.into(),
+                    duration: duration.into(),
+                    delay: delay.into(),
+                }
+            }
+        }
+        impl SetTimingParams {
+            pub fn builder() -> SetTimingParamsBuilder {
+                SetTimingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetTimingParamsBuilder {
+            animation_id: Option<String>,
+            duration: Option<f64>,
+            delay: Option<f64>,
+        }
+        impl SetTimingParamsBuilder {
+            pub fn animation_id(mut self, animation_id: impl Into<String>) -> Self {
+                self.animation_id = Some(animation_id.into());
+                self
+            }
+            pub fn duration(mut self, duration: impl Into<f64>) -> Self {
+                self.duration = Some(duration.into());
+                self
+            }
+            pub fn delay(mut self, delay: impl Into<f64>) -> Self {
+                self.delay = Some(delay.into());
+                self
+            }
+            pub fn build(self) -> Result<SetTimingParams, String> {
+                Ok(SetTimingParams {
+                    animation_id: self.animation_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(animation_id))
+                    })?,
+                    duration: self.duration.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(duration))
+                    })?,
+                    delay: self.delay.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(delay))
+                    })?,
+                })
+            }
+        }
+        impl SetTimingParams {
+            pub const IDENTIFIER: &'static str = "Animation.setTiming";
+        }
+        impl chromiumoxide_types::Method for SetTimingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetTimingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets the timing of an animation node.\n[setTiming](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#method-setTiming)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetTimingReturns {}
+        impl chromiumoxide_types::Command for SetTimingParams {
+            type Response = SetTimingReturns;
+        }
+        #[doc = "Event for when an animation has been cancelled.\n[animationCanceled](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#event-animationCanceled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAnimationCanceled {
+            #[doc = "Id of the animation that was cancelled."]
+            #[serde(rename = "id")]
+            pub id: String,
+        }
+        impl EventAnimationCanceled {
+            pub const IDENTIFIER: &'static str = "Animation.animationCanceled";
+        }
+        impl chromiumoxide_types::Method for EventAnimationCanceled {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAnimationCanceled {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Event for each animation that has been created.\n[animationCreated](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#event-animationCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAnimationCreated {
+            #[doc = "Id of the animation that was created."]
+            #[serde(rename = "id")]
+            pub id: String,
+        }
+        impl EventAnimationCreated {
+            pub const IDENTIFIER: &'static str = "Animation.animationCreated";
+        }
+        impl chromiumoxide_types::Method for EventAnimationCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAnimationCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Event for animation that has been started.\n[animationStarted](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#event-animationStarted)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAnimationStarted {
+            #[doc = "Animation that was started."]
+            #[serde(rename = "animation")]
+            pub animation: Animation,
+        }
+        impl EventAnimationStarted {
+            pub const IDENTIFIER: &'static str = "Animation.animationStarted";
+        }
+        impl chromiumoxide_types::Method for EventAnimationStarted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAnimationStarted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Event for animation that has been updated.\n[animationUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Animation/#event-animationUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAnimationUpdated {
+            #[doc = "Animation that was updated."]
+            #[serde(rename = "animation")]
+            pub animation: Animation,
+        }
+        impl EventAnimationUpdated {
+            pub const IDENTIFIER: &'static str = "Animation.animationUpdated";
+        }
+        impl chromiumoxide_types::Method for EventAnimationUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAnimationUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "Audits domain allows investigation of page violations and possible improvements."]
+    pub mod audits {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Information about a cookie that is affected by an inspector issue.\n[AffectedCookie](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-AffectedCookie)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AffectedCookie {
+            #[doc = "The following three properties uniquely identify a cookie"]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "path")]
+            pub path: String,
+            #[serde(rename = "domain")]
+            pub domain: String,
+        }
+        impl AffectedCookie {
+            pub fn new(
+                name: impl Into<String>,
+                path: impl Into<String>,
+                domain: impl Into<String>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    path: path.into(),
+                    domain: domain.into(),
+                }
+            }
+        }
+        impl AffectedCookie {
+            pub fn builder() -> AffectedCookieBuilder {
+                AffectedCookieBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AffectedCookieBuilder {
+            name: Option<String>,
+            path: Option<String>,
+            domain: Option<String>,
+        }
+        impl AffectedCookieBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn path(mut self, path: impl Into<String>) -> Self {
+                self.path = Some(path.into());
+                self
+            }
+            pub fn domain(mut self, domain: impl Into<String>) -> Self {
+                self.domain = Some(domain.into());
+                self
+            }
+            pub fn build(self) -> Result<AffectedCookie, String> {
+                Ok(AffectedCookie {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    path: self.path.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(path))
+                    })?,
+                    domain: self.domain.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(domain))
+                    })?,
+                })
+            }
+        }
+        impl AffectedCookie {
+            pub const IDENTIFIER: &'static str = "Audits.AffectedCookie";
+        }
+        #[doc = "Information about a request that is affected by an inspector issue.\n[AffectedRequest](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-AffectedRequest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AffectedRequest {
+            #[doc = "The unique request id."]
+            #[serde(rename = "requestId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request_id: Option<super::network::RequestId>,
+            #[serde(rename = "url")]
+            pub url: String,
+        }
+        impl AffectedRequest {
+            pub fn new(url: impl Into<String>) -> Self {
+                Self {
+                    url: url.into(),
+                    request_id: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for AffectedRequest {
+            fn from(url: T) -> Self {
+                AffectedRequest::new(url)
+            }
+        }
+        impl AffectedRequest {
+            pub fn builder() -> AffectedRequestBuilder {
+                AffectedRequestBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AffectedRequestBuilder {
+            request_id: Option<super::network::RequestId>,
+            url: Option<String>,
+        }
+        impl AffectedRequestBuilder {
+            pub fn request_id(mut self, request_id: impl Into<super::network::RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn build(self) -> Result<AffectedRequest, String> {
+                Ok(AffectedRequest {
+                    request_id: self.request_id,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                })
+            }
+        }
+        impl AffectedRequest {
+            pub const IDENTIFIER: &'static str = "Audits.AffectedRequest";
+        }
+        #[doc = "Information about the frame affected by an inspector issue.\n[AffectedFrame](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-AffectedFrame)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AffectedFrame {
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+        }
+        impl AffectedFrame {
+            pub fn new(frame_id: impl Into<super::page::FrameId>) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                }
+            }
+        }
+        impl AffectedFrame {
+            pub fn builder() -> AffectedFrameBuilder {
+                AffectedFrameBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AffectedFrameBuilder {
+            frame_id: Option<super::page::FrameId>,
+        }
+        impl AffectedFrameBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AffectedFrame, String> {
+                Ok(AffectedFrame {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                })
+            }
+        }
+        impl AffectedFrame {
+            pub const IDENTIFIER: &'static str = "Audits.AffectedFrame";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CookieExclusionReason {
+            #[serde(rename = "ExcludeSameSiteUnspecifiedTreatedAsLax")]
+            ExcludeSameSiteUnspecifiedTreatedAsLax,
+            #[serde(rename = "ExcludeSameSiteNoneInsecure")]
+            ExcludeSameSiteNoneInsecure,
+            #[serde(rename = "ExcludeSameSiteLax")]
+            ExcludeSameSiteLax,
+            #[serde(rename = "ExcludeSameSiteStrict")]
+            ExcludeSameSiteStrict,
+            #[serde(rename = "ExcludeInvalidSameParty")]
+            ExcludeInvalidSameParty,
+            #[serde(rename = "ExcludeSamePartyCrossPartyContext")]
+            ExcludeSamePartyCrossPartyContext,
+            #[serde(rename = "ExcludeDomainNonASCII")]
+            ExcludeDomainNonAscii,
+            #[serde(rename = "ExcludeThirdPartyCookieBlockedInFirstPartySet")]
+            ExcludeThirdPartyCookieBlockedInFirstPartySet,
+            #[serde(rename = "ExcludeThirdPartyPhaseout")]
+            ExcludeThirdPartyPhaseout,
+            #[serde(rename = "ExcludePortMismatch")]
+            ExcludePortMismatch,
+            #[serde(rename = "ExcludeSchemeMismatch")]
+            ExcludeSchemeMismatch,
+        }
+        impl AsRef<str> for CookieExclusionReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CookieExclusionReason::ExcludeSameSiteUnspecifiedTreatedAsLax => {
+                        "ExcludeSameSiteUnspecifiedTreatedAsLax"
+                    }
+                    CookieExclusionReason::ExcludeSameSiteNoneInsecure => {
+                        "ExcludeSameSiteNoneInsecure"
+                    }
+                    CookieExclusionReason::ExcludeSameSiteLax => "ExcludeSameSiteLax",
+                    CookieExclusionReason::ExcludeSameSiteStrict => "ExcludeSameSiteStrict",
+                    CookieExclusionReason::ExcludeInvalidSameParty => "ExcludeInvalidSameParty",
+                    CookieExclusionReason::ExcludeSamePartyCrossPartyContext => {
+                        "ExcludeSamePartyCrossPartyContext"
+                    }
+                    CookieExclusionReason::ExcludeDomainNonAscii => "ExcludeDomainNonASCII",
+                    CookieExclusionReason::ExcludeThirdPartyCookieBlockedInFirstPartySet => {
+                        "ExcludeThirdPartyCookieBlockedInFirstPartySet"
+                    }
+                    CookieExclusionReason::ExcludeThirdPartyPhaseout => "ExcludeThirdPartyPhaseout",
+                    CookieExclusionReason::ExcludePortMismatch => "ExcludePortMismatch",
+                    CookieExclusionReason::ExcludeSchemeMismatch => "ExcludeSchemeMismatch",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CookieExclusionReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "ExcludeSameSiteUnspecifiedTreatedAsLax"
+                    | "excludesamesiteunspecifiedtreatedaslax" => {
+                        Ok(CookieExclusionReason::ExcludeSameSiteUnspecifiedTreatedAsLax)
+                    }
+                    "ExcludeSameSiteNoneInsecure" | "excludesamesitenoneinsecure" => {
+                        Ok(CookieExclusionReason::ExcludeSameSiteNoneInsecure)
+                    }
+                    "ExcludeSameSiteLax" | "excludesamesitelax" => {
+                        Ok(CookieExclusionReason::ExcludeSameSiteLax)
+                    }
+                    "ExcludeSameSiteStrict" | "excludesamesitestrict" => {
+                        Ok(CookieExclusionReason::ExcludeSameSiteStrict)
+                    }
+                    "ExcludeInvalidSameParty" | "excludeinvalidsameparty" => {
+                        Ok(CookieExclusionReason::ExcludeInvalidSameParty)
+                    }
+                    "ExcludeSamePartyCrossPartyContext" | "excludesamepartycrosspartycontext" => {
+                        Ok(CookieExclusionReason::ExcludeSamePartyCrossPartyContext)
+                    }
+                    "ExcludeDomainNonASCII" | "ExcludeDomainNonAscii" | "excludedomainnonascii" => {
+                        Ok(CookieExclusionReason::ExcludeDomainNonAscii)
+                    }
+                    "ExcludeThirdPartyCookieBlockedInFirstPartySet"
+                    | "excludethirdpartycookieblockedinfirstpartyset" => {
+                        Ok(CookieExclusionReason::ExcludeThirdPartyCookieBlockedInFirstPartySet)
+                    }
+                    "ExcludeThirdPartyPhaseout" | "excludethirdpartyphaseout" => {
+                        Ok(CookieExclusionReason::ExcludeThirdPartyPhaseout)
+                    }
+                    "ExcludePortMismatch" | "excludeportmismatch" => {
+                        Ok(CookieExclusionReason::ExcludePortMismatch)
+                    }
+                    "ExcludeSchemeMismatch" | "excludeschememismatch" => {
+                        Ok(CookieExclusionReason::ExcludeSchemeMismatch)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CookieWarningReason {
+            #[serde(rename = "WarnSameSiteUnspecifiedCrossSiteContext")]
+            WarnSameSiteUnspecifiedCrossSiteContext,
+            #[serde(rename = "WarnSameSiteNoneInsecure")]
+            WarnSameSiteNoneInsecure,
+            #[serde(rename = "WarnSameSiteUnspecifiedLaxAllowUnsafe")]
+            WarnSameSiteUnspecifiedLaxAllowUnsafe,
+            #[serde(rename = "WarnSameSiteStrictLaxDowngradeStrict")]
+            WarnSameSiteStrictLaxDowngradeStrict,
+            #[serde(rename = "WarnSameSiteStrictCrossDowngradeStrict")]
+            WarnSameSiteStrictCrossDowngradeStrict,
+            #[serde(rename = "WarnSameSiteStrictCrossDowngradeLax")]
+            WarnSameSiteStrictCrossDowngradeLax,
+            #[serde(rename = "WarnSameSiteLaxCrossDowngradeStrict")]
+            WarnSameSiteLaxCrossDowngradeStrict,
+            #[serde(rename = "WarnSameSiteLaxCrossDowngradeLax")]
+            WarnSameSiteLaxCrossDowngradeLax,
+            #[serde(rename = "WarnAttributeValueExceedsMaxSize")]
+            WarnAttributeValueExceedsMaxSize,
+            #[serde(rename = "WarnDomainNonASCII")]
+            WarnDomainNonAscii,
+            #[serde(rename = "WarnThirdPartyPhaseout")]
+            WarnThirdPartyPhaseout,
+            #[serde(rename = "WarnCrossSiteRedirectDowngradeChangesInclusion")]
+            WarnCrossSiteRedirectDowngradeChangesInclusion,
+            #[serde(rename = "WarnDeprecationTrialMetadata")]
+            WarnDeprecationTrialMetadata,
+            #[serde(rename = "WarnThirdPartyCookieHeuristic")]
+            WarnThirdPartyCookieHeuristic,
+        }
+        impl AsRef<str> for CookieWarningReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CookieWarningReason::WarnSameSiteUnspecifiedCrossSiteContext => {
+                        "WarnSameSiteUnspecifiedCrossSiteContext"
+                    }
+                    CookieWarningReason::WarnSameSiteNoneInsecure => "WarnSameSiteNoneInsecure",
+                    CookieWarningReason::WarnSameSiteUnspecifiedLaxAllowUnsafe => {
+                        "WarnSameSiteUnspecifiedLaxAllowUnsafe"
+                    }
+                    CookieWarningReason::WarnSameSiteStrictLaxDowngradeStrict => {
+                        "WarnSameSiteStrictLaxDowngradeStrict"
+                    }
+                    CookieWarningReason::WarnSameSiteStrictCrossDowngradeStrict => {
+                        "WarnSameSiteStrictCrossDowngradeStrict"
+                    }
+                    CookieWarningReason::WarnSameSiteStrictCrossDowngradeLax => {
+                        "WarnSameSiteStrictCrossDowngradeLax"
+                    }
+                    CookieWarningReason::WarnSameSiteLaxCrossDowngradeStrict => {
+                        "WarnSameSiteLaxCrossDowngradeStrict"
+                    }
+                    CookieWarningReason::WarnSameSiteLaxCrossDowngradeLax => {
+                        "WarnSameSiteLaxCrossDowngradeLax"
+                    }
+                    CookieWarningReason::WarnAttributeValueExceedsMaxSize => {
+                        "WarnAttributeValueExceedsMaxSize"
+                    }
+                    CookieWarningReason::WarnDomainNonAscii => "WarnDomainNonASCII",
+                    CookieWarningReason::WarnThirdPartyPhaseout => "WarnThirdPartyPhaseout",
+                    CookieWarningReason::WarnCrossSiteRedirectDowngradeChangesInclusion => {
+                        "WarnCrossSiteRedirectDowngradeChangesInclusion"
+                    }
+                    CookieWarningReason::WarnDeprecationTrialMetadata => {
+                        "WarnDeprecationTrialMetadata"
+                    }
+                    CookieWarningReason::WarnThirdPartyCookieHeuristic => {
+                        "WarnThirdPartyCookieHeuristic"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for CookieWarningReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "WarnSameSiteUnspecifiedCrossSiteContext"
+                    | "warnsamesiteunspecifiedcrosssitecontext" => {
+                        Ok(CookieWarningReason::WarnSameSiteUnspecifiedCrossSiteContext)
+                    }
+                    "WarnSameSiteNoneInsecure" | "warnsamesitenoneinsecure" => {
+                        Ok(CookieWarningReason::WarnSameSiteNoneInsecure)
+                    }
+                    "WarnSameSiteUnspecifiedLaxAllowUnsafe"
+                    | "warnsamesiteunspecifiedlaxallowunsafe" => {
+                        Ok(CookieWarningReason::WarnSameSiteUnspecifiedLaxAllowUnsafe)
+                    }
+                    "WarnSameSiteStrictLaxDowngradeStrict"
+                    | "warnsamesitestrictlaxdowngradestrict" => {
+                        Ok(CookieWarningReason::WarnSameSiteStrictLaxDowngradeStrict)
+                    }
+                    "WarnSameSiteStrictCrossDowngradeStrict"
+                    | "warnsamesitestrictcrossdowngradestrict" => {
+                        Ok(CookieWarningReason::WarnSameSiteStrictCrossDowngradeStrict)
+                    }
+                    "WarnSameSiteStrictCrossDowngradeLax"
+                    | "warnsamesitestrictcrossdowngradelax" => {
+                        Ok(CookieWarningReason::WarnSameSiteStrictCrossDowngradeLax)
+                    }
+                    "WarnSameSiteLaxCrossDowngradeStrict"
+                    | "warnsamesitelaxcrossdowngradestrict" => {
+                        Ok(CookieWarningReason::WarnSameSiteLaxCrossDowngradeStrict)
+                    }
+                    "WarnSameSiteLaxCrossDowngradeLax" | "warnsamesitelaxcrossdowngradelax" => {
+                        Ok(CookieWarningReason::WarnSameSiteLaxCrossDowngradeLax)
+                    }
+                    "WarnAttributeValueExceedsMaxSize" | "warnattributevalueexceedsmaxsize" => {
+                        Ok(CookieWarningReason::WarnAttributeValueExceedsMaxSize)
+                    }
+                    "WarnDomainNonASCII" | "WarnDomainNonAscii" | "warndomainnonascii" => {
+                        Ok(CookieWarningReason::WarnDomainNonAscii)
+                    }
+                    "WarnThirdPartyPhaseout" | "warnthirdpartyphaseout" => {
+                        Ok(CookieWarningReason::WarnThirdPartyPhaseout)
+                    }
+                    "WarnCrossSiteRedirectDowngradeChangesInclusion"
+                    | "warncrosssiteredirectdowngradechangesinclusion" => {
+                        Ok(CookieWarningReason::WarnCrossSiteRedirectDowngradeChangesInclusion)
+                    }
+                    "WarnDeprecationTrialMetadata" | "warndeprecationtrialmetadata" => {
+                        Ok(CookieWarningReason::WarnDeprecationTrialMetadata)
+                    }
+                    "WarnThirdPartyCookieHeuristic" | "warnthirdpartycookieheuristic" => {
+                        Ok(CookieWarningReason::WarnThirdPartyCookieHeuristic)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CookieOperation {
+            #[serde(rename = "SetCookie")]
+            SetCookie,
+            #[serde(rename = "ReadCookie")]
+            ReadCookie,
+        }
+        impl AsRef<str> for CookieOperation {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CookieOperation::SetCookie => "SetCookie",
+                    CookieOperation::ReadCookie => "ReadCookie",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CookieOperation {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "SetCookie" | "setcookie" => Ok(CookieOperation::SetCookie),
+                    "ReadCookie" | "readcookie" => Ok(CookieOperation::ReadCookie),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Represents the category of insight that a cookie issue falls under."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum InsightType {
+            #[doc = "Cookie domain has an entry in third-party cookie migration readiness\nlist:\nhttps://github.com/privacysandbox/privacy-sandbox-dev-support/blob/main/3pc-migration-readiness.md"]
+            #[serde(rename = "GitHubResource")]
+            GitHubResource,
+            #[doc = "Cookie is exempted due to a grace period:\nhttps://developers.google.com/privacy-sandbox/cookies/temporary-exceptions/grace-period"]
+            #[serde(rename = "GracePeriod")]
+            GracePeriod,
+            #[doc = "Cookie is exempted due a heuristics-based exemptiuon:\nhttps://developers.google.com/privacy-sandbox/cookies/temporary-exceptions/heuristics-based-exception"]
+            #[serde(rename = "Heuristics")]
+            Heuristics,
+        }
+        impl AsRef<str> for InsightType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    InsightType::GitHubResource => "GitHubResource",
+                    InsightType::GracePeriod => "GracePeriod",
+                    InsightType::Heuristics => "Heuristics",
+                }
+            }
+        }
+        impl ::std::str::FromStr for InsightType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "GitHubResource" | "githubresource" => Ok(InsightType::GitHubResource),
+                    "GracePeriod" | "graceperiod" => Ok(InsightType::GracePeriod),
+                    "Heuristics" | "heuristics" => Ok(InsightType::Heuristics),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Information about the suggested solution to a cookie issue.\n[CookieIssueInsight](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-CookieIssueInsight)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CookieIssueInsight {
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: InsightType,
+            #[doc = "Link to table entry in third-party cookie migration readiness list."]
+            #[serde(rename = "tableEntryUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub table_entry_url: Option<String>,
+        }
+        impl CookieIssueInsight {
+            pub fn new(r#type: impl Into<InsightType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    table_entry_url: None,
+                }
+            }
+        }
+        impl CookieIssueInsight {
+            pub fn builder() -> CookieIssueInsightBuilder {
+                CookieIssueInsightBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CookieIssueInsightBuilder {
+            r#type: Option<InsightType>,
+            table_entry_url: Option<String>,
+        }
+        impl CookieIssueInsightBuilder {
+            pub fn r#type(mut self, r#type: impl Into<InsightType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn table_entry_url(mut self, table_entry_url: impl Into<String>) -> Self {
+                self.table_entry_url = Some(table_entry_url.into());
+                self
+            }
+            pub fn build(self) -> Result<CookieIssueInsight, String> {
+                Ok(CookieIssueInsight {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    table_entry_url: self.table_entry_url,
+                })
+            }
+        }
+        impl CookieIssueInsight {
+            pub const IDENTIFIER: &'static str = "Audits.CookieIssueInsight";
+        }
+        #[doc = "This information is currently necessary, as the front-end has a difficult\ntime finding a specific cookie. With this, we can convey specific error\ninformation without the cookie.\n[CookieIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-CookieIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CookieIssueDetails {
+            #[doc = "If AffectedCookie is not set then rawCookieLine contains the raw\nSet-Cookie header string. This hints at a problem where the\ncookie line is syntactically or semantically malformed in a way\nthat no valid cookie could be created."]
+            #[serde(rename = "cookie")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cookie: Option<AffectedCookie>,
+            #[serde(rename = "rawCookieLine")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub raw_cookie_line: Option<String>,
+            #[serde(rename = "cookieWarningReasons")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub cookie_warning_reasons: Vec<CookieWarningReason>,
+            #[serde(rename = "cookieExclusionReasons")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub cookie_exclusion_reasons: Vec<CookieExclusionReason>,
+            #[doc = "Optionally identifies the site-for-cookies and the cookie url, which\nmay be used by the front-end as additional context."]
+            #[serde(rename = "operation")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub operation: CookieOperation,
+            #[serde(rename = "siteForCookies")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub site_for_cookies: Option<String>,
+            #[serde(rename = "cookieUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cookie_url: Option<String>,
+            #[serde(rename = "request")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request: Option<AffectedRequest>,
+            #[doc = "The recommended solution to the issue."]
+            #[serde(rename = "insight")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub insight: Option<CookieIssueInsight>,
+        }
+        impl CookieIssueDetails {
+            pub fn new(
+                cookie_warning_reasons: Vec<CookieWarningReason>,
+                cookie_exclusion_reasons: Vec<CookieExclusionReason>,
+                operation: impl Into<CookieOperation>,
+            ) -> Self {
+                Self {
+                    cookie_warning_reasons,
+                    cookie_exclusion_reasons,
+                    operation: operation.into(),
+                    cookie: None,
+                    raw_cookie_line: None,
+                    site_for_cookies: None,
+                    cookie_url: None,
+                    request: None,
+                    insight: None,
+                }
+            }
+        }
+        impl CookieIssueDetails {
+            pub fn builder() -> CookieIssueDetailsBuilder {
+                CookieIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CookieIssueDetailsBuilder {
+            cookie: Option<AffectedCookie>,
+            raw_cookie_line: Option<String>,
+            cookie_warning_reasons: Option<Vec<CookieWarningReason>>,
+            cookie_exclusion_reasons: Option<Vec<CookieExclusionReason>>,
+            operation: Option<CookieOperation>,
+            site_for_cookies: Option<String>,
+            cookie_url: Option<String>,
+            request: Option<AffectedRequest>,
+            insight: Option<CookieIssueInsight>,
+        }
+        impl CookieIssueDetailsBuilder {
+            pub fn cookie(mut self, cookie: impl Into<AffectedCookie>) -> Self {
+                self.cookie = Some(cookie.into());
+                self
+            }
+            pub fn raw_cookie_line(mut self, raw_cookie_line: impl Into<String>) -> Self {
+                self.raw_cookie_line = Some(raw_cookie_line.into());
+                self
+            }
+            pub fn cookie_warning_reason(
+                mut self,
+                cookie_warning_reason: impl Into<CookieWarningReason>,
+            ) -> Self {
+                let v = self.cookie_warning_reasons.get_or_insert(Vec::new());
+                v.push(cookie_warning_reason.into());
+                self
+            }
+            pub fn cookie_warning_reasons<I, S>(mut self, cookie_warning_reasons: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CookieWarningReason>,
+            {
+                let v = self.cookie_warning_reasons.get_or_insert(Vec::new());
+                for val in cookie_warning_reasons {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn cookie_exclusion_reason(
+                mut self,
+                cookie_exclusion_reason: impl Into<CookieExclusionReason>,
+            ) -> Self {
+                let v = self.cookie_exclusion_reasons.get_or_insert(Vec::new());
+                v.push(cookie_exclusion_reason.into());
+                self
+            }
+            pub fn cookie_exclusion_reasons<I, S>(mut self, cookie_exclusion_reasons: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CookieExclusionReason>,
+            {
+                let v = self.cookie_exclusion_reasons.get_or_insert(Vec::new());
+                for val in cookie_exclusion_reasons {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn operation(mut self, operation: impl Into<CookieOperation>) -> Self {
+                self.operation = Some(operation.into());
+                self
+            }
+            pub fn site_for_cookies(mut self, site_for_cookies: impl Into<String>) -> Self {
+                self.site_for_cookies = Some(site_for_cookies.into());
+                self
+            }
+            pub fn cookie_url(mut self, cookie_url: impl Into<String>) -> Self {
+                self.cookie_url = Some(cookie_url.into());
+                self
+            }
+            pub fn request(mut self, request: impl Into<AffectedRequest>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn insight(mut self, insight: impl Into<CookieIssueInsight>) -> Self {
+                self.insight = Some(insight.into());
+                self
+            }
+            pub fn build(self) -> Result<CookieIssueDetails, String> {
+                Ok(CookieIssueDetails {
+                    cookie: self.cookie,
+                    raw_cookie_line: self.raw_cookie_line,
+                    cookie_warning_reasons: self.cookie_warning_reasons.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(cookie_warning_reasons)
+                        )
+                    })?,
+                    cookie_exclusion_reasons: self.cookie_exclusion_reasons.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(cookie_exclusion_reasons)
+                        )
+                    })?,
+                    operation: self.operation.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(operation))
+                    })?,
+                    site_for_cookies: self.site_for_cookies,
+                    cookie_url: self.cookie_url,
+                    request: self.request,
+                    insight: self.insight,
+                })
+            }
+        }
+        impl CookieIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.CookieIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum MixedContentResolutionStatus {
+            #[serde(rename = "MixedContentBlocked")]
+            MixedContentBlocked,
+            #[serde(rename = "MixedContentAutomaticallyUpgraded")]
+            MixedContentAutomaticallyUpgraded,
+            #[serde(rename = "MixedContentWarning")]
+            MixedContentWarning,
+        }
+        impl AsRef<str> for MixedContentResolutionStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    MixedContentResolutionStatus::MixedContentBlocked => "MixedContentBlocked",
+                    MixedContentResolutionStatus::MixedContentAutomaticallyUpgraded => {
+                        "MixedContentAutomaticallyUpgraded"
+                    }
+                    MixedContentResolutionStatus::MixedContentWarning => "MixedContentWarning",
+                }
+            }
+        }
+        impl ::std::str::FromStr for MixedContentResolutionStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "MixedContentBlocked" | "mixedcontentblocked" => {
+                        Ok(MixedContentResolutionStatus::MixedContentBlocked)
+                    }
+                    "MixedContentAutomaticallyUpgraded" | "mixedcontentautomaticallyupgraded" => {
+                        Ok(MixedContentResolutionStatus::MixedContentAutomaticallyUpgraded)
+                    }
+                    "MixedContentWarning" | "mixedcontentwarning" => {
+                        Ok(MixedContentResolutionStatus::MixedContentWarning)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum MixedContentResourceType {
+            #[serde(rename = "AttributionSrc")]
+            AttributionSrc,
+            #[serde(rename = "Audio")]
+            Audio,
+            #[serde(rename = "Beacon")]
+            Beacon,
+            #[serde(rename = "CSPReport")]
+            CspReport,
+            #[serde(rename = "Download")]
+            Download,
+            #[serde(rename = "EventSource")]
+            EventSource,
+            #[serde(rename = "Favicon")]
+            Favicon,
+            #[serde(rename = "Font")]
+            Font,
+            #[serde(rename = "Form")]
+            Form,
+            #[serde(rename = "Frame")]
+            Frame,
+            #[serde(rename = "Image")]
+            Image,
+            #[serde(rename = "Import")]
+            Import,
+            #[serde(rename = "JSON")]
+            Json,
+            #[serde(rename = "Manifest")]
+            Manifest,
+            #[serde(rename = "Ping")]
+            Ping,
+            #[serde(rename = "PluginData")]
+            PluginData,
+            #[serde(rename = "PluginResource")]
+            PluginResource,
+            #[serde(rename = "Prefetch")]
+            Prefetch,
+            #[serde(rename = "Resource")]
+            Resource,
+            #[serde(rename = "Script")]
+            Script,
+            #[serde(rename = "ServiceWorker")]
+            ServiceWorker,
+            #[serde(rename = "SharedWorker")]
+            SharedWorker,
+            #[serde(rename = "SpeculationRules")]
+            SpeculationRules,
+            #[serde(rename = "Stylesheet")]
+            Stylesheet,
+            #[serde(rename = "Track")]
+            Track,
+            #[serde(rename = "Video")]
+            Video,
+            #[serde(rename = "Worker")]
+            Worker,
+            #[serde(rename = "XMLHttpRequest")]
+            XmlHttpRequest,
+            #[serde(rename = "XSLT")]
+            Xslt,
+        }
+        impl AsRef<str> for MixedContentResourceType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    MixedContentResourceType::AttributionSrc => "AttributionSrc",
+                    MixedContentResourceType::Audio => "Audio",
+                    MixedContentResourceType::Beacon => "Beacon",
+                    MixedContentResourceType::CspReport => "CSPReport",
+                    MixedContentResourceType::Download => "Download",
+                    MixedContentResourceType::EventSource => "EventSource",
+                    MixedContentResourceType::Favicon => "Favicon",
+                    MixedContentResourceType::Font => "Font",
+                    MixedContentResourceType::Form => "Form",
+                    MixedContentResourceType::Frame => "Frame",
+                    MixedContentResourceType::Image => "Image",
+                    MixedContentResourceType::Import => "Import",
+                    MixedContentResourceType::Json => "JSON",
+                    MixedContentResourceType::Manifest => "Manifest",
+                    MixedContentResourceType::Ping => "Ping",
+                    MixedContentResourceType::PluginData => "PluginData",
+                    MixedContentResourceType::PluginResource => "PluginResource",
+                    MixedContentResourceType::Prefetch => "Prefetch",
+                    MixedContentResourceType::Resource => "Resource",
+                    MixedContentResourceType::Script => "Script",
+                    MixedContentResourceType::ServiceWorker => "ServiceWorker",
+                    MixedContentResourceType::SharedWorker => "SharedWorker",
+                    MixedContentResourceType::SpeculationRules => "SpeculationRules",
+                    MixedContentResourceType::Stylesheet => "Stylesheet",
+                    MixedContentResourceType::Track => "Track",
+                    MixedContentResourceType::Video => "Video",
+                    MixedContentResourceType::Worker => "Worker",
+                    MixedContentResourceType::XmlHttpRequest => "XMLHttpRequest",
+                    MixedContentResourceType::Xslt => "XSLT",
+                }
+            }
+        }
+        impl ::std::str::FromStr for MixedContentResourceType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "AttributionSrc" | "attributionsrc" => {
+                        Ok(MixedContentResourceType::AttributionSrc)
+                    }
+                    "Audio" | "audio" => Ok(MixedContentResourceType::Audio),
+                    "Beacon" | "beacon" => Ok(MixedContentResourceType::Beacon),
+                    "CSPReport" | "CspReport" | "cspreport" => {
+                        Ok(MixedContentResourceType::CspReport)
+                    }
+                    "Download" | "download" => Ok(MixedContentResourceType::Download),
+                    "EventSource" | "eventsource" => Ok(MixedContentResourceType::EventSource),
+                    "Favicon" | "favicon" => Ok(MixedContentResourceType::Favicon),
+                    "Font" | "font" => Ok(MixedContentResourceType::Font),
+                    "Form" | "form" => Ok(MixedContentResourceType::Form),
+                    "Frame" | "frame" => Ok(MixedContentResourceType::Frame),
+                    "Image" | "image" => Ok(MixedContentResourceType::Image),
+                    "Import" | "import" => Ok(MixedContentResourceType::Import),
+                    "JSON" | "Json" | "json" => Ok(MixedContentResourceType::Json),
+                    "Manifest" | "manifest" => Ok(MixedContentResourceType::Manifest),
+                    "Ping" | "ping" => Ok(MixedContentResourceType::Ping),
+                    "PluginData" | "plugindata" => Ok(MixedContentResourceType::PluginData),
+                    "PluginResource" | "pluginresource" => {
+                        Ok(MixedContentResourceType::PluginResource)
+                    }
+                    "Prefetch" | "prefetch" => Ok(MixedContentResourceType::Prefetch),
+                    "Resource" | "resource" => Ok(MixedContentResourceType::Resource),
+                    "Script" | "script" => Ok(MixedContentResourceType::Script),
+                    "ServiceWorker" | "serviceworker" => {
+                        Ok(MixedContentResourceType::ServiceWorker)
+                    }
+                    "SharedWorker" | "sharedworker" => Ok(MixedContentResourceType::SharedWorker),
+                    "SpeculationRules" | "speculationrules" => {
+                        Ok(MixedContentResourceType::SpeculationRules)
+                    }
+                    "Stylesheet" | "stylesheet" => Ok(MixedContentResourceType::Stylesheet),
+                    "Track" | "track" => Ok(MixedContentResourceType::Track),
+                    "Video" | "video" => Ok(MixedContentResourceType::Video),
+                    "Worker" | "worker" => Ok(MixedContentResourceType::Worker),
+                    "XMLHttpRequest" | "XmlHttpRequest" | "xmlhttprequest" => {
+                        Ok(MixedContentResourceType::XmlHttpRequest)
+                    }
+                    "XSLT" | "Xslt" | "xslt" => Ok(MixedContentResourceType::Xslt),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct MixedContentIssueDetails {
+            #[doc = "The type of resource causing the mixed content issue (css, js, iframe,\nform,...). Marked as optional because it is mapped to from\nblink::mojom::RequestContextType, which will be replaced\nby network::mojom::RequestDestination"]
+            #[serde(rename = "resourceType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub resource_type: Option<MixedContentResourceType>,
+            #[doc = "The way the mixed content issue is being resolved."]
+            #[serde(rename = "resolutionStatus")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub resolution_status: MixedContentResolutionStatus,
+            #[doc = "The unsafe http url causing the mixed content issue."]
+            #[serde(rename = "insecureURL")]
+            pub insecure_url: String,
+            #[doc = "The url responsible for the call to an unsafe url."]
+            #[serde(rename = "mainResourceURL")]
+            pub main_resource_url: String,
+            #[doc = "The mixed content request.\nDoes not always exist (e.g. for unsafe form submission urls)."]
+            #[serde(rename = "request")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request: Option<AffectedRequest>,
+            #[doc = "Optional because not every mixed content issue is necessarily linked to a frame."]
+            #[serde(rename = "frame")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame: Option<AffectedFrame>,
+        }
+        impl MixedContentIssueDetails {
+            pub fn new(
+                resolution_status: impl Into<MixedContentResolutionStatus>,
+                insecure_url: impl Into<String>,
+                main_resource_url: impl Into<String>,
+            ) -> Self {
+                Self {
+                    resolution_status: resolution_status.into(),
+                    insecure_url: insecure_url.into(),
+                    main_resource_url: main_resource_url.into(),
+                    resource_type: None,
+                    request: None,
+                    frame: None,
+                }
+            }
+        }
+        impl MixedContentIssueDetails {
+            pub fn builder() -> MixedContentIssueDetailsBuilder {
+                MixedContentIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct MixedContentIssueDetailsBuilder {
+            resource_type: Option<MixedContentResourceType>,
+            resolution_status: Option<MixedContentResolutionStatus>,
+            insecure_url: Option<String>,
+            main_resource_url: Option<String>,
+            request: Option<AffectedRequest>,
+            frame: Option<AffectedFrame>,
+        }
+        impl MixedContentIssueDetailsBuilder {
+            pub fn resource_type(
+                mut self,
+                resource_type: impl Into<MixedContentResourceType>,
+            ) -> Self {
+                self.resource_type = Some(resource_type.into());
+                self
+            }
+            pub fn resolution_status(
+                mut self,
+                resolution_status: impl Into<MixedContentResolutionStatus>,
+            ) -> Self {
+                self.resolution_status = Some(resolution_status.into());
+                self
+            }
+            pub fn insecure_url(mut self, insecure_url: impl Into<String>) -> Self {
+                self.insecure_url = Some(insecure_url.into());
+                self
+            }
+            pub fn main_resource_url(mut self, main_resource_url: impl Into<String>) -> Self {
+                self.main_resource_url = Some(main_resource_url.into());
+                self
+            }
+            pub fn request(mut self, request: impl Into<AffectedRequest>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn frame(mut self, frame: impl Into<AffectedFrame>) -> Self {
+                self.frame = Some(frame.into());
+                self
+            }
+            pub fn build(self) -> Result<MixedContentIssueDetails, String> {
+                Ok(MixedContentIssueDetails {
+                    resource_type: self.resource_type,
+                    resolution_status: self.resolution_status.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(resolution_status)
+                        )
+                    })?,
+                    insecure_url: self.insecure_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(insecure_url))
+                    })?,
+                    main_resource_url: self.main_resource_url.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(main_resource_url)
+                        )
+                    })?,
+                    request: self.request,
+                    frame: self.frame,
+                })
+            }
+        }
+        impl MixedContentIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.MixedContentIssueDetails";
+        }
+        #[doc = "Enum indicating the reason a response has been blocked. These reasons are\nrefinements of the net error BLOCKED_BY_RESPONSE."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum BlockedByResponseReason {
+            #[serde(rename = "CoepFrameResourceNeedsCoepHeader")]
+            CoepFrameResourceNeedsCoepHeader,
+            #[serde(rename = "CoopSandboxedIFrameCannotNavigateToCoopPage")]
+            CoopSandboxedIFrameCannotNavigateToCoopPage,
+            #[serde(rename = "CorpNotSameOrigin")]
+            CorpNotSameOrigin,
+            #[serde(rename = "CorpNotSameOriginAfterDefaultedToSameOriginByCoep")]
+            CorpNotSameOriginAfterDefaultedToSameOriginByCoep,
+            #[serde(rename = "CorpNotSameOriginAfterDefaultedToSameOriginByDip")]
+            CorpNotSameOriginAfterDefaultedToSameOriginByDip,
+            #[serde(rename = "CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip")]
+            CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip,
+            #[serde(rename = "CorpNotSameSite")]
+            CorpNotSameSite,
+            #[serde(rename = "SRIMessageSignatureMismatch")]
+            SriMessageSignatureMismatch,
+        }
+        impl AsRef<str> for BlockedByResponseReason {
+            fn as_ref(&self) -> &str {
+                match self { BlockedByResponseReason :: CoepFrameResourceNeedsCoepHeader => "CoepFrameResourceNeedsCoepHeader" , BlockedByResponseReason :: CoopSandboxedIFrameCannotNavigateToCoopPage => "CoopSandboxedIFrameCannotNavigateToCoopPage" , BlockedByResponseReason :: CorpNotSameOrigin => "CorpNotSameOrigin" , BlockedByResponseReason :: CorpNotSameOriginAfterDefaultedToSameOriginByCoep => "CorpNotSameOriginAfterDefaultedToSameOriginByCoep" , BlockedByResponseReason :: CorpNotSameOriginAfterDefaultedToSameOriginByDip => "CorpNotSameOriginAfterDefaultedToSameOriginByDip" , BlockedByResponseReason :: CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip => "CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip" , BlockedByResponseReason :: CorpNotSameSite => "CorpNotSameSite" , BlockedByResponseReason :: SriMessageSignatureMismatch => "SRIMessageSignatureMismatch" }
+            }
+        }
+        impl ::std::str::FromStr for BlockedByResponseReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s { "CoepFrameResourceNeedsCoepHeader" | "coepframeresourceneedscoepheader" => Ok (BlockedByResponseReason :: CoepFrameResourceNeedsCoepHeader) , "CoopSandboxedIFrameCannotNavigateToCoopPage" | "coopsandboxediframecannotnavigatetocooppage" => Ok (BlockedByResponseReason :: CoopSandboxedIFrameCannotNavigateToCoopPage) , "CorpNotSameOrigin" | "corpnotsameorigin" => Ok (BlockedByResponseReason :: CorpNotSameOrigin) , "CorpNotSameOriginAfterDefaultedToSameOriginByCoep" | "corpnotsameoriginafterdefaultedtosameoriginbycoep" => Ok (BlockedByResponseReason :: CorpNotSameOriginAfterDefaultedToSameOriginByCoep) , "CorpNotSameOriginAfterDefaultedToSameOriginByDip" | "corpnotsameoriginafterdefaultedtosameoriginbydip" => Ok (BlockedByResponseReason :: CorpNotSameOriginAfterDefaultedToSameOriginByDip) , "CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip" | "corpnotsameoriginafterdefaultedtosameoriginbycoepanddip" => Ok (BlockedByResponseReason :: CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip) , "CorpNotSameSite" | "corpnotsamesite" => Ok (BlockedByResponseReason :: CorpNotSameSite) , "SRIMessageSignatureMismatch" | "SriMessageSignatureMismatch" | "srimessagesignaturemismatch" => Ok (BlockedByResponseReason :: SriMessageSignatureMismatch) , _ => Err (s . to_string ()) }
+            }
+        }
+        #[doc = "Details for a request that has been blocked with the BLOCKED_BY_RESPONSE\ncode. Currently only used for COEP/COOP, but may be extended to include\nsome CSP errors in the future.\n[BlockedByResponseIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-BlockedByResponseIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BlockedByResponseIssueDetails {
+            #[serde(rename = "request")]
+            pub request: AffectedRequest,
+            #[serde(rename = "parentFrame")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent_frame: Option<AffectedFrame>,
+            #[serde(rename = "blockedFrame")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub blocked_frame: Option<AffectedFrame>,
+            #[serde(rename = "reason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub reason: BlockedByResponseReason,
+        }
+        impl BlockedByResponseIssueDetails {
+            pub fn new(
+                request: impl Into<AffectedRequest>,
+                reason: impl Into<BlockedByResponseReason>,
+            ) -> Self {
+                Self {
+                    request: request.into(),
+                    reason: reason.into(),
+                    parent_frame: None,
+                    blocked_frame: None,
+                }
+            }
+        }
+        impl BlockedByResponseIssueDetails {
+            pub fn builder() -> BlockedByResponseIssueDetailsBuilder {
+                BlockedByResponseIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BlockedByResponseIssueDetailsBuilder {
+            request: Option<AffectedRequest>,
+            parent_frame: Option<AffectedFrame>,
+            blocked_frame: Option<AffectedFrame>,
+            reason: Option<BlockedByResponseReason>,
+        }
+        impl BlockedByResponseIssueDetailsBuilder {
+            pub fn request(mut self, request: impl Into<AffectedRequest>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn parent_frame(mut self, parent_frame: impl Into<AffectedFrame>) -> Self {
+                self.parent_frame = Some(parent_frame.into());
+                self
+            }
+            pub fn blocked_frame(mut self, blocked_frame: impl Into<AffectedFrame>) -> Self {
+                self.blocked_frame = Some(blocked_frame.into());
+                self
+            }
+            pub fn reason(mut self, reason: impl Into<BlockedByResponseReason>) -> Self {
+                self.reason = Some(reason.into());
+                self
+            }
+            pub fn build(self) -> Result<BlockedByResponseIssueDetails, String> {
+                Ok(BlockedByResponseIssueDetails {
+                    request: self.request.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request))
+                    })?,
+                    parent_frame: self.parent_frame,
+                    blocked_frame: self.blocked_frame,
+                    reason: self.reason.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(reason))
+                    })?,
+                })
+            }
+        }
+        impl BlockedByResponseIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.BlockedByResponseIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum HeavyAdResolutionStatus {
+            #[serde(rename = "HeavyAdBlocked")]
+            HeavyAdBlocked,
+            #[serde(rename = "HeavyAdWarning")]
+            HeavyAdWarning,
+        }
+        impl AsRef<str> for HeavyAdResolutionStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    HeavyAdResolutionStatus::HeavyAdBlocked => "HeavyAdBlocked",
+                    HeavyAdResolutionStatus::HeavyAdWarning => "HeavyAdWarning",
+                }
+            }
+        }
+        impl ::std::str::FromStr for HeavyAdResolutionStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "HeavyAdBlocked" | "heavyadblocked" => {
+                        Ok(HeavyAdResolutionStatus::HeavyAdBlocked)
+                    }
+                    "HeavyAdWarning" | "heavyadwarning" => {
+                        Ok(HeavyAdResolutionStatus::HeavyAdWarning)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum HeavyAdReason {
+            #[serde(rename = "NetworkTotalLimit")]
+            NetworkTotalLimit,
+            #[serde(rename = "CpuTotalLimit")]
+            CpuTotalLimit,
+            #[serde(rename = "CpuPeakLimit")]
+            CpuPeakLimit,
+        }
+        impl AsRef<str> for HeavyAdReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    HeavyAdReason::NetworkTotalLimit => "NetworkTotalLimit",
+                    HeavyAdReason::CpuTotalLimit => "CpuTotalLimit",
+                    HeavyAdReason::CpuPeakLimit => "CpuPeakLimit",
+                }
+            }
+        }
+        impl ::std::str::FromStr for HeavyAdReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "NetworkTotalLimit" | "networktotallimit" => {
+                        Ok(HeavyAdReason::NetworkTotalLimit)
+                    }
+                    "CpuTotalLimit" | "cputotallimit" => Ok(HeavyAdReason::CpuTotalLimit),
+                    "CpuPeakLimit" | "cpupeaklimit" => Ok(HeavyAdReason::CpuPeakLimit),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct HeavyAdIssueDetails {
+            #[doc = "The resolution status, either blocking the content or warning."]
+            #[serde(rename = "resolution")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub resolution: HeavyAdResolutionStatus,
+            #[doc = "The reason the ad was blocked, total network or cpu or peak cpu."]
+            #[serde(rename = "reason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub reason: HeavyAdReason,
+            #[doc = "The frame that was blocked."]
+            #[serde(rename = "frame")]
+            pub frame: AffectedFrame,
+        }
+        impl HeavyAdIssueDetails {
+            pub fn new(
+                resolution: impl Into<HeavyAdResolutionStatus>,
+                reason: impl Into<HeavyAdReason>,
+                frame: impl Into<AffectedFrame>,
+            ) -> Self {
+                Self {
+                    resolution: resolution.into(),
+                    reason: reason.into(),
+                    frame: frame.into(),
+                }
+            }
+        }
+        impl HeavyAdIssueDetails {
+            pub fn builder() -> HeavyAdIssueDetailsBuilder {
+                HeavyAdIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HeavyAdIssueDetailsBuilder {
+            resolution: Option<HeavyAdResolutionStatus>,
+            reason: Option<HeavyAdReason>,
+            frame: Option<AffectedFrame>,
+        }
+        impl HeavyAdIssueDetailsBuilder {
+            pub fn resolution(mut self, resolution: impl Into<HeavyAdResolutionStatus>) -> Self {
+                self.resolution = Some(resolution.into());
+                self
+            }
+            pub fn reason(mut self, reason: impl Into<HeavyAdReason>) -> Self {
+                self.reason = Some(reason.into());
+                self
+            }
+            pub fn frame(mut self, frame: impl Into<AffectedFrame>) -> Self {
+                self.frame = Some(frame.into());
+                self
+            }
+            pub fn build(self) -> Result<HeavyAdIssueDetails, String> {
+                Ok(HeavyAdIssueDetails {
+                    resolution: self.resolution.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(resolution))
+                    })?,
+                    reason: self.reason.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(reason))
+                    })?,
+                    frame: self.frame.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame))
+                    })?,
+                })
+            }
+        }
+        impl HeavyAdIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.HeavyAdIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ContentSecurityPolicyViolationType {
+            #[serde(rename = "kInlineViolation")]
+            KInlineViolation,
+            #[serde(rename = "kEvalViolation")]
+            KEvalViolation,
+            #[serde(rename = "kURLViolation")]
+            KUrlViolation,
+            #[serde(rename = "kSRIViolation")]
+            KSriViolation,
+            #[serde(rename = "kTrustedTypesSinkViolation")]
+            KTrustedTypesSinkViolation,
+            #[serde(rename = "kTrustedTypesPolicyViolation")]
+            KTrustedTypesPolicyViolation,
+            #[serde(rename = "kWasmEvalViolation")]
+            KWasmEvalViolation,
+        }
+        impl AsRef<str> for ContentSecurityPolicyViolationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ContentSecurityPolicyViolationType::KInlineViolation => "kInlineViolation",
+                    ContentSecurityPolicyViolationType::KEvalViolation => "kEvalViolation",
+                    ContentSecurityPolicyViolationType::KUrlViolation => "kURLViolation",
+                    ContentSecurityPolicyViolationType::KSriViolation => "kSRIViolation",
+                    ContentSecurityPolicyViolationType::KTrustedTypesSinkViolation => {
+                        "kTrustedTypesSinkViolation"
+                    }
+                    ContentSecurityPolicyViolationType::KTrustedTypesPolicyViolation => {
+                        "kTrustedTypesPolicyViolation"
+                    }
+                    ContentSecurityPolicyViolationType::KWasmEvalViolation => "kWasmEvalViolation",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ContentSecurityPolicyViolationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "kInlineViolation" | "KInlineViolation" | "kinlineviolation" => {
+                        Ok(ContentSecurityPolicyViolationType::KInlineViolation)
+                    }
+                    "kEvalViolation" | "KEvalViolation" | "kevalviolation" => {
+                        Ok(ContentSecurityPolicyViolationType::KEvalViolation)
+                    }
+                    "kURLViolation" | "KUrlViolation" | "kurlviolation" => {
+                        Ok(ContentSecurityPolicyViolationType::KUrlViolation)
+                    }
+                    "kSRIViolation" | "KSriViolation" | "ksriviolation" => {
+                        Ok(ContentSecurityPolicyViolationType::KSriViolation)
+                    }
+                    "kTrustedTypesSinkViolation"
+                    | "KTrustedTypesSinkViolation"
+                    | "ktrustedtypessinkviolation" => {
+                        Ok(ContentSecurityPolicyViolationType::KTrustedTypesSinkViolation)
+                    }
+                    "kTrustedTypesPolicyViolation"
+                    | "KTrustedTypesPolicyViolation"
+                    | "ktrustedtypespolicyviolation" => {
+                        Ok(ContentSecurityPolicyViolationType::KTrustedTypesPolicyViolation)
+                    }
+                    "kWasmEvalViolation" | "KWasmEvalViolation" | "kwasmevalviolation" => {
+                        Ok(ContentSecurityPolicyViolationType::KWasmEvalViolation)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SourceCodeLocation {
+            #[serde(rename = "scriptId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub script_id: Option<super::super::js_protocol::runtime::ScriptId>,
+            #[serde(rename = "url")]
+            pub url: String,
+            #[serde(rename = "lineNumber")]
+            pub line_number: i64,
+            #[serde(rename = "columnNumber")]
+            pub column_number: i64,
+        }
+        impl SourceCodeLocation {
+            pub fn new(
+                url: impl Into<String>,
+                line_number: impl Into<i64>,
+                column_number: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    url: url.into(),
+                    line_number: line_number.into(),
+                    column_number: column_number.into(),
+                    script_id: None,
+                }
+            }
+        }
+        impl SourceCodeLocation {
+            pub fn builder() -> SourceCodeLocationBuilder {
+                SourceCodeLocationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SourceCodeLocationBuilder {
+            script_id: Option<super::super::js_protocol::runtime::ScriptId>,
+            url: Option<String>,
+            line_number: Option<i64>,
+            column_number: Option<i64>,
+        }
+        impl SourceCodeLocationBuilder {
+            pub fn script_id(
+                mut self,
+                script_id: impl Into<super::super::js_protocol::runtime::ScriptId>,
+            ) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<i64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn build(self) -> Result<SourceCodeLocation, String> {
+                Ok(SourceCodeLocation {
+                    script_id: self.script_id,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    column_number: self.column_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(column_number))
+                    })?,
+                })
+            }
+        }
+        impl SourceCodeLocation {
+            pub const IDENTIFIER: &'static str = "Audits.SourceCodeLocation";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ContentSecurityPolicyIssueDetails {
+            #[doc = "The url not included in allowed sources."]
+            #[serde(rename = "blockedURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub blocked_url: Option<String>,
+            #[doc = "Specific directive that is violated, causing the CSP issue."]
+            #[serde(rename = "violatedDirective")]
+            pub violated_directive: String,
+            #[serde(rename = "isReportOnly")]
+            pub is_report_only: bool,
+            #[serde(rename = "contentSecurityPolicyViolationType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub content_security_policy_violation_type: ContentSecurityPolicyViolationType,
+            #[serde(rename = "frameAncestor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_ancestor: Option<AffectedFrame>,
+            #[serde(rename = "sourceCodeLocation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_code_location: Option<SourceCodeLocation>,
+            #[serde(rename = "violatingNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub violating_node_id: Option<super::dom::BackendNodeId>,
+        }
+        impl ContentSecurityPolicyIssueDetails {
+            pub fn new(
+                violated_directive: impl Into<String>,
+                is_report_only: impl Into<bool>,
+                content_security_policy_violation_type: impl Into<ContentSecurityPolicyViolationType>,
+            ) -> Self {
+                Self {
+                    violated_directive: violated_directive.into(),
+                    is_report_only: is_report_only.into(),
+                    content_security_policy_violation_type: content_security_policy_violation_type
+                        .into(),
+                    blocked_url: None,
+                    frame_ancestor: None,
+                    source_code_location: None,
+                    violating_node_id: None,
+                }
+            }
+        }
+        impl ContentSecurityPolicyIssueDetails {
+            pub fn builder() -> ContentSecurityPolicyIssueDetailsBuilder {
+                ContentSecurityPolicyIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ContentSecurityPolicyIssueDetailsBuilder {
+            blocked_url: Option<String>,
+            violated_directive: Option<String>,
+            is_report_only: Option<bool>,
+            content_security_policy_violation_type: Option<ContentSecurityPolicyViolationType>,
+            frame_ancestor: Option<AffectedFrame>,
+            source_code_location: Option<SourceCodeLocation>,
+            violating_node_id: Option<super::dom::BackendNodeId>,
+        }
+        impl ContentSecurityPolicyIssueDetailsBuilder {
+            pub fn blocked_url(mut self, blocked_url: impl Into<String>) -> Self {
+                self.blocked_url = Some(blocked_url.into());
+                self
+            }
+            pub fn violated_directive(mut self, violated_directive: impl Into<String>) -> Self {
+                self.violated_directive = Some(violated_directive.into());
+                self
+            }
+            pub fn is_report_only(mut self, is_report_only: impl Into<bool>) -> Self {
+                self.is_report_only = Some(is_report_only.into());
+                self
+            }
+            pub fn content_security_policy_violation_type(
+                mut self,
+                content_security_policy_violation_type: impl Into<ContentSecurityPolicyViolationType>,
+            ) -> Self {
+                self.content_security_policy_violation_type =
+                    Some(content_security_policy_violation_type.into());
+                self
+            }
+            pub fn frame_ancestor(mut self, frame_ancestor: impl Into<AffectedFrame>) -> Self {
+                self.frame_ancestor = Some(frame_ancestor.into());
+                self
+            }
+            pub fn source_code_location(
+                mut self,
+                source_code_location: impl Into<SourceCodeLocation>,
+            ) -> Self {
+                self.source_code_location = Some(source_code_location.into());
+                self
+            }
+            pub fn violating_node_id(
+                mut self,
+                violating_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.violating_node_id = Some(violating_node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ContentSecurityPolicyIssueDetails, String> {
+                Ok(ContentSecurityPolicyIssueDetails {
+                    blocked_url: self.blocked_url,
+                    violated_directive: self.violated_directive.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(violated_directive)
+                        )
+                    })?,
+                    is_report_only: self.is_report_only.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_report_only))
+                    })?,
+                    content_security_policy_violation_type: self
+                        .content_security_policy_violation_type
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(content_security_policy_violation_type)
+                            )
+                        })?,
+                    frame_ancestor: self.frame_ancestor,
+                    source_code_location: self.source_code_location,
+                    violating_node_id: self.violating_node_id,
+                })
+            }
+        }
+        impl ContentSecurityPolicyIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.ContentSecurityPolicyIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SharedArrayBufferIssueType {
+            #[serde(rename = "TransferIssue")]
+            TransferIssue,
+            #[serde(rename = "CreationIssue")]
+            CreationIssue,
+        }
+        impl AsRef<str> for SharedArrayBufferIssueType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SharedArrayBufferIssueType::TransferIssue => "TransferIssue",
+                    SharedArrayBufferIssueType::CreationIssue => "CreationIssue",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SharedArrayBufferIssueType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "TransferIssue" | "transferissue" => {
+                        Ok(SharedArrayBufferIssueType::TransferIssue)
+                    }
+                    "CreationIssue" | "creationissue" => {
+                        Ok(SharedArrayBufferIssueType::CreationIssue)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Details for a issue arising from an SAB being instantiated in, or\ntransferred to a context that is not cross-origin isolated.\n[SharedArrayBufferIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-SharedArrayBufferIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SharedArrayBufferIssueDetails {
+            #[serde(rename = "sourceCodeLocation")]
+            pub source_code_location: SourceCodeLocation,
+            #[serde(rename = "isWarning")]
+            pub is_warning: bool,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: SharedArrayBufferIssueType,
+        }
+        impl SharedArrayBufferIssueDetails {
+            pub fn new(
+                source_code_location: impl Into<SourceCodeLocation>,
+                is_warning: impl Into<bool>,
+                r#type: impl Into<SharedArrayBufferIssueType>,
+            ) -> Self {
+                Self {
+                    source_code_location: source_code_location.into(),
+                    is_warning: is_warning.into(),
+                    r#type: r#type.into(),
+                }
+            }
+        }
+        impl SharedArrayBufferIssueDetails {
+            pub fn builder() -> SharedArrayBufferIssueDetailsBuilder {
+                SharedArrayBufferIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SharedArrayBufferIssueDetailsBuilder {
+            source_code_location: Option<SourceCodeLocation>,
+            is_warning: Option<bool>,
+            r#type: Option<SharedArrayBufferIssueType>,
+        }
+        impl SharedArrayBufferIssueDetailsBuilder {
+            pub fn source_code_location(
+                mut self,
+                source_code_location: impl Into<SourceCodeLocation>,
+            ) -> Self {
+                self.source_code_location = Some(source_code_location.into());
+                self
+            }
+            pub fn is_warning(mut self, is_warning: impl Into<bool>) -> Self {
+                self.is_warning = Some(is_warning.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<SharedArrayBufferIssueType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<SharedArrayBufferIssueDetails, String> {
+                Ok(SharedArrayBufferIssueDetails {
+                    source_code_location: self.source_code_location.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(source_code_location)
+                        )
+                    })?,
+                    is_warning: self.is_warning.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_warning))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                })
+            }
+        }
+        impl SharedArrayBufferIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.SharedArrayBufferIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LowTextContrastIssueDetails {
+            #[serde(rename = "violatingNodeId")]
+            pub violating_node_id: super::dom::BackendNodeId,
+            #[serde(rename = "violatingNodeSelector")]
+            pub violating_node_selector: String,
+            #[serde(rename = "contrastRatio")]
+            pub contrast_ratio: f64,
+            #[serde(rename = "thresholdAA")]
+            pub threshold_aa: f64,
+            #[serde(rename = "thresholdAAA")]
+            pub threshold_aaa: f64,
+            #[serde(rename = "fontSize")]
+            pub font_size: String,
+            #[serde(rename = "fontWeight")]
+            pub font_weight: String,
+        }
+        impl LowTextContrastIssueDetails {
+            pub fn builder() -> LowTextContrastIssueDetailsBuilder {
+                LowTextContrastIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LowTextContrastIssueDetailsBuilder {
+            violating_node_id: Option<super::dom::BackendNodeId>,
+            violating_node_selector: Option<String>,
+            contrast_ratio: Option<f64>,
+            threshold_aa: Option<f64>,
+            threshold_aaa: Option<f64>,
+            font_size: Option<String>,
+            font_weight: Option<String>,
+        }
+        impl LowTextContrastIssueDetailsBuilder {
+            pub fn violating_node_id(
+                mut self,
+                violating_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.violating_node_id = Some(violating_node_id.into());
+                self
+            }
+            pub fn violating_node_selector(
+                mut self,
+                violating_node_selector: impl Into<String>,
+            ) -> Self {
+                self.violating_node_selector = Some(violating_node_selector.into());
+                self
+            }
+            pub fn contrast_ratio(mut self, contrast_ratio: impl Into<f64>) -> Self {
+                self.contrast_ratio = Some(contrast_ratio.into());
+                self
+            }
+            pub fn threshold_aa(mut self, threshold_aa: impl Into<f64>) -> Self {
+                self.threshold_aa = Some(threshold_aa.into());
+                self
+            }
+            pub fn threshold_aaa(mut self, threshold_aaa: impl Into<f64>) -> Self {
+                self.threshold_aaa = Some(threshold_aaa.into());
+                self
+            }
+            pub fn font_size(mut self, font_size: impl Into<String>) -> Self {
+                self.font_size = Some(font_size.into());
+                self
+            }
+            pub fn font_weight(mut self, font_weight: impl Into<String>) -> Self {
+                self.font_weight = Some(font_weight.into());
+                self
+            }
+            pub fn build(self) -> Result<LowTextContrastIssueDetails, String> {
+                Ok(LowTextContrastIssueDetails {
+                    violating_node_id: self.violating_node_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(violating_node_id)
+                        )
+                    })?,
+                    violating_node_selector: self.violating_node_selector.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(violating_node_selector)
+                        )
+                    })?,
+                    contrast_ratio: self.contrast_ratio.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(contrast_ratio))
+                    })?,
+                    threshold_aa: self.threshold_aa.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(threshold_aa))
+                    })?,
+                    threshold_aaa: self.threshold_aaa.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(threshold_aaa))
+                    })?,
+                    font_size: self.font_size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_size))
+                    })?,
+                    font_weight: self.font_weight.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_weight))
+                    })?,
+                })
+            }
+        }
+        impl LowTextContrastIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.LowTextContrastIssueDetails";
+        }
+        #[doc = "Details for a CORS related issue, e.g. a warning or error related to\nCORS RFC1918 enforcement.\n[CorsIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-CorsIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CorsIssueDetails {
+            #[serde(rename = "corsErrorStatus")]
+            pub cors_error_status: super::network::CorsErrorStatus,
+            #[serde(rename = "isWarning")]
+            pub is_warning: bool,
+            #[serde(rename = "request")]
+            pub request: AffectedRequest,
+            #[serde(rename = "location")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub location: Option<SourceCodeLocation>,
+            #[serde(rename = "initiatorOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub initiator_origin: Option<String>,
+            #[serde(rename = "resourceIPAddressSpace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub resource_ip_address_space: Option<super::network::IpAddressSpace>,
+            #[serde(rename = "clientSecurityState")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub client_security_state: Option<super::network::ClientSecurityState>,
+        }
+        impl CorsIssueDetails {
+            pub fn new(
+                cors_error_status: impl Into<super::network::CorsErrorStatus>,
+                is_warning: impl Into<bool>,
+                request: impl Into<AffectedRequest>,
+            ) -> Self {
+                Self {
+                    cors_error_status: cors_error_status.into(),
+                    is_warning: is_warning.into(),
+                    request: request.into(),
+                    location: None,
+                    initiator_origin: None,
+                    resource_ip_address_space: None,
+                    client_security_state: None,
+                }
+            }
+        }
+        impl CorsIssueDetails {
+            pub fn builder() -> CorsIssueDetailsBuilder {
+                CorsIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CorsIssueDetailsBuilder {
+            cors_error_status: Option<super::network::CorsErrorStatus>,
+            is_warning: Option<bool>,
+            request: Option<AffectedRequest>,
+            location: Option<SourceCodeLocation>,
+            initiator_origin: Option<String>,
+            resource_ip_address_space: Option<super::network::IpAddressSpace>,
+            client_security_state: Option<super::network::ClientSecurityState>,
+        }
+        impl CorsIssueDetailsBuilder {
+            pub fn cors_error_status(
+                mut self,
+                cors_error_status: impl Into<super::network::CorsErrorStatus>,
+            ) -> Self {
+                self.cors_error_status = Some(cors_error_status.into());
+                self
+            }
+            pub fn is_warning(mut self, is_warning: impl Into<bool>) -> Self {
+                self.is_warning = Some(is_warning.into());
+                self
+            }
+            pub fn request(mut self, request: impl Into<AffectedRequest>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn location(mut self, location: impl Into<SourceCodeLocation>) -> Self {
+                self.location = Some(location.into());
+                self
+            }
+            pub fn initiator_origin(mut self, initiator_origin: impl Into<String>) -> Self {
+                self.initiator_origin = Some(initiator_origin.into());
+                self
+            }
+            pub fn resource_ip_address_space(
+                mut self,
+                resource_ip_address_space: impl Into<super::network::IpAddressSpace>,
+            ) -> Self {
+                self.resource_ip_address_space = Some(resource_ip_address_space.into());
+                self
+            }
+            pub fn client_security_state(
+                mut self,
+                client_security_state: impl Into<super::network::ClientSecurityState>,
+            ) -> Self {
+                self.client_security_state = Some(client_security_state.into());
+                self
+            }
+            pub fn build(self) -> Result<CorsIssueDetails, String> {
+                Ok(CorsIssueDetails {
+                    cors_error_status: self.cors_error_status.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(cors_error_status)
+                        )
+                    })?,
+                    is_warning: self.is_warning.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_warning))
+                    })?,
+                    request: self.request.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request))
+                    })?,
+                    location: self.location,
+                    initiator_origin: self.initiator_origin,
+                    resource_ip_address_space: self.resource_ip_address_space,
+                    client_security_state: self.client_security_state,
+                })
+            }
+        }
+        impl CorsIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.CorsIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AttributionReportingIssueType {
+            #[serde(rename = "PermissionPolicyDisabled")]
+            PermissionPolicyDisabled,
+            #[serde(rename = "UntrustworthyReportingOrigin")]
+            UntrustworthyReportingOrigin,
+            #[serde(rename = "InsecureContext")]
+            InsecureContext,
+            #[doc = "TODO(apaseltiner): Rename this to InvalidRegisterSourceHeader"]
+            #[serde(rename = "InvalidHeader")]
+            InvalidHeader,
+            #[serde(rename = "InvalidRegisterTriggerHeader")]
+            InvalidRegisterTriggerHeader,
+            #[serde(rename = "SourceAndTriggerHeaders")]
+            SourceAndTriggerHeaders,
+            #[serde(rename = "SourceIgnored")]
+            SourceIgnored,
+            #[serde(rename = "TriggerIgnored")]
+            TriggerIgnored,
+            #[serde(rename = "OsSourceIgnored")]
+            OsSourceIgnored,
+            #[serde(rename = "OsTriggerIgnored")]
+            OsTriggerIgnored,
+            #[serde(rename = "InvalidRegisterOsSourceHeader")]
+            InvalidRegisterOsSourceHeader,
+            #[serde(rename = "InvalidRegisterOsTriggerHeader")]
+            InvalidRegisterOsTriggerHeader,
+            #[serde(rename = "WebAndOsHeaders")]
+            WebAndOsHeaders,
+            #[serde(rename = "NoWebOrOsSupport")]
+            NoWebOrOsSupport,
+            #[serde(rename = "NavigationRegistrationWithoutTransientUserActivation")]
+            NavigationRegistrationWithoutTransientUserActivation,
+            #[serde(rename = "InvalidInfoHeader")]
+            InvalidInfoHeader,
+            #[serde(rename = "NoRegisterSourceHeader")]
+            NoRegisterSourceHeader,
+            #[serde(rename = "NoRegisterTriggerHeader")]
+            NoRegisterTriggerHeader,
+            #[serde(rename = "NoRegisterOsSourceHeader")]
+            NoRegisterOsSourceHeader,
+            #[serde(rename = "NoRegisterOsTriggerHeader")]
+            NoRegisterOsTriggerHeader,
+            #[serde(rename = "NavigationRegistrationUniqueScopeAlreadySet")]
+            NavigationRegistrationUniqueScopeAlreadySet,
+        }
+        impl AsRef<str> for AttributionReportingIssueType {
+            fn as_ref(&self) -> &str {
+                match self { AttributionReportingIssueType :: PermissionPolicyDisabled => "PermissionPolicyDisabled" , AttributionReportingIssueType :: UntrustworthyReportingOrigin => "UntrustworthyReportingOrigin" , AttributionReportingIssueType :: InsecureContext => "InsecureContext" , AttributionReportingIssueType :: InvalidHeader => "InvalidHeader" , AttributionReportingIssueType :: InvalidRegisterTriggerHeader => "InvalidRegisterTriggerHeader" , AttributionReportingIssueType :: SourceAndTriggerHeaders => "SourceAndTriggerHeaders" , AttributionReportingIssueType :: SourceIgnored => "SourceIgnored" , AttributionReportingIssueType :: TriggerIgnored => "TriggerIgnored" , AttributionReportingIssueType :: OsSourceIgnored => "OsSourceIgnored" , AttributionReportingIssueType :: OsTriggerIgnored => "OsTriggerIgnored" , AttributionReportingIssueType :: InvalidRegisterOsSourceHeader => "InvalidRegisterOsSourceHeader" , AttributionReportingIssueType :: InvalidRegisterOsTriggerHeader => "InvalidRegisterOsTriggerHeader" , AttributionReportingIssueType :: WebAndOsHeaders => "WebAndOsHeaders" , AttributionReportingIssueType :: NoWebOrOsSupport => "NoWebOrOsSupport" , AttributionReportingIssueType :: NavigationRegistrationWithoutTransientUserActivation => "NavigationRegistrationWithoutTransientUserActivation" , AttributionReportingIssueType :: InvalidInfoHeader => "InvalidInfoHeader" , AttributionReportingIssueType :: NoRegisterSourceHeader => "NoRegisterSourceHeader" , AttributionReportingIssueType :: NoRegisterTriggerHeader => "NoRegisterTriggerHeader" , AttributionReportingIssueType :: NoRegisterOsSourceHeader => "NoRegisterOsSourceHeader" , AttributionReportingIssueType :: NoRegisterOsTriggerHeader => "NoRegisterOsTriggerHeader" , AttributionReportingIssueType :: NavigationRegistrationUniqueScopeAlreadySet => "NavigationRegistrationUniqueScopeAlreadySet" }
+            }
+        }
+        impl ::std::str::FromStr for AttributionReportingIssueType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s { "PermissionPolicyDisabled" | "permissionpolicydisabled" => Ok (AttributionReportingIssueType :: PermissionPolicyDisabled) , "UntrustworthyReportingOrigin" | "untrustworthyreportingorigin" => Ok (AttributionReportingIssueType :: UntrustworthyReportingOrigin) , "InsecureContext" | "insecurecontext" => Ok (AttributionReportingIssueType :: InsecureContext) , "InvalidHeader" | "invalidheader" => Ok (AttributionReportingIssueType :: InvalidHeader) , "InvalidRegisterTriggerHeader" | "invalidregistertriggerheader" => Ok (AttributionReportingIssueType :: InvalidRegisterTriggerHeader) , "SourceAndTriggerHeaders" | "sourceandtriggerheaders" => Ok (AttributionReportingIssueType :: SourceAndTriggerHeaders) , "SourceIgnored" | "sourceignored" => Ok (AttributionReportingIssueType :: SourceIgnored) , "TriggerIgnored" | "triggerignored" => Ok (AttributionReportingIssueType :: TriggerIgnored) , "OsSourceIgnored" | "ossourceignored" => Ok (AttributionReportingIssueType :: OsSourceIgnored) , "OsTriggerIgnored" | "ostriggerignored" => Ok (AttributionReportingIssueType :: OsTriggerIgnored) , "InvalidRegisterOsSourceHeader" | "invalidregisterossourceheader" => Ok (AttributionReportingIssueType :: InvalidRegisterOsSourceHeader) , "InvalidRegisterOsTriggerHeader" | "invalidregisterostriggerheader" => Ok (AttributionReportingIssueType :: InvalidRegisterOsTriggerHeader) , "WebAndOsHeaders" | "webandosheaders" => Ok (AttributionReportingIssueType :: WebAndOsHeaders) , "NoWebOrOsSupport" | "noweborossupport" => Ok (AttributionReportingIssueType :: NoWebOrOsSupport) , "NavigationRegistrationWithoutTransientUserActivation" | "navigationregistrationwithouttransientuseractivation" => Ok (AttributionReportingIssueType :: NavigationRegistrationWithoutTransientUserActivation) , "InvalidInfoHeader" | "invalidinfoheader" => Ok (AttributionReportingIssueType :: InvalidInfoHeader) , "NoRegisterSourceHeader" | "noregistersourceheader" => Ok (AttributionReportingIssueType :: NoRegisterSourceHeader) , "NoRegisterTriggerHeader" | "noregistertriggerheader" => Ok (AttributionReportingIssueType :: NoRegisterTriggerHeader) , "NoRegisterOsSourceHeader" | "noregisterossourceheader" => Ok (AttributionReportingIssueType :: NoRegisterOsSourceHeader) , "NoRegisterOsTriggerHeader" | "noregisterostriggerheader" => Ok (AttributionReportingIssueType :: NoRegisterOsTriggerHeader) , "NavigationRegistrationUniqueScopeAlreadySet" | "navigationregistrationuniquescopealreadyset" => Ok (AttributionReportingIssueType :: NavigationRegistrationUniqueScopeAlreadySet) , _ => Err (s . to_string ()) }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SharedDictionaryError {
+            #[serde(rename = "UseErrorCrossOriginNoCorsRequest")]
+            UseErrorCrossOriginNoCorsRequest,
+            #[serde(rename = "UseErrorDictionaryLoadFailure")]
+            UseErrorDictionaryLoadFailure,
+            #[serde(rename = "UseErrorMatchingDictionaryNotUsed")]
+            UseErrorMatchingDictionaryNotUsed,
+            #[serde(rename = "UseErrorUnexpectedContentDictionaryHeader")]
+            UseErrorUnexpectedContentDictionaryHeader,
+            #[serde(rename = "WriteErrorCossOriginNoCorsRequest")]
+            WriteErrorCossOriginNoCorsRequest,
+            #[serde(rename = "WriteErrorDisallowedBySettings")]
+            WriteErrorDisallowedBySettings,
+            #[serde(rename = "WriteErrorExpiredResponse")]
+            WriteErrorExpiredResponse,
+            #[serde(rename = "WriteErrorFeatureDisabled")]
+            WriteErrorFeatureDisabled,
+            #[serde(rename = "WriteErrorInsufficientResources")]
+            WriteErrorInsufficientResources,
+            #[serde(rename = "WriteErrorInvalidMatchField")]
+            WriteErrorInvalidMatchField,
+            #[serde(rename = "WriteErrorInvalidStructuredHeader")]
+            WriteErrorInvalidStructuredHeader,
+            #[serde(rename = "WriteErrorInvalidTTLField")]
+            WriteErrorInvalidTtlField,
+            #[serde(rename = "WriteErrorNavigationRequest")]
+            WriteErrorNavigationRequest,
+            #[serde(rename = "WriteErrorNoMatchField")]
+            WriteErrorNoMatchField,
+            #[serde(rename = "WriteErrorNonIntegerTTLField")]
+            WriteErrorNonIntegerTtlField,
+            #[serde(rename = "WriteErrorNonListMatchDestField")]
+            WriteErrorNonListMatchDestField,
+            #[serde(rename = "WriteErrorNonSecureContext")]
+            WriteErrorNonSecureContext,
+            #[serde(rename = "WriteErrorNonStringIdField")]
+            WriteErrorNonStringIdField,
+            #[serde(rename = "WriteErrorNonStringInMatchDestList")]
+            WriteErrorNonStringInMatchDestList,
+            #[serde(rename = "WriteErrorNonStringMatchField")]
+            WriteErrorNonStringMatchField,
+            #[serde(rename = "WriteErrorNonTokenTypeField")]
+            WriteErrorNonTokenTypeField,
+            #[serde(rename = "WriteErrorRequestAborted")]
+            WriteErrorRequestAborted,
+            #[serde(rename = "WriteErrorShuttingDown")]
+            WriteErrorShuttingDown,
+            #[serde(rename = "WriteErrorTooLongIdField")]
+            WriteErrorTooLongIdField,
+            #[serde(rename = "WriteErrorUnsupportedType")]
+            WriteErrorUnsupportedType,
+        }
+        impl AsRef<str> for SharedDictionaryError {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SharedDictionaryError::UseErrorCrossOriginNoCorsRequest => {
+                        "UseErrorCrossOriginNoCorsRequest"
+                    }
+                    SharedDictionaryError::UseErrorDictionaryLoadFailure => {
+                        "UseErrorDictionaryLoadFailure"
+                    }
+                    SharedDictionaryError::UseErrorMatchingDictionaryNotUsed => {
+                        "UseErrorMatchingDictionaryNotUsed"
+                    }
+                    SharedDictionaryError::UseErrorUnexpectedContentDictionaryHeader => {
+                        "UseErrorUnexpectedContentDictionaryHeader"
+                    }
+                    SharedDictionaryError::WriteErrorCossOriginNoCorsRequest => {
+                        "WriteErrorCossOriginNoCorsRequest"
+                    }
+                    SharedDictionaryError::WriteErrorDisallowedBySettings => {
+                        "WriteErrorDisallowedBySettings"
+                    }
+                    SharedDictionaryError::WriteErrorExpiredResponse => "WriteErrorExpiredResponse",
+                    SharedDictionaryError::WriteErrorFeatureDisabled => "WriteErrorFeatureDisabled",
+                    SharedDictionaryError::WriteErrorInsufficientResources => {
+                        "WriteErrorInsufficientResources"
+                    }
+                    SharedDictionaryError::WriteErrorInvalidMatchField => {
+                        "WriteErrorInvalidMatchField"
+                    }
+                    SharedDictionaryError::WriteErrorInvalidStructuredHeader => {
+                        "WriteErrorInvalidStructuredHeader"
+                    }
+                    SharedDictionaryError::WriteErrorInvalidTtlField => "WriteErrorInvalidTTLField",
+                    SharedDictionaryError::WriteErrorNavigationRequest => {
+                        "WriteErrorNavigationRequest"
+                    }
+                    SharedDictionaryError::WriteErrorNoMatchField => "WriteErrorNoMatchField",
+                    SharedDictionaryError::WriteErrorNonIntegerTtlField => {
+                        "WriteErrorNonIntegerTTLField"
+                    }
+                    SharedDictionaryError::WriteErrorNonListMatchDestField => {
+                        "WriteErrorNonListMatchDestField"
+                    }
+                    SharedDictionaryError::WriteErrorNonSecureContext => {
+                        "WriteErrorNonSecureContext"
+                    }
+                    SharedDictionaryError::WriteErrorNonStringIdField => {
+                        "WriteErrorNonStringIdField"
+                    }
+                    SharedDictionaryError::WriteErrorNonStringInMatchDestList => {
+                        "WriteErrorNonStringInMatchDestList"
+                    }
+                    SharedDictionaryError::WriteErrorNonStringMatchField => {
+                        "WriteErrorNonStringMatchField"
+                    }
+                    SharedDictionaryError::WriteErrorNonTokenTypeField => {
+                        "WriteErrorNonTokenTypeField"
+                    }
+                    SharedDictionaryError::WriteErrorRequestAborted => "WriteErrorRequestAborted",
+                    SharedDictionaryError::WriteErrorShuttingDown => "WriteErrorShuttingDown",
+                    SharedDictionaryError::WriteErrorTooLongIdField => "WriteErrorTooLongIdField",
+                    SharedDictionaryError::WriteErrorUnsupportedType => "WriteErrorUnsupportedType",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SharedDictionaryError {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "UseErrorCrossOriginNoCorsRequest" | "useerrorcrossoriginnocorsrequest" => {
+                        Ok(SharedDictionaryError::UseErrorCrossOriginNoCorsRequest)
+                    }
+                    "UseErrorDictionaryLoadFailure" | "useerrordictionaryloadfailure" => {
+                        Ok(SharedDictionaryError::UseErrorDictionaryLoadFailure)
+                    }
+                    "UseErrorMatchingDictionaryNotUsed" | "useerrormatchingdictionarynotused" => {
+                        Ok(SharedDictionaryError::UseErrorMatchingDictionaryNotUsed)
+                    }
+                    "UseErrorUnexpectedContentDictionaryHeader"
+                    | "useerrorunexpectedcontentdictionaryheader" => {
+                        Ok(SharedDictionaryError::UseErrorUnexpectedContentDictionaryHeader)
+                    }
+                    "WriteErrorCossOriginNoCorsRequest" | "writeerrorcossoriginnocorsrequest" => {
+                        Ok(SharedDictionaryError::WriteErrorCossOriginNoCorsRequest)
+                    }
+                    "WriteErrorDisallowedBySettings" | "writeerrordisallowedbysettings" => {
+                        Ok(SharedDictionaryError::WriteErrorDisallowedBySettings)
+                    }
+                    "WriteErrorExpiredResponse" | "writeerrorexpiredresponse" => {
+                        Ok(SharedDictionaryError::WriteErrorExpiredResponse)
+                    }
+                    "WriteErrorFeatureDisabled" | "writeerrorfeaturedisabled" => {
+                        Ok(SharedDictionaryError::WriteErrorFeatureDisabled)
+                    }
+                    "WriteErrorInsufficientResources" | "writeerrorinsufficientresources" => {
+                        Ok(SharedDictionaryError::WriteErrorInsufficientResources)
+                    }
+                    "WriteErrorInvalidMatchField" | "writeerrorinvalidmatchfield" => {
+                        Ok(SharedDictionaryError::WriteErrorInvalidMatchField)
+                    }
+                    "WriteErrorInvalidStructuredHeader" | "writeerrorinvalidstructuredheader" => {
+                        Ok(SharedDictionaryError::WriteErrorInvalidStructuredHeader)
+                    }
+                    "WriteErrorInvalidTTLField"
+                    | "WriteErrorInvalidTtlField"
+                    | "writeerrorinvalidttlfield" => {
+                        Ok(SharedDictionaryError::WriteErrorInvalidTtlField)
+                    }
+                    "WriteErrorNavigationRequest" | "writeerrornavigationrequest" => {
+                        Ok(SharedDictionaryError::WriteErrorNavigationRequest)
+                    }
+                    "WriteErrorNoMatchField" | "writeerrornomatchfield" => {
+                        Ok(SharedDictionaryError::WriteErrorNoMatchField)
+                    }
+                    "WriteErrorNonIntegerTTLField"
+                    | "WriteErrorNonIntegerTtlField"
+                    | "writeerrornonintegerttlfield" => {
+                        Ok(SharedDictionaryError::WriteErrorNonIntegerTtlField)
+                    }
+                    "WriteErrorNonListMatchDestField" | "writeerrornonlistmatchdestfield" => {
+                        Ok(SharedDictionaryError::WriteErrorNonListMatchDestField)
+                    }
+                    "WriteErrorNonSecureContext" | "writeerrornonsecurecontext" => {
+                        Ok(SharedDictionaryError::WriteErrorNonSecureContext)
+                    }
+                    "WriteErrorNonStringIdField" | "writeerrornonstringidfield" => {
+                        Ok(SharedDictionaryError::WriteErrorNonStringIdField)
+                    }
+                    "WriteErrorNonStringInMatchDestList" | "writeerrornonstringinmatchdestlist" => {
+                        Ok(SharedDictionaryError::WriteErrorNonStringInMatchDestList)
+                    }
+                    "WriteErrorNonStringMatchField" | "writeerrornonstringmatchfield" => {
+                        Ok(SharedDictionaryError::WriteErrorNonStringMatchField)
+                    }
+                    "WriteErrorNonTokenTypeField" | "writeerrornontokentypefield" => {
+                        Ok(SharedDictionaryError::WriteErrorNonTokenTypeField)
+                    }
+                    "WriteErrorRequestAborted" | "writeerrorrequestaborted" => {
+                        Ok(SharedDictionaryError::WriteErrorRequestAborted)
+                    }
+                    "WriteErrorShuttingDown" | "writeerrorshuttingdown" => {
+                        Ok(SharedDictionaryError::WriteErrorShuttingDown)
+                    }
+                    "WriteErrorTooLongIdField" | "writeerrortoolongidfield" => {
+                        Ok(SharedDictionaryError::WriteErrorTooLongIdField)
+                    }
+                    "WriteErrorUnsupportedType" | "writeerrorunsupportedtype" => {
+                        Ok(SharedDictionaryError::WriteErrorUnsupportedType)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SriMessageSignatureError {
+            #[serde(rename = "MissingSignatureHeader")]
+            MissingSignatureHeader,
+            #[serde(rename = "MissingSignatureInputHeader")]
+            MissingSignatureInputHeader,
+            #[serde(rename = "InvalidSignatureHeader")]
+            InvalidSignatureHeader,
+            #[serde(rename = "InvalidSignatureInputHeader")]
+            InvalidSignatureInputHeader,
+            #[serde(rename = "SignatureHeaderValueIsNotByteSequence")]
+            SignatureHeaderValueIsNotByteSequence,
+            #[serde(rename = "SignatureHeaderValueIsParameterized")]
+            SignatureHeaderValueIsParameterized,
+            #[serde(rename = "SignatureHeaderValueIsIncorrectLength")]
+            SignatureHeaderValueIsIncorrectLength,
+            #[serde(rename = "SignatureInputHeaderMissingLabel")]
+            SignatureInputHeaderMissingLabel,
+            #[serde(rename = "SignatureInputHeaderValueNotInnerList")]
+            SignatureInputHeaderValueNotInnerList,
+            #[serde(rename = "SignatureInputHeaderValueMissingComponents")]
+            SignatureInputHeaderValueMissingComponents,
+            #[serde(rename = "SignatureInputHeaderInvalidComponentType")]
+            SignatureInputHeaderInvalidComponentType,
+            #[serde(rename = "SignatureInputHeaderInvalidComponentName")]
+            SignatureInputHeaderInvalidComponentName,
+            #[serde(rename = "SignatureInputHeaderInvalidHeaderComponentParameter")]
+            SignatureInputHeaderInvalidHeaderComponentParameter,
+            #[serde(rename = "SignatureInputHeaderInvalidDerivedComponentParameter")]
+            SignatureInputHeaderInvalidDerivedComponentParameter,
+            #[serde(rename = "SignatureInputHeaderKeyIdLength")]
+            SignatureInputHeaderKeyIdLength,
+            #[serde(rename = "SignatureInputHeaderInvalidParameter")]
+            SignatureInputHeaderInvalidParameter,
+            #[serde(rename = "SignatureInputHeaderMissingRequiredParameters")]
+            SignatureInputHeaderMissingRequiredParameters,
+            #[serde(rename = "ValidationFailedSignatureExpired")]
+            ValidationFailedSignatureExpired,
+            #[serde(rename = "ValidationFailedInvalidLength")]
+            ValidationFailedInvalidLength,
+            #[serde(rename = "ValidationFailedSignatureMismatch")]
+            ValidationFailedSignatureMismatch,
+            #[serde(rename = "ValidationFailedIntegrityMismatch")]
+            ValidationFailedIntegrityMismatch,
+        }
+        impl AsRef<str> for SriMessageSignatureError {
+            fn as_ref(&self) -> &str {
+                match self { SriMessageSignatureError :: MissingSignatureHeader => "MissingSignatureHeader" , SriMessageSignatureError :: MissingSignatureInputHeader => "MissingSignatureInputHeader" , SriMessageSignatureError :: InvalidSignatureHeader => "InvalidSignatureHeader" , SriMessageSignatureError :: InvalidSignatureInputHeader => "InvalidSignatureInputHeader" , SriMessageSignatureError :: SignatureHeaderValueIsNotByteSequence => "SignatureHeaderValueIsNotByteSequence" , SriMessageSignatureError :: SignatureHeaderValueIsParameterized => "SignatureHeaderValueIsParameterized" , SriMessageSignatureError :: SignatureHeaderValueIsIncorrectLength => "SignatureHeaderValueIsIncorrectLength" , SriMessageSignatureError :: SignatureInputHeaderMissingLabel => "SignatureInputHeaderMissingLabel" , SriMessageSignatureError :: SignatureInputHeaderValueNotInnerList => "SignatureInputHeaderValueNotInnerList" , SriMessageSignatureError :: SignatureInputHeaderValueMissingComponents => "SignatureInputHeaderValueMissingComponents" , SriMessageSignatureError :: SignatureInputHeaderInvalidComponentType => "SignatureInputHeaderInvalidComponentType" , SriMessageSignatureError :: SignatureInputHeaderInvalidComponentName => "SignatureInputHeaderInvalidComponentName" , SriMessageSignatureError :: SignatureInputHeaderInvalidHeaderComponentParameter => "SignatureInputHeaderInvalidHeaderComponentParameter" , SriMessageSignatureError :: SignatureInputHeaderInvalidDerivedComponentParameter => "SignatureInputHeaderInvalidDerivedComponentParameter" , SriMessageSignatureError :: SignatureInputHeaderKeyIdLength => "SignatureInputHeaderKeyIdLength" , SriMessageSignatureError :: SignatureInputHeaderInvalidParameter => "SignatureInputHeaderInvalidParameter" , SriMessageSignatureError :: SignatureInputHeaderMissingRequiredParameters => "SignatureInputHeaderMissingRequiredParameters" , SriMessageSignatureError :: ValidationFailedSignatureExpired => "ValidationFailedSignatureExpired" , SriMessageSignatureError :: ValidationFailedInvalidLength => "ValidationFailedInvalidLength" , SriMessageSignatureError :: ValidationFailedSignatureMismatch => "ValidationFailedSignatureMismatch" , SriMessageSignatureError :: ValidationFailedIntegrityMismatch => "ValidationFailedIntegrityMismatch" }
+            }
+        }
+        impl ::std::str::FromStr for SriMessageSignatureError {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s { "MissingSignatureHeader" | "missingsignatureheader" => Ok (SriMessageSignatureError :: MissingSignatureHeader) , "MissingSignatureInputHeader" | "missingsignatureinputheader" => Ok (SriMessageSignatureError :: MissingSignatureInputHeader) , "InvalidSignatureHeader" | "invalidsignatureheader" => Ok (SriMessageSignatureError :: InvalidSignatureHeader) , "InvalidSignatureInputHeader" | "invalidsignatureinputheader" => Ok (SriMessageSignatureError :: InvalidSignatureInputHeader) , "SignatureHeaderValueIsNotByteSequence" | "signatureheadervalueisnotbytesequence" => Ok (SriMessageSignatureError :: SignatureHeaderValueIsNotByteSequence) , "SignatureHeaderValueIsParameterized" | "signatureheadervalueisparameterized" => Ok (SriMessageSignatureError :: SignatureHeaderValueIsParameterized) , "SignatureHeaderValueIsIncorrectLength" | "signatureheadervalueisincorrectlength" => Ok (SriMessageSignatureError :: SignatureHeaderValueIsIncorrectLength) , "SignatureInputHeaderMissingLabel" | "signatureinputheadermissinglabel" => Ok (SriMessageSignatureError :: SignatureInputHeaderMissingLabel) , "SignatureInputHeaderValueNotInnerList" | "signatureinputheadervaluenotinnerlist" => Ok (SriMessageSignatureError :: SignatureInputHeaderValueNotInnerList) , "SignatureInputHeaderValueMissingComponents" | "signatureinputheadervaluemissingcomponents" => Ok (SriMessageSignatureError :: SignatureInputHeaderValueMissingComponents) , "SignatureInputHeaderInvalidComponentType" | "signatureinputheaderinvalidcomponenttype" => Ok (SriMessageSignatureError :: SignatureInputHeaderInvalidComponentType) , "SignatureInputHeaderInvalidComponentName" | "signatureinputheaderinvalidcomponentname" => Ok (SriMessageSignatureError :: SignatureInputHeaderInvalidComponentName) , "SignatureInputHeaderInvalidHeaderComponentParameter" | "signatureinputheaderinvalidheadercomponentparameter" => Ok (SriMessageSignatureError :: SignatureInputHeaderInvalidHeaderComponentParameter) , "SignatureInputHeaderInvalidDerivedComponentParameter" | "signatureinputheaderinvalidderivedcomponentparameter" => Ok (SriMessageSignatureError :: SignatureInputHeaderInvalidDerivedComponentParameter) , "SignatureInputHeaderKeyIdLength" | "signatureinputheaderkeyidlength" => Ok (SriMessageSignatureError :: SignatureInputHeaderKeyIdLength) , "SignatureInputHeaderInvalidParameter" | "signatureinputheaderinvalidparameter" => Ok (SriMessageSignatureError :: SignatureInputHeaderInvalidParameter) , "SignatureInputHeaderMissingRequiredParameters" | "signatureinputheadermissingrequiredparameters" => Ok (SriMessageSignatureError :: SignatureInputHeaderMissingRequiredParameters) , "ValidationFailedSignatureExpired" | "validationfailedsignatureexpired" => Ok (SriMessageSignatureError :: ValidationFailedSignatureExpired) , "ValidationFailedInvalidLength" | "validationfailedinvalidlength" => Ok (SriMessageSignatureError :: ValidationFailedInvalidLength) , "ValidationFailedSignatureMismatch" | "validationfailedsignaturemismatch" => Ok (SriMessageSignatureError :: ValidationFailedSignatureMismatch) , "ValidationFailedIntegrityMismatch" | "validationfailedintegritymismatch" => Ok (SriMessageSignatureError :: ValidationFailedIntegrityMismatch) , _ => Err (s . to_string ()) }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum UnencodedDigestError {
+            #[serde(rename = "MalformedDictionary")]
+            MalformedDictionary,
+            #[serde(rename = "UnknownAlgorithm")]
+            UnknownAlgorithm,
+            #[serde(rename = "IncorrectDigestType")]
+            IncorrectDigestType,
+            #[serde(rename = "IncorrectDigestLength")]
+            IncorrectDigestLength,
+        }
+        impl AsRef<str> for UnencodedDigestError {
+            fn as_ref(&self) -> &str {
+                match self {
+                    UnencodedDigestError::MalformedDictionary => "MalformedDictionary",
+                    UnencodedDigestError::UnknownAlgorithm => "UnknownAlgorithm",
+                    UnencodedDigestError::IncorrectDigestType => "IncorrectDigestType",
+                    UnencodedDigestError::IncorrectDigestLength => "IncorrectDigestLength",
+                }
+            }
+        }
+        impl ::std::str::FromStr for UnencodedDigestError {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "MalformedDictionary" | "malformeddictionary" => {
+                        Ok(UnencodedDigestError::MalformedDictionary)
+                    }
+                    "UnknownAlgorithm" | "unknownalgorithm" => {
+                        Ok(UnencodedDigestError::UnknownAlgorithm)
+                    }
+                    "IncorrectDigestType" | "incorrectdigesttype" => {
+                        Ok(UnencodedDigestError::IncorrectDigestType)
+                    }
+                    "IncorrectDigestLength" | "incorrectdigestlength" => {
+                        Ok(UnencodedDigestError::IncorrectDigestLength)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Details for issues around \"Attribution Reporting API\" usage.\nExplainer: https://github.com/WICG/attribution-reporting-api\n[AttributionReportingIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-AttributionReportingIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingIssueDetails {
+            #[serde(rename = "violationType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub violation_type: AttributionReportingIssueType,
+            #[serde(rename = "request")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request: Option<AffectedRequest>,
+            #[serde(rename = "violatingNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub violating_node_id: Option<super::dom::BackendNodeId>,
+            #[serde(rename = "invalidParameter")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub invalid_parameter: Option<String>,
+        }
+        impl AttributionReportingIssueDetails {
+            pub fn new(violation_type: impl Into<AttributionReportingIssueType>) -> Self {
+                Self {
+                    violation_type: violation_type.into(),
+                    request: None,
+                    violating_node_id: None,
+                    invalid_parameter: None,
+                }
+            }
+        }
+        impl AttributionReportingIssueDetails {
+            pub fn builder() -> AttributionReportingIssueDetailsBuilder {
+                AttributionReportingIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingIssueDetailsBuilder {
+            violation_type: Option<AttributionReportingIssueType>,
+            request: Option<AffectedRequest>,
+            violating_node_id: Option<super::dom::BackendNodeId>,
+            invalid_parameter: Option<String>,
+        }
+        impl AttributionReportingIssueDetailsBuilder {
+            pub fn violation_type(
+                mut self,
+                violation_type: impl Into<AttributionReportingIssueType>,
+            ) -> Self {
+                self.violation_type = Some(violation_type.into());
+                self
+            }
+            pub fn request(mut self, request: impl Into<AffectedRequest>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn violating_node_id(
+                mut self,
+                violating_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.violating_node_id = Some(violating_node_id.into());
+                self
+            }
+            pub fn invalid_parameter(mut self, invalid_parameter: impl Into<String>) -> Self {
+                self.invalid_parameter = Some(invalid_parameter.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingIssueDetails, String> {
+                Ok(AttributionReportingIssueDetails {
+                    violation_type: self.violation_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(violation_type))
+                    })?,
+                    request: self.request,
+                    violating_node_id: self.violating_node_id,
+                    invalid_parameter: self.invalid_parameter,
+                })
+            }
+        }
+        impl AttributionReportingIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.AttributionReportingIssueDetails";
+        }
+        #[doc = "Details for issues about documents in Quirks Mode\nor Limited Quirks Mode that affects page layouting.\n[QuirksModeIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-QuirksModeIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct QuirksModeIssueDetails {
+            #[doc = "If false, it means the document's mode is \"quirks\"\ninstead of \"limited-quirks\"."]
+            #[serde(rename = "isLimitedQuirksMode")]
+            pub is_limited_quirks_mode: bool,
+            #[serde(rename = "documentNodeId")]
+            pub document_node_id: super::dom::BackendNodeId,
+            #[serde(rename = "url")]
+            pub url: String,
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+            #[serde(rename = "loaderId")]
+            pub loader_id: super::network::LoaderId,
+        }
+        impl QuirksModeIssueDetails {
+            pub fn builder() -> QuirksModeIssueDetailsBuilder {
+                QuirksModeIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct QuirksModeIssueDetailsBuilder {
+            is_limited_quirks_mode: Option<bool>,
+            document_node_id: Option<super::dom::BackendNodeId>,
+            url: Option<String>,
+            frame_id: Option<super::page::FrameId>,
+            loader_id: Option<super::network::LoaderId>,
+        }
+        impl QuirksModeIssueDetailsBuilder {
+            pub fn is_limited_quirks_mode(
+                mut self,
+                is_limited_quirks_mode: impl Into<bool>,
+            ) -> Self {
+                self.is_limited_quirks_mode = Some(is_limited_quirks_mode.into());
+                self
+            }
+            pub fn document_node_id(
+                mut self,
+                document_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.document_node_id = Some(document_node_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn loader_id(mut self, loader_id: impl Into<super::network::LoaderId>) -> Self {
+                self.loader_id = Some(loader_id.into());
+                self
+            }
+            pub fn build(self) -> Result<QuirksModeIssueDetails, String> {
+                Ok(QuirksModeIssueDetails {
+                    is_limited_quirks_mode: self.is_limited_quirks_mode.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(is_limited_quirks_mode)
+                        )
+                    })?,
+                    document_node_id: self.document_node_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(document_node_id)
+                        )
+                    })?,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    loader_id: self.loader_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(loader_id))
+                    })?,
+                })
+            }
+        }
+        impl QuirksModeIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.QuirksModeIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SharedDictionaryIssueDetails {
+            #[serde(rename = "sharedDictionaryError")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub shared_dictionary_error: SharedDictionaryError,
+            #[serde(rename = "request")]
+            pub request: AffectedRequest,
+        }
+        impl SharedDictionaryIssueDetails {
+            pub fn new(
+                shared_dictionary_error: impl Into<SharedDictionaryError>,
+                request: impl Into<AffectedRequest>,
+            ) -> Self {
+                Self {
+                    shared_dictionary_error: shared_dictionary_error.into(),
+                    request: request.into(),
+                }
+            }
+        }
+        impl SharedDictionaryIssueDetails {
+            pub fn builder() -> SharedDictionaryIssueDetailsBuilder {
+                SharedDictionaryIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SharedDictionaryIssueDetailsBuilder {
+            shared_dictionary_error: Option<SharedDictionaryError>,
+            request: Option<AffectedRequest>,
+        }
+        impl SharedDictionaryIssueDetailsBuilder {
+            pub fn shared_dictionary_error(
+                mut self,
+                shared_dictionary_error: impl Into<SharedDictionaryError>,
+            ) -> Self {
+                self.shared_dictionary_error = Some(shared_dictionary_error.into());
+                self
+            }
+            pub fn request(mut self, request: impl Into<AffectedRequest>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn build(self) -> Result<SharedDictionaryIssueDetails, String> {
+                Ok(SharedDictionaryIssueDetails {
+                    shared_dictionary_error: self.shared_dictionary_error.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(shared_dictionary_error)
+                        )
+                    })?,
+                    request: self.request.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request))
+                    })?,
+                })
+            }
+        }
+        impl SharedDictionaryIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.SharedDictionaryIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SriMessageSignatureIssueDetails {
+            #[serde(rename = "error")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub error: SriMessageSignatureError,
+            #[serde(rename = "signatureBase")]
+            pub signature_base: String,
+            #[serde(rename = "integrityAssertions")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub integrity_assertions: Vec<String>,
+            #[serde(rename = "request")]
+            pub request: AffectedRequest,
+        }
+        impl SriMessageSignatureIssueDetails {
+            pub fn new(
+                error: impl Into<SriMessageSignatureError>,
+                signature_base: impl Into<String>,
+                integrity_assertions: Vec<String>,
+                request: impl Into<AffectedRequest>,
+            ) -> Self {
+                Self {
+                    error: error.into(),
+                    signature_base: signature_base.into(),
+                    integrity_assertions,
+                    request: request.into(),
+                }
+            }
+        }
+        impl SriMessageSignatureIssueDetails {
+            pub fn builder() -> SriMessageSignatureIssueDetailsBuilder {
+                SriMessageSignatureIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SriMessageSignatureIssueDetailsBuilder {
+            error: Option<SriMessageSignatureError>,
+            signature_base: Option<String>,
+            integrity_assertions: Option<Vec<String>>,
+            request: Option<AffectedRequest>,
+        }
+        impl SriMessageSignatureIssueDetailsBuilder {
+            pub fn error(mut self, error: impl Into<SriMessageSignatureError>) -> Self {
+                self.error = Some(error.into());
+                self
+            }
+            pub fn signature_base(mut self, signature_base: impl Into<String>) -> Self {
+                self.signature_base = Some(signature_base.into());
+                self
+            }
+            pub fn integrity_assertion(mut self, integrity_assertion: impl Into<String>) -> Self {
+                let v = self.integrity_assertions.get_or_insert(Vec::new());
+                v.push(integrity_assertion.into());
+                self
+            }
+            pub fn integrity_assertions<I, S>(mut self, integrity_assertions: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.integrity_assertions.get_or_insert(Vec::new());
+                for val in integrity_assertions {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn request(mut self, request: impl Into<AffectedRequest>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn build(self) -> Result<SriMessageSignatureIssueDetails, String> {
+                Ok(SriMessageSignatureIssueDetails {
+                    error: self.error.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(error))
+                    })?,
+                    signature_base: self.signature_base.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(signature_base))
+                    })?,
+                    integrity_assertions: self.integrity_assertions.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(integrity_assertions)
+                        )
+                    })?,
+                    request: self.request.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request))
+                    })?,
+                })
+            }
+        }
+        impl SriMessageSignatureIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.SRIMessageSignatureIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UnencodedDigestIssueDetails {
+            #[serde(rename = "error")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub error: UnencodedDigestError,
+            #[serde(rename = "request")]
+            pub request: AffectedRequest,
+        }
+        impl UnencodedDigestIssueDetails {
+            pub fn new(
+                error: impl Into<UnencodedDigestError>,
+                request: impl Into<AffectedRequest>,
+            ) -> Self {
+                Self {
+                    error: error.into(),
+                    request: request.into(),
+                }
+            }
+        }
+        impl UnencodedDigestIssueDetails {
+            pub fn builder() -> UnencodedDigestIssueDetailsBuilder {
+                UnencodedDigestIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UnencodedDigestIssueDetailsBuilder {
+            error: Option<UnencodedDigestError>,
+            request: Option<AffectedRequest>,
+        }
+        impl UnencodedDigestIssueDetailsBuilder {
+            pub fn error(mut self, error: impl Into<UnencodedDigestError>) -> Self {
+                self.error = Some(error.into());
+                self
+            }
+            pub fn request(mut self, request: impl Into<AffectedRequest>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn build(self) -> Result<UnencodedDigestIssueDetails, String> {
+                Ok(UnencodedDigestIssueDetails {
+                    error: self.error.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(error))
+                    })?,
+                    request: self.request.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request))
+                    })?,
+                })
+            }
+        }
+        impl UnencodedDigestIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.UnencodedDigestIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum GenericIssueErrorType {
+            #[serde(rename = "FormLabelForNameError")]
+            FormLabelForNameError,
+            #[serde(rename = "FormDuplicateIdForInputError")]
+            FormDuplicateIdForInputError,
+            #[serde(rename = "FormInputWithNoLabelError")]
+            FormInputWithNoLabelError,
+            #[serde(rename = "FormAutocompleteAttributeEmptyError")]
+            FormAutocompleteAttributeEmptyError,
+            #[serde(rename = "FormEmptyIdAndNameAttributesForInputError")]
+            FormEmptyIdAndNameAttributesForInputError,
+            #[serde(rename = "FormAriaLabelledByToNonExistingIdError")]
+            FormAriaLabelledByToNonExistingIdError,
+            #[serde(rename = "FormInputAssignedAutocompleteValueToIdOrNameAttributeError")]
+            FormInputAssignedAutocompleteValueToIdOrNameAttributeError,
+            #[serde(rename = "FormLabelHasNeitherForNorNestedInputError")]
+            FormLabelHasNeitherForNorNestedInputError,
+            #[serde(rename = "FormLabelForMatchesNonExistingIdError")]
+            FormLabelForMatchesNonExistingIdError,
+            #[serde(rename = "FormInputHasWrongButWellIntendedAutocompleteValueError")]
+            FormInputHasWrongButWellIntendedAutocompleteValueError,
+            #[serde(rename = "ResponseWasBlockedByORB")]
+            ResponseWasBlockedByOrb,
+            #[serde(rename = "NavigationEntryMarkedSkippable")]
+            NavigationEntryMarkedSkippable,
+            #[serde(rename = "AutofillAndManualTextPolicyControlledFeaturesInfo")]
+            AutofillAndManualTextPolicyControlledFeaturesInfo,
+            #[serde(rename = "AutofillPolicyControlledFeatureInfo")]
+            AutofillPolicyControlledFeatureInfo,
+            #[serde(rename = "ManualTextPolicyControlledFeatureInfo")]
+            ManualTextPolicyControlledFeatureInfo,
+        }
+        impl AsRef<str> for GenericIssueErrorType {
+            fn as_ref(&self) -> &str {
+                match self { GenericIssueErrorType :: FormLabelForNameError => "FormLabelForNameError" , GenericIssueErrorType :: FormDuplicateIdForInputError => "FormDuplicateIdForInputError" , GenericIssueErrorType :: FormInputWithNoLabelError => "FormInputWithNoLabelError" , GenericIssueErrorType :: FormAutocompleteAttributeEmptyError => "FormAutocompleteAttributeEmptyError" , GenericIssueErrorType :: FormEmptyIdAndNameAttributesForInputError => "FormEmptyIdAndNameAttributesForInputError" , GenericIssueErrorType :: FormAriaLabelledByToNonExistingIdError => "FormAriaLabelledByToNonExistingIdError" , GenericIssueErrorType :: FormInputAssignedAutocompleteValueToIdOrNameAttributeError => "FormInputAssignedAutocompleteValueToIdOrNameAttributeError" , GenericIssueErrorType :: FormLabelHasNeitherForNorNestedInputError => "FormLabelHasNeitherForNorNestedInputError" , GenericIssueErrorType :: FormLabelForMatchesNonExistingIdError => "FormLabelForMatchesNonExistingIdError" , GenericIssueErrorType :: FormInputHasWrongButWellIntendedAutocompleteValueError => "FormInputHasWrongButWellIntendedAutocompleteValueError" , GenericIssueErrorType :: ResponseWasBlockedByOrb => "ResponseWasBlockedByORB" , GenericIssueErrorType :: NavigationEntryMarkedSkippable => "NavigationEntryMarkedSkippable" , GenericIssueErrorType :: AutofillAndManualTextPolicyControlledFeaturesInfo => "AutofillAndManualTextPolicyControlledFeaturesInfo" , GenericIssueErrorType :: AutofillPolicyControlledFeatureInfo => "AutofillPolicyControlledFeatureInfo" , GenericIssueErrorType :: ManualTextPolicyControlledFeatureInfo => "ManualTextPolicyControlledFeatureInfo" }
+            }
+        }
+        impl ::std::str::FromStr for GenericIssueErrorType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s { "FormLabelForNameError" | "formlabelfornameerror" => Ok (GenericIssueErrorType :: FormLabelForNameError) , "FormDuplicateIdForInputError" | "formduplicateidforinputerror" => Ok (GenericIssueErrorType :: FormDuplicateIdForInputError) , "FormInputWithNoLabelError" | "forminputwithnolabelerror" => Ok (GenericIssueErrorType :: FormInputWithNoLabelError) , "FormAutocompleteAttributeEmptyError" | "formautocompleteattributeemptyerror" => Ok (GenericIssueErrorType :: FormAutocompleteAttributeEmptyError) , "FormEmptyIdAndNameAttributesForInputError" | "formemptyidandnameattributesforinputerror" => Ok (GenericIssueErrorType :: FormEmptyIdAndNameAttributesForInputError) , "FormAriaLabelledByToNonExistingIdError" | "formarialabelledbytononexistingiderror" => Ok (GenericIssueErrorType :: FormAriaLabelledByToNonExistingIdError) , "FormInputAssignedAutocompleteValueToIdOrNameAttributeError" | "forminputassignedautocompletevaluetoidornameattributeerror" => Ok (GenericIssueErrorType :: FormInputAssignedAutocompleteValueToIdOrNameAttributeError) , "FormLabelHasNeitherForNorNestedInputError" | "formlabelhasneitherfornornestedinputerror" => Ok (GenericIssueErrorType :: FormLabelHasNeitherForNorNestedInputError) , "FormLabelForMatchesNonExistingIdError" | "formlabelformatchesnonexistingiderror" => Ok (GenericIssueErrorType :: FormLabelForMatchesNonExistingIdError) , "FormInputHasWrongButWellIntendedAutocompleteValueError" | "forminputhaswrongbutwellintendedautocompletevalueerror" => Ok (GenericIssueErrorType :: FormInputHasWrongButWellIntendedAutocompleteValueError) , "ResponseWasBlockedByORB" | "ResponseWasBlockedByOrb" | "responsewasblockedbyorb" => Ok (GenericIssueErrorType :: ResponseWasBlockedByOrb) , "NavigationEntryMarkedSkippable" | "navigationentrymarkedskippable" => Ok (GenericIssueErrorType :: NavigationEntryMarkedSkippable) , "AutofillAndManualTextPolicyControlledFeaturesInfo" | "autofillandmanualtextpolicycontrolledfeaturesinfo" => Ok (GenericIssueErrorType :: AutofillAndManualTextPolicyControlledFeaturesInfo) , "AutofillPolicyControlledFeatureInfo" | "autofillpolicycontrolledfeatureinfo" => Ok (GenericIssueErrorType :: AutofillPolicyControlledFeatureInfo) , "ManualTextPolicyControlledFeatureInfo" | "manualtextpolicycontrolledfeatureinfo" => Ok (GenericIssueErrorType :: ManualTextPolicyControlledFeatureInfo) , _ => Err (s . to_string ()) }
+            }
+        }
+        #[doc = "Depending on the concrete errorType, different properties are set.\n[GenericIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-GenericIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GenericIssueDetails {
+            #[doc = "Issues with the same errorType are aggregated in the frontend."]
+            #[serde(rename = "errorType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub error_type: GenericIssueErrorType,
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+            #[serde(rename = "violatingNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub violating_node_id: Option<super::dom::BackendNodeId>,
+            #[serde(rename = "violatingNodeAttribute")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub violating_node_attribute: Option<String>,
+            #[serde(rename = "request")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request: Option<AffectedRequest>,
+        }
+        impl GenericIssueDetails {
+            pub fn new(error_type: impl Into<GenericIssueErrorType>) -> Self {
+                Self {
+                    error_type: error_type.into(),
+                    frame_id: None,
+                    violating_node_id: None,
+                    violating_node_attribute: None,
+                    request: None,
+                }
+            }
+        }
+        impl GenericIssueDetails {
+            pub fn builder() -> GenericIssueDetailsBuilder {
+                GenericIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GenericIssueDetailsBuilder {
+            error_type: Option<GenericIssueErrorType>,
+            frame_id: Option<super::page::FrameId>,
+            violating_node_id: Option<super::dom::BackendNodeId>,
+            violating_node_attribute: Option<String>,
+            request: Option<AffectedRequest>,
+        }
+        impl GenericIssueDetailsBuilder {
+            pub fn error_type(mut self, error_type: impl Into<GenericIssueErrorType>) -> Self {
+                self.error_type = Some(error_type.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn violating_node_id(
+                mut self,
+                violating_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.violating_node_id = Some(violating_node_id.into());
+                self
+            }
+            pub fn violating_node_attribute(
+                mut self,
+                violating_node_attribute: impl Into<String>,
+            ) -> Self {
+                self.violating_node_attribute = Some(violating_node_attribute.into());
+                self
+            }
+            pub fn request(mut self, request: impl Into<AffectedRequest>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn build(self) -> Result<GenericIssueDetails, String> {
+                Ok(GenericIssueDetails {
+                    error_type: self.error_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(error_type))
+                    })?,
+                    frame_id: self.frame_id,
+                    violating_node_id: self.violating_node_id,
+                    violating_node_attribute: self.violating_node_attribute,
+                    request: self.request,
+                })
+            }
+        }
+        impl GenericIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.GenericIssueDetails";
+        }
+        #[doc = "This issue tracks information needed to print a deprecation message.\nhttps://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/frame/third_party/blink/renderer/core/frame/deprecation/README.md\n[DeprecationIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-DeprecationIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeprecationIssueDetails {
+            #[serde(rename = "affectedFrame")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub affected_frame: Option<AffectedFrame>,
+            #[serde(rename = "sourceCodeLocation")]
+            pub source_code_location: SourceCodeLocation,
+            #[doc = "One of the deprecation names from third_party/blink/renderer/core/frame/deprecation/deprecation.json5"]
+            #[serde(rename = "type")]
+            pub r#type: String,
+        }
+        impl DeprecationIssueDetails {
+            pub fn new(
+                source_code_location: impl Into<SourceCodeLocation>,
+                r#type: impl Into<String>,
+            ) -> Self {
+                Self {
+                    source_code_location: source_code_location.into(),
+                    r#type: r#type.into(),
+                    affected_frame: None,
+                }
+            }
+        }
+        impl DeprecationIssueDetails {
+            pub fn builder() -> DeprecationIssueDetailsBuilder {
+                DeprecationIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeprecationIssueDetailsBuilder {
+            affected_frame: Option<AffectedFrame>,
+            source_code_location: Option<SourceCodeLocation>,
+            r#type: Option<String>,
+        }
+        impl DeprecationIssueDetailsBuilder {
+            pub fn affected_frame(mut self, affected_frame: impl Into<AffectedFrame>) -> Self {
+                self.affected_frame = Some(affected_frame.into());
+                self
+            }
+            pub fn source_code_location(
+                mut self,
+                source_code_location: impl Into<SourceCodeLocation>,
+            ) -> Self {
+                self.source_code_location = Some(source_code_location.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<DeprecationIssueDetails, String> {
+                Ok(DeprecationIssueDetails {
+                    affected_frame: self.affected_frame,
+                    source_code_location: self.source_code_location.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(source_code_location)
+                        )
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                })
+            }
+        }
+        impl DeprecationIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.DeprecationIssueDetails";
+        }
+        #[doc = "This issue warns about sites in the redirect chain of a finished navigation\nthat may be flagged as trackers and have their state cleared if they don't\nreceive a user interaction. Note that in this context 'site' means eTLD+1.\nFor example, if the URL `https://example.test:80/bounce` was in the\nredirect chain, the site reported would be `example.test`.\n[BounceTrackingIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-BounceTrackingIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BounceTrackingIssueDetails {
+            #[serde(rename = "trackingSites")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub tracking_sites: Vec<String>,
+        }
+        impl BounceTrackingIssueDetails {
+            pub fn new(tracking_sites: Vec<String>) -> Self {
+                Self { tracking_sites }
+            }
+        }
+        impl BounceTrackingIssueDetails {
+            pub fn builder() -> BounceTrackingIssueDetailsBuilder {
+                BounceTrackingIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BounceTrackingIssueDetailsBuilder {
+            tracking_sites: Option<Vec<String>>,
+        }
+        impl BounceTrackingIssueDetailsBuilder {
+            pub fn tracking_site(mut self, tracking_site: impl Into<String>) -> Self {
+                let v = self.tracking_sites.get_or_insert(Vec::new());
+                v.push(tracking_site.into());
+                self
+            }
+            pub fn tracking_sites<I, S>(mut self, tracking_sites: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.tracking_sites.get_or_insert(Vec::new());
+                for val in tracking_sites {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<BounceTrackingIssueDetails, String> {
+                Ok(BounceTrackingIssueDetails {
+                    tracking_sites: self.tracking_sites.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(tracking_sites))
+                    })?,
+                })
+            }
+        }
+        impl BounceTrackingIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.BounceTrackingIssueDetails";
+        }
+        #[doc = "This issue warns about third-party sites that are accessing cookies on the\ncurrent page, and have been permitted due to having a global metadata grant.\nNote that in this context 'site' means eTLD+1. For example, if the URL\n`https://example.test:80/web_page` was accessing cookies, the site reported\nwould be `example.test`.\n[CookieDeprecationMetadataIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-CookieDeprecationMetadataIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CookieDeprecationMetadataIssueDetails {
+            #[serde(rename = "allowedSites")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub allowed_sites: Vec<String>,
+            #[serde(rename = "optOutPercentage")]
+            pub opt_out_percentage: f64,
+            #[serde(rename = "isOptOutTopLevel")]
+            pub is_opt_out_top_level: bool,
+            #[serde(rename = "operation")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub operation: CookieOperation,
+        }
+        impl CookieDeprecationMetadataIssueDetails {
+            pub fn new(
+                allowed_sites: Vec<String>,
+                opt_out_percentage: impl Into<f64>,
+                is_opt_out_top_level: impl Into<bool>,
+                operation: impl Into<CookieOperation>,
+            ) -> Self {
+                Self {
+                    allowed_sites,
+                    opt_out_percentage: opt_out_percentage.into(),
+                    is_opt_out_top_level: is_opt_out_top_level.into(),
+                    operation: operation.into(),
+                }
+            }
+        }
+        impl CookieDeprecationMetadataIssueDetails {
+            pub fn builder() -> CookieDeprecationMetadataIssueDetailsBuilder {
+                CookieDeprecationMetadataIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CookieDeprecationMetadataIssueDetailsBuilder {
+            allowed_sites: Option<Vec<String>>,
+            opt_out_percentage: Option<f64>,
+            is_opt_out_top_level: Option<bool>,
+            operation: Option<CookieOperation>,
+        }
+        impl CookieDeprecationMetadataIssueDetailsBuilder {
+            pub fn allowed_site(mut self, allowed_site: impl Into<String>) -> Self {
+                let v = self.allowed_sites.get_or_insert(Vec::new());
+                v.push(allowed_site.into());
+                self
+            }
+            pub fn allowed_sites<I, S>(mut self, allowed_sites: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.allowed_sites.get_or_insert(Vec::new());
+                for val in allowed_sites {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn opt_out_percentage(mut self, opt_out_percentage: impl Into<f64>) -> Self {
+                self.opt_out_percentage = Some(opt_out_percentage.into());
+                self
+            }
+            pub fn is_opt_out_top_level(mut self, is_opt_out_top_level: impl Into<bool>) -> Self {
+                self.is_opt_out_top_level = Some(is_opt_out_top_level.into());
+                self
+            }
+            pub fn operation(mut self, operation: impl Into<CookieOperation>) -> Self {
+                self.operation = Some(operation.into());
+                self
+            }
+            pub fn build(self) -> Result<CookieDeprecationMetadataIssueDetails, String> {
+                Ok(CookieDeprecationMetadataIssueDetails {
+                    allowed_sites: self.allowed_sites.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(allowed_sites))
+                    })?,
+                    opt_out_percentage: self.opt_out_percentage.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(opt_out_percentage)
+                        )
+                    })?,
+                    is_opt_out_top_level: self.is_opt_out_top_level.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(is_opt_out_top_level)
+                        )
+                    })?,
+                    operation: self.operation.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(operation))
+                    })?,
+                })
+            }
+        }
+        impl CookieDeprecationMetadataIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.CookieDeprecationMetadataIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ClientHintIssueReason {
+            #[doc = "Items in the accept-ch meta tag allow list must be valid origins.\nNo special values (e.g. self, none, and *) are permitted."]
+            #[serde(rename = "MetaTagAllowListInvalidOrigin")]
+            MetaTagAllowListInvalidOrigin,
+            #[doc = "Only accept-ch meta tags in the original HTML sent from the server\nare respected. Any injected via javascript (or other means) are ignored."]
+            #[serde(rename = "MetaTagModifiedHTML")]
+            MetaTagModifiedHtml,
+        }
+        impl AsRef<str> for ClientHintIssueReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ClientHintIssueReason::MetaTagAllowListInvalidOrigin => {
+                        "MetaTagAllowListInvalidOrigin"
+                    }
+                    ClientHintIssueReason::MetaTagModifiedHtml => "MetaTagModifiedHTML",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ClientHintIssueReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "MetaTagAllowListInvalidOrigin" | "metatagallowlistinvalidorigin" => {
+                        Ok(ClientHintIssueReason::MetaTagAllowListInvalidOrigin)
+                    }
+                    "MetaTagModifiedHTML" | "MetaTagModifiedHtml" | "metatagmodifiedhtml" => {
+                        Ok(ClientHintIssueReason::MetaTagModifiedHtml)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FederatedAuthRequestIssueDetails {
+            #[serde(rename = "federatedAuthRequestIssueReason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub federated_auth_request_issue_reason: FederatedAuthRequestIssueReason,
+        }
+        impl FederatedAuthRequestIssueDetails {
+            pub fn new(
+                federated_auth_request_issue_reason: impl Into<FederatedAuthRequestIssueReason>,
+            ) -> Self {
+                Self {
+                    federated_auth_request_issue_reason: federated_auth_request_issue_reason.into(),
+                }
+            }
+        }
+        impl FederatedAuthRequestIssueDetails {
+            pub fn builder() -> FederatedAuthRequestIssueDetailsBuilder {
+                FederatedAuthRequestIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FederatedAuthRequestIssueDetailsBuilder {
+            federated_auth_request_issue_reason: Option<FederatedAuthRequestIssueReason>,
+        }
+        impl FederatedAuthRequestIssueDetailsBuilder {
+            pub fn federated_auth_request_issue_reason(
+                mut self,
+                federated_auth_request_issue_reason: impl Into<FederatedAuthRequestIssueReason>,
+            ) -> Self {
+                self.federated_auth_request_issue_reason =
+                    Some(federated_auth_request_issue_reason.into());
+                self
+            }
+            pub fn build(self) -> Result<FederatedAuthRequestIssueDetails, String> {
+                Ok(FederatedAuthRequestIssueDetails {
+                    federated_auth_request_issue_reason: self
+                        .federated_auth_request_issue_reason
+                        .ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(federated_auth_request_issue_reason)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl FederatedAuthRequestIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.FederatedAuthRequestIssueDetails";
+        }
+        #[doc = "Represents the failure reason when a federated authentication reason fails.\nShould be updated alongside RequestIdTokenStatus in\nthird_party/blink/public/mojom/devtools/inspector_issue.mojom to include\nall cases except for success."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum FederatedAuthRequestIssueReason {
+            #[serde(rename = "ShouldEmbargo")]
+            ShouldEmbargo,
+            #[serde(rename = "TooManyRequests")]
+            TooManyRequests,
+            #[serde(rename = "WellKnownHttpNotFound")]
+            WellKnownHttpNotFound,
+            #[serde(rename = "WellKnownNoResponse")]
+            WellKnownNoResponse,
+            #[serde(rename = "WellKnownInvalidResponse")]
+            WellKnownInvalidResponse,
+            #[serde(rename = "WellKnownListEmpty")]
+            WellKnownListEmpty,
+            #[serde(rename = "WellKnownInvalidContentType")]
+            WellKnownInvalidContentType,
+            #[serde(rename = "ConfigNotInWellKnown")]
+            ConfigNotInWellKnown,
+            #[serde(rename = "WellKnownTooBig")]
+            WellKnownTooBig,
+            #[serde(rename = "ConfigHttpNotFound")]
+            ConfigHttpNotFound,
+            #[serde(rename = "ConfigNoResponse")]
+            ConfigNoResponse,
+            #[serde(rename = "ConfigInvalidResponse")]
+            ConfigInvalidResponse,
+            #[serde(rename = "ConfigInvalidContentType")]
+            ConfigInvalidContentType,
+            #[serde(rename = "ClientMetadataHttpNotFound")]
+            ClientMetadataHttpNotFound,
+            #[serde(rename = "ClientMetadataNoResponse")]
+            ClientMetadataNoResponse,
+            #[serde(rename = "ClientMetadataInvalidResponse")]
+            ClientMetadataInvalidResponse,
+            #[serde(rename = "ClientMetadataInvalidContentType")]
+            ClientMetadataInvalidContentType,
+            #[serde(rename = "IdpNotPotentiallyTrustworthy")]
+            IdpNotPotentiallyTrustworthy,
+            #[serde(rename = "DisabledInSettings")]
+            DisabledInSettings,
+            #[serde(rename = "DisabledInFlags")]
+            DisabledInFlags,
+            #[serde(rename = "ErrorFetchingSignin")]
+            ErrorFetchingSignin,
+            #[serde(rename = "InvalidSigninResponse")]
+            InvalidSigninResponse,
+            #[serde(rename = "AccountsHttpNotFound")]
+            AccountsHttpNotFound,
+            #[serde(rename = "AccountsNoResponse")]
+            AccountsNoResponse,
+            #[serde(rename = "AccountsInvalidResponse")]
+            AccountsInvalidResponse,
+            #[serde(rename = "AccountsListEmpty")]
+            AccountsListEmpty,
+            #[serde(rename = "AccountsInvalidContentType")]
+            AccountsInvalidContentType,
+            #[serde(rename = "IdTokenHttpNotFound")]
+            IdTokenHttpNotFound,
+            #[serde(rename = "IdTokenNoResponse")]
+            IdTokenNoResponse,
+            #[serde(rename = "IdTokenInvalidResponse")]
+            IdTokenInvalidResponse,
+            #[serde(rename = "IdTokenIdpErrorResponse")]
+            IdTokenIdpErrorResponse,
+            #[serde(rename = "IdTokenCrossSiteIdpErrorResponse")]
+            IdTokenCrossSiteIdpErrorResponse,
+            #[serde(rename = "IdTokenInvalidRequest")]
+            IdTokenInvalidRequest,
+            #[serde(rename = "IdTokenInvalidContentType")]
+            IdTokenInvalidContentType,
+            #[serde(rename = "ErrorIdToken")]
+            ErrorIdToken,
+            #[serde(rename = "Canceled")]
+            Canceled,
+            #[serde(rename = "RpPageNotVisible")]
+            RpPageNotVisible,
+            #[serde(rename = "SilentMediationFailure")]
+            SilentMediationFailure,
+            #[serde(rename = "ThirdPartyCookiesBlocked")]
+            ThirdPartyCookiesBlocked,
+            #[serde(rename = "NotSignedInWithIdp")]
+            NotSignedInWithIdp,
+            #[serde(rename = "MissingTransientUserActivation")]
+            MissingTransientUserActivation,
+            #[serde(rename = "ReplacedByActiveMode")]
+            ReplacedByActiveMode,
+            #[serde(rename = "InvalidFieldsSpecified")]
+            InvalidFieldsSpecified,
+            #[serde(rename = "RelyingPartyOriginIsOpaque")]
+            RelyingPartyOriginIsOpaque,
+            #[serde(rename = "TypeNotMatching")]
+            TypeNotMatching,
+            #[serde(rename = "UiDismissedNoEmbargo")]
+            UiDismissedNoEmbargo,
+            #[serde(rename = "CorsError")]
+            CorsError,
+            #[serde(rename = "SuppressedBySegmentationPlatform")]
+            SuppressedBySegmentationPlatform,
+        }
+        impl AsRef<str> for FederatedAuthRequestIssueReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    FederatedAuthRequestIssueReason::ShouldEmbargo => "ShouldEmbargo",
+                    FederatedAuthRequestIssueReason::TooManyRequests => "TooManyRequests",
+                    FederatedAuthRequestIssueReason::WellKnownHttpNotFound => {
+                        "WellKnownHttpNotFound"
+                    }
+                    FederatedAuthRequestIssueReason::WellKnownNoResponse => "WellKnownNoResponse",
+                    FederatedAuthRequestIssueReason::WellKnownInvalidResponse => {
+                        "WellKnownInvalidResponse"
+                    }
+                    FederatedAuthRequestIssueReason::WellKnownListEmpty => "WellKnownListEmpty",
+                    FederatedAuthRequestIssueReason::WellKnownInvalidContentType => {
+                        "WellKnownInvalidContentType"
+                    }
+                    FederatedAuthRequestIssueReason::ConfigNotInWellKnown => "ConfigNotInWellKnown",
+                    FederatedAuthRequestIssueReason::WellKnownTooBig => "WellKnownTooBig",
+                    FederatedAuthRequestIssueReason::ConfigHttpNotFound => "ConfigHttpNotFound",
+                    FederatedAuthRequestIssueReason::ConfigNoResponse => "ConfigNoResponse",
+                    FederatedAuthRequestIssueReason::ConfigInvalidResponse => {
+                        "ConfigInvalidResponse"
+                    }
+                    FederatedAuthRequestIssueReason::ConfigInvalidContentType => {
+                        "ConfigInvalidContentType"
+                    }
+                    FederatedAuthRequestIssueReason::ClientMetadataHttpNotFound => {
+                        "ClientMetadataHttpNotFound"
+                    }
+                    FederatedAuthRequestIssueReason::ClientMetadataNoResponse => {
+                        "ClientMetadataNoResponse"
+                    }
+                    FederatedAuthRequestIssueReason::ClientMetadataInvalidResponse => {
+                        "ClientMetadataInvalidResponse"
+                    }
+                    FederatedAuthRequestIssueReason::ClientMetadataInvalidContentType => {
+                        "ClientMetadataInvalidContentType"
+                    }
+                    FederatedAuthRequestIssueReason::IdpNotPotentiallyTrustworthy => {
+                        "IdpNotPotentiallyTrustworthy"
+                    }
+                    FederatedAuthRequestIssueReason::DisabledInSettings => "DisabledInSettings",
+                    FederatedAuthRequestIssueReason::DisabledInFlags => "DisabledInFlags",
+                    FederatedAuthRequestIssueReason::ErrorFetchingSignin => "ErrorFetchingSignin",
+                    FederatedAuthRequestIssueReason::InvalidSigninResponse => {
+                        "InvalidSigninResponse"
+                    }
+                    FederatedAuthRequestIssueReason::AccountsHttpNotFound => "AccountsHttpNotFound",
+                    FederatedAuthRequestIssueReason::AccountsNoResponse => "AccountsNoResponse",
+                    FederatedAuthRequestIssueReason::AccountsInvalidResponse => {
+                        "AccountsInvalidResponse"
+                    }
+                    FederatedAuthRequestIssueReason::AccountsListEmpty => "AccountsListEmpty",
+                    FederatedAuthRequestIssueReason::AccountsInvalidContentType => {
+                        "AccountsInvalidContentType"
+                    }
+                    FederatedAuthRequestIssueReason::IdTokenHttpNotFound => "IdTokenHttpNotFound",
+                    FederatedAuthRequestIssueReason::IdTokenNoResponse => "IdTokenNoResponse",
+                    FederatedAuthRequestIssueReason::IdTokenInvalidResponse => {
+                        "IdTokenInvalidResponse"
+                    }
+                    FederatedAuthRequestIssueReason::IdTokenIdpErrorResponse => {
+                        "IdTokenIdpErrorResponse"
+                    }
+                    FederatedAuthRequestIssueReason::IdTokenCrossSiteIdpErrorResponse => {
+                        "IdTokenCrossSiteIdpErrorResponse"
+                    }
+                    FederatedAuthRequestIssueReason::IdTokenInvalidRequest => {
+                        "IdTokenInvalidRequest"
+                    }
+                    FederatedAuthRequestIssueReason::IdTokenInvalidContentType => {
+                        "IdTokenInvalidContentType"
+                    }
+                    FederatedAuthRequestIssueReason::ErrorIdToken => "ErrorIdToken",
+                    FederatedAuthRequestIssueReason::Canceled => "Canceled",
+                    FederatedAuthRequestIssueReason::RpPageNotVisible => "RpPageNotVisible",
+                    FederatedAuthRequestIssueReason::SilentMediationFailure => {
+                        "SilentMediationFailure"
+                    }
+                    FederatedAuthRequestIssueReason::ThirdPartyCookiesBlocked => {
+                        "ThirdPartyCookiesBlocked"
+                    }
+                    FederatedAuthRequestIssueReason::NotSignedInWithIdp => "NotSignedInWithIdp",
+                    FederatedAuthRequestIssueReason::MissingTransientUserActivation => {
+                        "MissingTransientUserActivation"
+                    }
+                    FederatedAuthRequestIssueReason::ReplacedByActiveMode => "ReplacedByActiveMode",
+                    FederatedAuthRequestIssueReason::InvalidFieldsSpecified => {
+                        "InvalidFieldsSpecified"
+                    }
+                    FederatedAuthRequestIssueReason::RelyingPartyOriginIsOpaque => {
+                        "RelyingPartyOriginIsOpaque"
+                    }
+                    FederatedAuthRequestIssueReason::TypeNotMatching => "TypeNotMatching",
+                    FederatedAuthRequestIssueReason::UiDismissedNoEmbargo => "UiDismissedNoEmbargo",
+                    FederatedAuthRequestIssueReason::CorsError => "CorsError",
+                    FederatedAuthRequestIssueReason::SuppressedBySegmentationPlatform => {
+                        "SuppressedBySegmentationPlatform"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for FederatedAuthRequestIssueReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "ShouldEmbargo" | "shouldembargo" => {
+                        Ok(FederatedAuthRequestIssueReason::ShouldEmbargo)
+                    }
+                    "TooManyRequests" | "toomanyrequests" => {
+                        Ok(FederatedAuthRequestIssueReason::TooManyRequests)
+                    }
+                    "WellKnownHttpNotFound" | "wellknownhttpnotfound" => {
+                        Ok(FederatedAuthRequestIssueReason::WellKnownHttpNotFound)
+                    }
+                    "WellKnownNoResponse" | "wellknownnoresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::WellKnownNoResponse)
+                    }
+                    "WellKnownInvalidResponse" | "wellknowninvalidresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::WellKnownInvalidResponse)
+                    }
+                    "WellKnownListEmpty" | "wellknownlistempty" => {
+                        Ok(FederatedAuthRequestIssueReason::WellKnownListEmpty)
+                    }
+                    "WellKnownInvalidContentType" | "wellknowninvalidcontenttype" => {
+                        Ok(FederatedAuthRequestIssueReason::WellKnownInvalidContentType)
+                    }
+                    "ConfigNotInWellKnown" | "confignotinwellknown" => {
+                        Ok(FederatedAuthRequestIssueReason::ConfigNotInWellKnown)
+                    }
+                    "WellKnownTooBig" | "wellknowntoobig" => {
+                        Ok(FederatedAuthRequestIssueReason::WellKnownTooBig)
+                    }
+                    "ConfigHttpNotFound" | "confighttpnotfound" => {
+                        Ok(FederatedAuthRequestIssueReason::ConfigHttpNotFound)
+                    }
+                    "ConfigNoResponse" | "confignoresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::ConfigNoResponse)
+                    }
+                    "ConfigInvalidResponse" | "configinvalidresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::ConfigInvalidResponse)
+                    }
+                    "ConfigInvalidContentType" | "configinvalidcontenttype" => {
+                        Ok(FederatedAuthRequestIssueReason::ConfigInvalidContentType)
+                    }
+                    "ClientMetadataHttpNotFound" | "clientmetadatahttpnotfound" => {
+                        Ok(FederatedAuthRequestIssueReason::ClientMetadataHttpNotFound)
+                    }
+                    "ClientMetadataNoResponse" | "clientmetadatanoresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::ClientMetadataNoResponse)
+                    }
+                    "ClientMetadataInvalidResponse" | "clientmetadatainvalidresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::ClientMetadataInvalidResponse)
+                    }
+                    "ClientMetadataInvalidContentType" | "clientmetadatainvalidcontenttype" => {
+                        Ok(FederatedAuthRequestIssueReason::ClientMetadataInvalidContentType)
+                    }
+                    "IdpNotPotentiallyTrustworthy" | "idpnotpotentiallytrustworthy" => {
+                        Ok(FederatedAuthRequestIssueReason::IdpNotPotentiallyTrustworthy)
+                    }
+                    "DisabledInSettings" | "disabledinsettings" => {
+                        Ok(FederatedAuthRequestIssueReason::DisabledInSettings)
+                    }
+                    "DisabledInFlags" | "disabledinflags" => {
+                        Ok(FederatedAuthRequestIssueReason::DisabledInFlags)
+                    }
+                    "ErrorFetchingSignin" | "errorfetchingsignin" => {
+                        Ok(FederatedAuthRequestIssueReason::ErrorFetchingSignin)
+                    }
+                    "InvalidSigninResponse" | "invalidsigninresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::InvalidSigninResponse)
+                    }
+                    "AccountsHttpNotFound" | "accountshttpnotfound" => {
+                        Ok(FederatedAuthRequestIssueReason::AccountsHttpNotFound)
+                    }
+                    "AccountsNoResponse" | "accountsnoresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::AccountsNoResponse)
+                    }
+                    "AccountsInvalidResponse" | "accountsinvalidresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::AccountsInvalidResponse)
+                    }
+                    "AccountsListEmpty" | "accountslistempty" => {
+                        Ok(FederatedAuthRequestIssueReason::AccountsListEmpty)
+                    }
+                    "AccountsInvalidContentType" | "accountsinvalidcontenttype" => {
+                        Ok(FederatedAuthRequestIssueReason::AccountsInvalidContentType)
+                    }
+                    "IdTokenHttpNotFound" | "idtokenhttpnotfound" => {
+                        Ok(FederatedAuthRequestIssueReason::IdTokenHttpNotFound)
+                    }
+                    "IdTokenNoResponse" | "idtokennoresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::IdTokenNoResponse)
+                    }
+                    "IdTokenInvalidResponse" | "idtokeninvalidresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::IdTokenInvalidResponse)
+                    }
+                    "IdTokenIdpErrorResponse" | "idtokenidperrorresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::IdTokenIdpErrorResponse)
+                    }
+                    "IdTokenCrossSiteIdpErrorResponse" | "idtokencrosssiteidperrorresponse" => {
+                        Ok(FederatedAuthRequestIssueReason::IdTokenCrossSiteIdpErrorResponse)
+                    }
+                    "IdTokenInvalidRequest" | "idtokeninvalidrequest" => {
+                        Ok(FederatedAuthRequestIssueReason::IdTokenInvalidRequest)
+                    }
+                    "IdTokenInvalidContentType" | "idtokeninvalidcontenttype" => {
+                        Ok(FederatedAuthRequestIssueReason::IdTokenInvalidContentType)
+                    }
+                    "ErrorIdToken" | "erroridtoken" => {
+                        Ok(FederatedAuthRequestIssueReason::ErrorIdToken)
+                    }
+                    "Canceled" | "canceled" => Ok(FederatedAuthRequestIssueReason::Canceled),
+                    "RpPageNotVisible" | "rppagenotvisible" => {
+                        Ok(FederatedAuthRequestIssueReason::RpPageNotVisible)
+                    }
+                    "SilentMediationFailure" | "silentmediationfailure" => {
+                        Ok(FederatedAuthRequestIssueReason::SilentMediationFailure)
+                    }
+                    "ThirdPartyCookiesBlocked" | "thirdpartycookiesblocked" => {
+                        Ok(FederatedAuthRequestIssueReason::ThirdPartyCookiesBlocked)
+                    }
+                    "NotSignedInWithIdp" | "notsignedinwithidp" => {
+                        Ok(FederatedAuthRequestIssueReason::NotSignedInWithIdp)
+                    }
+                    "MissingTransientUserActivation" | "missingtransientuseractivation" => {
+                        Ok(FederatedAuthRequestIssueReason::MissingTransientUserActivation)
+                    }
+                    "ReplacedByActiveMode" | "replacedbyactivemode" => {
+                        Ok(FederatedAuthRequestIssueReason::ReplacedByActiveMode)
+                    }
+                    "InvalidFieldsSpecified" | "invalidfieldsspecified" => {
+                        Ok(FederatedAuthRequestIssueReason::InvalidFieldsSpecified)
+                    }
+                    "RelyingPartyOriginIsOpaque" | "relyingpartyoriginisopaque" => {
+                        Ok(FederatedAuthRequestIssueReason::RelyingPartyOriginIsOpaque)
+                    }
+                    "TypeNotMatching" | "typenotmatching" => {
+                        Ok(FederatedAuthRequestIssueReason::TypeNotMatching)
+                    }
+                    "UiDismissedNoEmbargo" | "uidismissednoembargo" => {
+                        Ok(FederatedAuthRequestIssueReason::UiDismissedNoEmbargo)
+                    }
+                    "CorsError" | "corserror" => Ok(FederatedAuthRequestIssueReason::CorsError),
+                    "SuppressedBySegmentationPlatform" | "suppressedbysegmentationplatform" => {
+                        Ok(FederatedAuthRequestIssueReason::SuppressedBySegmentationPlatform)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FederatedAuthUserInfoRequestIssueDetails {
+            #[serde(rename = "federatedAuthUserInfoRequestIssueReason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub federated_auth_user_info_request_issue_reason:
+                FederatedAuthUserInfoRequestIssueReason,
+        }
+        impl FederatedAuthUserInfoRequestIssueDetails {
+            pub fn new(
+                federated_auth_user_info_request_issue_reason: impl Into<
+                    FederatedAuthUserInfoRequestIssueReason,
+                >,
+            ) -> Self {
+                Self {
+                    federated_auth_user_info_request_issue_reason:
+                        federated_auth_user_info_request_issue_reason.into(),
+                }
+            }
+        }
+        impl FederatedAuthUserInfoRequestIssueDetails {
+            pub fn builder() -> FederatedAuthUserInfoRequestIssueDetailsBuilder {
+                FederatedAuthUserInfoRequestIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FederatedAuthUserInfoRequestIssueDetailsBuilder {
+            federated_auth_user_info_request_issue_reason:
+                Option<FederatedAuthUserInfoRequestIssueReason>,
+        }
+        impl FederatedAuthUserInfoRequestIssueDetailsBuilder {
+            pub fn federated_auth_user_info_request_issue_reason(
+                mut self,
+                federated_auth_user_info_request_issue_reason: impl Into<
+                    FederatedAuthUserInfoRequestIssueReason,
+                >,
+            ) -> Self {
+                self.federated_auth_user_info_request_issue_reason =
+                    Some(federated_auth_user_info_request_issue_reason.into());
+                self
+            }
+            pub fn build(self) -> Result<FederatedAuthUserInfoRequestIssueDetails, String> {
+                Ok(FederatedAuthUserInfoRequestIssueDetails {
+                    federated_auth_user_info_request_issue_reason: self
+                        .federated_auth_user_info_request_issue_reason
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(federated_auth_user_info_request_issue_reason)
+                            )
+                        })?,
+                })
+            }
+        }
+        impl FederatedAuthUserInfoRequestIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.FederatedAuthUserInfoRequestIssueDetails";
+        }
+        #[doc = "Represents the failure reason when a getUserInfo() call fails.\nShould be updated alongside FederatedAuthUserInfoRequestResult in\nthird_party/blink/public/mojom/devtools/inspector_issue.mojom."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum FederatedAuthUserInfoRequestIssueReason {
+            #[serde(rename = "NotSameOrigin")]
+            NotSameOrigin,
+            #[serde(rename = "NotIframe")]
+            NotIframe,
+            #[serde(rename = "NotPotentiallyTrustworthy")]
+            NotPotentiallyTrustworthy,
+            #[serde(rename = "NoApiPermission")]
+            NoApiPermission,
+            #[serde(rename = "NotSignedInWithIdp")]
+            NotSignedInWithIdp,
+            #[serde(rename = "NoAccountSharingPermission")]
+            NoAccountSharingPermission,
+            #[serde(rename = "InvalidConfigOrWellKnown")]
+            InvalidConfigOrWellKnown,
+            #[serde(rename = "InvalidAccountsResponse")]
+            InvalidAccountsResponse,
+            #[serde(rename = "NoReturningUserFromFetchedAccounts")]
+            NoReturningUserFromFetchedAccounts,
+        }
+        impl AsRef<str> for FederatedAuthUserInfoRequestIssueReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    FederatedAuthUserInfoRequestIssueReason::NotSameOrigin => "NotSameOrigin",
+                    FederatedAuthUserInfoRequestIssueReason::NotIframe => "NotIframe",
+                    FederatedAuthUserInfoRequestIssueReason::NotPotentiallyTrustworthy => {
+                        "NotPotentiallyTrustworthy"
+                    }
+                    FederatedAuthUserInfoRequestIssueReason::NoApiPermission => "NoApiPermission",
+                    FederatedAuthUserInfoRequestIssueReason::NotSignedInWithIdp => {
+                        "NotSignedInWithIdp"
+                    }
+                    FederatedAuthUserInfoRequestIssueReason::NoAccountSharingPermission => {
+                        "NoAccountSharingPermission"
+                    }
+                    FederatedAuthUserInfoRequestIssueReason::InvalidConfigOrWellKnown => {
+                        "InvalidConfigOrWellKnown"
+                    }
+                    FederatedAuthUserInfoRequestIssueReason::InvalidAccountsResponse => {
+                        "InvalidAccountsResponse"
+                    }
+                    FederatedAuthUserInfoRequestIssueReason::NoReturningUserFromFetchedAccounts => {
+                        "NoReturningUserFromFetchedAccounts"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for FederatedAuthUserInfoRequestIssueReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s { "NotSameOrigin" | "notsameorigin" => Ok (FederatedAuthUserInfoRequestIssueReason :: NotSameOrigin) , "NotIframe" | "notiframe" => Ok (FederatedAuthUserInfoRequestIssueReason :: NotIframe) , "NotPotentiallyTrustworthy" | "notpotentiallytrustworthy" => Ok (FederatedAuthUserInfoRequestIssueReason :: NotPotentiallyTrustworthy) , "NoApiPermission" | "noapipermission" => Ok (FederatedAuthUserInfoRequestIssueReason :: NoApiPermission) , "NotSignedInWithIdp" | "notsignedinwithidp" => Ok (FederatedAuthUserInfoRequestIssueReason :: NotSignedInWithIdp) , "NoAccountSharingPermission" | "noaccountsharingpermission" => Ok (FederatedAuthUserInfoRequestIssueReason :: NoAccountSharingPermission) , "InvalidConfigOrWellKnown" | "invalidconfigorwellknown" => Ok (FederatedAuthUserInfoRequestIssueReason :: InvalidConfigOrWellKnown) , "InvalidAccountsResponse" | "invalidaccountsresponse" => Ok (FederatedAuthUserInfoRequestIssueReason :: InvalidAccountsResponse) , "NoReturningUserFromFetchedAccounts" | "noreturninguserfromfetchedaccounts" => Ok (FederatedAuthUserInfoRequestIssueReason :: NoReturningUserFromFetchedAccounts) , _ => Err (s . to_string ()) }
+            }
+        }
+        #[doc = "This issue tracks client hints related issues. It's used to deprecate old\nfeatures, encourage the use of new ones, and provide general guidance.\n[ClientHintIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-ClientHintIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClientHintIssueDetails {
+            #[serde(rename = "sourceCodeLocation")]
+            pub source_code_location: SourceCodeLocation,
+            #[serde(rename = "clientHintIssueReason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub client_hint_issue_reason: ClientHintIssueReason,
+        }
+        impl ClientHintIssueDetails {
+            pub fn new(
+                source_code_location: impl Into<SourceCodeLocation>,
+                client_hint_issue_reason: impl Into<ClientHintIssueReason>,
+            ) -> Self {
+                Self {
+                    source_code_location: source_code_location.into(),
+                    client_hint_issue_reason: client_hint_issue_reason.into(),
+                }
+            }
+        }
+        impl ClientHintIssueDetails {
+            pub fn builder() -> ClientHintIssueDetailsBuilder {
+                ClientHintIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClientHintIssueDetailsBuilder {
+            source_code_location: Option<SourceCodeLocation>,
+            client_hint_issue_reason: Option<ClientHintIssueReason>,
+        }
+        impl ClientHintIssueDetailsBuilder {
+            pub fn source_code_location(
+                mut self,
+                source_code_location: impl Into<SourceCodeLocation>,
+            ) -> Self {
+                self.source_code_location = Some(source_code_location.into());
+                self
+            }
+            pub fn client_hint_issue_reason(
+                mut self,
+                client_hint_issue_reason: impl Into<ClientHintIssueReason>,
+            ) -> Self {
+                self.client_hint_issue_reason = Some(client_hint_issue_reason.into());
+                self
+            }
+            pub fn build(self) -> Result<ClientHintIssueDetails, String> {
+                Ok(ClientHintIssueDetails {
+                    source_code_location: self.source_code_location.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(source_code_location)
+                        )
+                    })?,
+                    client_hint_issue_reason: self.client_hint_issue_reason.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(client_hint_issue_reason)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl ClientHintIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.ClientHintIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FailedRequestInfo {
+            #[doc = "The URL that failed to load."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "The failure message for the failed request."]
+            #[serde(rename = "failureMessage")]
+            pub failure_message: String,
+            #[serde(rename = "requestId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request_id: Option<super::network::RequestId>,
+        }
+        impl FailedRequestInfo {
+            pub fn new(url: impl Into<String>, failure_message: impl Into<String>) -> Self {
+                Self {
+                    url: url.into(),
+                    failure_message: failure_message.into(),
+                    request_id: None,
+                }
+            }
+        }
+        impl FailedRequestInfo {
+            pub fn builder() -> FailedRequestInfoBuilder {
+                FailedRequestInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FailedRequestInfoBuilder {
+            url: Option<String>,
+            failure_message: Option<String>,
+            request_id: Option<super::network::RequestId>,
+        }
+        impl FailedRequestInfoBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn failure_message(mut self, failure_message: impl Into<String>) -> Self {
+                self.failure_message = Some(failure_message.into());
+                self
+            }
+            pub fn request_id(mut self, request_id: impl Into<super::network::RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn build(self) -> Result<FailedRequestInfo, String> {
+                Ok(FailedRequestInfo {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    failure_message: self.failure_message.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(failure_message))
+                    })?,
+                    request_id: self.request_id,
+                })
+            }
+        }
+        impl FailedRequestInfo {
+            pub const IDENTIFIER: &'static str = "Audits.FailedRequestInfo";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PartitioningBlobUrlInfo {
+            #[serde(rename = "BlockedCrossPartitionFetching")]
+            BlockedCrossPartitionFetching,
+            #[serde(rename = "EnforceNoopenerForNavigation")]
+            EnforceNoopenerForNavigation,
+        }
+        impl AsRef<str> for PartitioningBlobUrlInfo {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PartitioningBlobUrlInfo::BlockedCrossPartitionFetching => {
+                        "BlockedCrossPartitionFetching"
+                    }
+                    PartitioningBlobUrlInfo::EnforceNoopenerForNavigation => {
+                        "EnforceNoopenerForNavigation"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for PartitioningBlobUrlInfo {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "BlockedCrossPartitionFetching" | "blockedcrosspartitionfetching" => {
+                        Ok(PartitioningBlobUrlInfo::BlockedCrossPartitionFetching)
+                    }
+                    "EnforceNoopenerForNavigation" | "enforcenoopenerfornavigation" => {
+                        Ok(PartitioningBlobUrlInfo::EnforceNoopenerForNavigation)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PartitioningBlobUrlIssueDetails {
+            #[doc = "The BlobURL that failed to load."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Additional information about the Partitioning Blob URL issue."]
+            #[serde(rename = "partitioningBlobURLInfo")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub partitioning_blob_url_info: PartitioningBlobUrlInfo,
+        }
+        impl PartitioningBlobUrlIssueDetails {
+            pub fn new(
+                url: impl Into<String>,
+                partitioning_blob_url_info: impl Into<PartitioningBlobUrlInfo>,
+            ) -> Self {
+                Self {
+                    url: url.into(),
+                    partitioning_blob_url_info: partitioning_blob_url_info.into(),
+                }
+            }
+        }
+        impl PartitioningBlobUrlIssueDetails {
+            pub fn builder() -> PartitioningBlobUrlIssueDetailsBuilder {
+                PartitioningBlobUrlIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PartitioningBlobUrlIssueDetailsBuilder {
+            url: Option<String>,
+            partitioning_blob_url_info: Option<PartitioningBlobUrlInfo>,
+        }
+        impl PartitioningBlobUrlIssueDetailsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn partitioning_blob_url_info(
+                mut self,
+                partitioning_blob_url_info: impl Into<PartitioningBlobUrlInfo>,
+            ) -> Self {
+                self.partitioning_blob_url_info = Some(partitioning_blob_url_info.into());
+                self
+            }
+            pub fn build(self) -> Result<PartitioningBlobUrlIssueDetails, String> {
+                Ok(PartitioningBlobUrlIssueDetails {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    partitioning_blob_url_info: self.partitioning_blob_url_info.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(partitioning_blob_url_info)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl PartitioningBlobUrlIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.PartitioningBlobURLIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ElementAccessibilityIssueReason {
+            #[serde(rename = "DisallowedSelectChild")]
+            DisallowedSelectChild,
+            #[serde(rename = "DisallowedOptGroupChild")]
+            DisallowedOptGroupChild,
+            #[serde(rename = "NonPhrasingContentOptionChild")]
+            NonPhrasingContentOptionChild,
+            #[serde(rename = "InteractiveContentOptionChild")]
+            InteractiveContentOptionChild,
+            #[serde(rename = "InteractiveContentLegendChild")]
+            InteractiveContentLegendChild,
+            #[serde(rename = "InteractiveContentSummaryDescendant")]
+            InteractiveContentSummaryDescendant,
+        }
+        impl AsRef<str> for ElementAccessibilityIssueReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ElementAccessibilityIssueReason::DisallowedSelectChild => {
+                        "DisallowedSelectChild"
+                    }
+                    ElementAccessibilityIssueReason::DisallowedOptGroupChild => {
+                        "DisallowedOptGroupChild"
+                    }
+                    ElementAccessibilityIssueReason::NonPhrasingContentOptionChild => {
+                        "NonPhrasingContentOptionChild"
+                    }
+                    ElementAccessibilityIssueReason::InteractiveContentOptionChild => {
+                        "InteractiveContentOptionChild"
+                    }
+                    ElementAccessibilityIssueReason::InteractiveContentLegendChild => {
+                        "InteractiveContentLegendChild"
+                    }
+                    ElementAccessibilityIssueReason::InteractiveContentSummaryDescendant => {
+                        "InteractiveContentSummaryDescendant"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for ElementAccessibilityIssueReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "DisallowedSelectChild" | "disallowedselectchild" => {
+                        Ok(ElementAccessibilityIssueReason::DisallowedSelectChild)
+                    }
+                    "DisallowedOptGroupChild" | "disallowedoptgroupchild" => {
+                        Ok(ElementAccessibilityIssueReason::DisallowedOptGroupChild)
+                    }
+                    "NonPhrasingContentOptionChild" | "nonphrasingcontentoptionchild" => {
+                        Ok(ElementAccessibilityIssueReason::NonPhrasingContentOptionChild)
+                    }
+                    "InteractiveContentOptionChild" | "interactivecontentoptionchild" => {
+                        Ok(ElementAccessibilityIssueReason::InteractiveContentOptionChild)
+                    }
+                    "InteractiveContentLegendChild" | "interactivecontentlegendchild" => {
+                        Ok(ElementAccessibilityIssueReason::InteractiveContentLegendChild)
+                    }
+                    "InteractiveContentSummaryDescendant"
+                    | "interactivecontentsummarydescendant" => {
+                        Ok(ElementAccessibilityIssueReason::InteractiveContentSummaryDescendant)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "This issue warns about errors in the select or summary element content model.\n[ElementAccessibilityIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-ElementAccessibilityIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ElementAccessibilityIssueDetails {
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::BackendNodeId,
+            #[serde(rename = "elementAccessibilityIssueReason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub element_accessibility_issue_reason: ElementAccessibilityIssueReason,
+            #[serde(rename = "hasDisallowedAttributes")]
+            pub has_disallowed_attributes: bool,
+        }
+        impl ElementAccessibilityIssueDetails {
+            pub fn new(
+                node_id: impl Into<super::dom::BackendNodeId>,
+                element_accessibility_issue_reason: impl Into<ElementAccessibilityIssueReason>,
+                has_disallowed_attributes: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    element_accessibility_issue_reason: element_accessibility_issue_reason.into(),
+                    has_disallowed_attributes: has_disallowed_attributes.into(),
+                }
+            }
+        }
+        impl ElementAccessibilityIssueDetails {
+            pub fn builder() -> ElementAccessibilityIssueDetailsBuilder {
+                ElementAccessibilityIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ElementAccessibilityIssueDetailsBuilder {
+            node_id: Option<super::dom::BackendNodeId>,
+            element_accessibility_issue_reason: Option<ElementAccessibilityIssueReason>,
+            has_disallowed_attributes: Option<bool>,
+        }
+        impl ElementAccessibilityIssueDetailsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::BackendNodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn element_accessibility_issue_reason(
+                mut self,
+                element_accessibility_issue_reason: impl Into<ElementAccessibilityIssueReason>,
+            ) -> Self {
+                self.element_accessibility_issue_reason =
+                    Some(element_accessibility_issue_reason.into());
+                self
+            }
+            pub fn has_disallowed_attributes(
+                mut self,
+                has_disallowed_attributes: impl Into<bool>,
+            ) -> Self {
+                self.has_disallowed_attributes = Some(has_disallowed_attributes.into());
+                self
+            }
+            pub fn build(self) -> Result<ElementAccessibilityIssueDetails, String> {
+                Ok(ElementAccessibilityIssueDetails {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    element_accessibility_issue_reason: self
+                        .element_accessibility_issue_reason
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(element_accessibility_issue_reason)
+                            )
+                        })?,
+                    has_disallowed_attributes: self.has_disallowed_attributes.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(has_disallowed_attributes)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl ElementAccessibilityIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.ElementAccessibilityIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum StyleSheetLoadingIssueReason {
+            #[serde(rename = "LateImportRule")]
+            LateImportRule,
+            #[serde(rename = "RequestFailed")]
+            RequestFailed,
+        }
+        impl AsRef<str> for StyleSheetLoadingIssueReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    StyleSheetLoadingIssueReason::LateImportRule => "LateImportRule",
+                    StyleSheetLoadingIssueReason::RequestFailed => "RequestFailed",
+                }
+            }
+        }
+        impl ::std::str::FromStr for StyleSheetLoadingIssueReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "LateImportRule" | "lateimportrule" => {
+                        Ok(StyleSheetLoadingIssueReason::LateImportRule)
+                    }
+                    "RequestFailed" | "requestfailed" => {
+                        Ok(StyleSheetLoadingIssueReason::RequestFailed)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "This issue warns when a referenced stylesheet couldn't be loaded.\n[StylesheetLoadingIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-StylesheetLoadingIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StylesheetLoadingIssueDetails {
+            #[doc = "Source code position that referenced the failing stylesheet."]
+            #[serde(rename = "sourceCodeLocation")]
+            pub source_code_location: SourceCodeLocation,
+            #[doc = "Reason why the stylesheet couldn't be loaded."]
+            #[serde(rename = "styleSheetLoadingIssueReason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub style_sheet_loading_issue_reason: StyleSheetLoadingIssueReason,
+            #[doc = "Contains additional info when the failure was due to a request."]
+            #[serde(rename = "failedRequestInfo")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub failed_request_info: Option<FailedRequestInfo>,
+        }
+        impl StylesheetLoadingIssueDetails {
+            pub fn new(
+                source_code_location: impl Into<SourceCodeLocation>,
+                style_sheet_loading_issue_reason: impl Into<StyleSheetLoadingIssueReason>,
+            ) -> Self {
+                Self {
+                    source_code_location: source_code_location.into(),
+                    style_sheet_loading_issue_reason: style_sheet_loading_issue_reason.into(),
+                    failed_request_info: None,
+                }
+            }
+        }
+        impl StylesheetLoadingIssueDetails {
+            pub fn builder() -> StylesheetLoadingIssueDetailsBuilder {
+                StylesheetLoadingIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StylesheetLoadingIssueDetailsBuilder {
+            source_code_location: Option<SourceCodeLocation>,
+            style_sheet_loading_issue_reason: Option<StyleSheetLoadingIssueReason>,
+            failed_request_info: Option<FailedRequestInfo>,
+        }
+        impl StylesheetLoadingIssueDetailsBuilder {
+            pub fn source_code_location(
+                mut self,
+                source_code_location: impl Into<SourceCodeLocation>,
+            ) -> Self {
+                self.source_code_location = Some(source_code_location.into());
+                self
+            }
+            pub fn style_sheet_loading_issue_reason(
+                mut self,
+                style_sheet_loading_issue_reason: impl Into<StyleSheetLoadingIssueReason>,
+            ) -> Self {
+                self.style_sheet_loading_issue_reason =
+                    Some(style_sheet_loading_issue_reason.into());
+                self
+            }
+            pub fn failed_request_info(
+                mut self,
+                failed_request_info: impl Into<FailedRequestInfo>,
+            ) -> Self {
+                self.failed_request_info = Some(failed_request_info.into());
+                self
+            }
+            pub fn build(self) -> Result<StylesheetLoadingIssueDetails, String> {
+                Ok(StylesheetLoadingIssueDetails {
+                    source_code_location: self.source_code_location.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(source_code_location)
+                        )
+                    })?,
+                    style_sheet_loading_issue_reason: self
+                        .style_sheet_loading_issue_reason
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(style_sheet_loading_issue_reason)
+                            )
+                        })?,
+                    failed_request_info: self.failed_request_info,
+                })
+            }
+        }
+        impl StylesheetLoadingIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.StylesheetLoadingIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PropertyRuleIssueReason {
+            #[serde(rename = "InvalidSyntax")]
+            InvalidSyntax,
+            #[serde(rename = "InvalidInitialValue")]
+            InvalidInitialValue,
+            #[serde(rename = "InvalidInherits")]
+            InvalidInherits,
+            #[serde(rename = "InvalidName")]
+            InvalidName,
+        }
+        impl AsRef<str> for PropertyRuleIssueReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PropertyRuleIssueReason::InvalidSyntax => "InvalidSyntax",
+                    PropertyRuleIssueReason::InvalidInitialValue => "InvalidInitialValue",
+                    PropertyRuleIssueReason::InvalidInherits => "InvalidInherits",
+                    PropertyRuleIssueReason::InvalidName => "InvalidName",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PropertyRuleIssueReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "InvalidSyntax" | "invalidsyntax" => Ok(PropertyRuleIssueReason::InvalidSyntax),
+                    "InvalidInitialValue" | "invalidinitialvalue" => {
+                        Ok(PropertyRuleIssueReason::InvalidInitialValue)
+                    }
+                    "InvalidInherits" | "invalidinherits" => {
+                        Ok(PropertyRuleIssueReason::InvalidInherits)
+                    }
+                    "InvalidName" | "invalidname" => Ok(PropertyRuleIssueReason::InvalidName),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "This issue warns about errors in property rules that lead to property\nregistrations being ignored.\n[PropertyRuleIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-PropertyRuleIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PropertyRuleIssueDetails {
+            #[doc = "Source code position of the property rule."]
+            #[serde(rename = "sourceCodeLocation")]
+            pub source_code_location: SourceCodeLocation,
+            #[doc = "Reason why the property rule was discarded."]
+            #[serde(rename = "propertyRuleIssueReason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub property_rule_issue_reason: PropertyRuleIssueReason,
+            #[doc = "The value of the property rule property that failed to parse"]
+            #[serde(rename = "propertyValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub property_value: Option<String>,
+        }
+        impl PropertyRuleIssueDetails {
+            pub fn new(
+                source_code_location: impl Into<SourceCodeLocation>,
+                property_rule_issue_reason: impl Into<PropertyRuleIssueReason>,
+            ) -> Self {
+                Self {
+                    source_code_location: source_code_location.into(),
+                    property_rule_issue_reason: property_rule_issue_reason.into(),
+                    property_value: None,
+                }
+            }
+        }
+        impl PropertyRuleIssueDetails {
+            pub fn builder() -> PropertyRuleIssueDetailsBuilder {
+                PropertyRuleIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PropertyRuleIssueDetailsBuilder {
+            source_code_location: Option<SourceCodeLocation>,
+            property_rule_issue_reason: Option<PropertyRuleIssueReason>,
+            property_value: Option<String>,
+        }
+        impl PropertyRuleIssueDetailsBuilder {
+            pub fn source_code_location(
+                mut self,
+                source_code_location: impl Into<SourceCodeLocation>,
+            ) -> Self {
+                self.source_code_location = Some(source_code_location.into());
+                self
+            }
+            pub fn property_rule_issue_reason(
+                mut self,
+                property_rule_issue_reason: impl Into<PropertyRuleIssueReason>,
+            ) -> Self {
+                self.property_rule_issue_reason = Some(property_rule_issue_reason.into());
+                self
+            }
+            pub fn property_value(mut self, property_value: impl Into<String>) -> Self {
+                self.property_value = Some(property_value.into());
+                self
+            }
+            pub fn build(self) -> Result<PropertyRuleIssueDetails, String> {
+                Ok(PropertyRuleIssueDetails {
+                    source_code_location: self.source_code_location.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(source_code_location)
+                        )
+                    })?,
+                    property_rule_issue_reason: self.property_rule_issue_reason.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(property_rule_issue_reason)
+                            )
+                        },
+                    )?,
+                    property_value: self.property_value,
+                })
+            }
+        }
+        impl PropertyRuleIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.PropertyRuleIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum UserReidentificationIssueType {
+            #[serde(rename = "BlockedFrameNavigation")]
+            BlockedFrameNavigation,
+            #[serde(rename = "BlockedSubresource")]
+            BlockedSubresource,
+            #[serde(rename = "NoisedCanvasReadback")]
+            NoisedCanvasReadback,
+        }
+        impl AsRef<str> for UserReidentificationIssueType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    UserReidentificationIssueType::BlockedFrameNavigation => {
+                        "BlockedFrameNavigation"
+                    }
+                    UserReidentificationIssueType::BlockedSubresource => "BlockedSubresource",
+                    UserReidentificationIssueType::NoisedCanvasReadback => "NoisedCanvasReadback",
+                }
+            }
+        }
+        impl ::std::str::FromStr for UserReidentificationIssueType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "BlockedFrameNavigation" | "blockedframenavigation" => {
+                        Ok(UserReidentificationIssueType::BlockedFrameNavigation)
+                    }
+                    "BlockedSubresource" | "blockedsubresource" => {
+                        Ok(UserReidentificationIssueType::BlockedSubresource)
+                    }
+                    "NoisedCanvasReadback" | "noisedcanvasreadback" => {
+                        Ok(UserReidentificationIssueType::NoisedCanvasReadback)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "This issue warns about uses of APIs that may be considered misuse to\nre-identify users.\n[UserReidentificationIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-UserReidentificationIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UserReidentificationIssueDetails {
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: UserReidentificationIssueType,
+            #[doc = "Applies to BlockedFrameNavigation and BlockedSubresource issue types."]
+            #[serde(rename = "request")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request: Option<AffectedRequest>,
+            #[doc = "Applies to NoisedCanvasReadback issue type."]
+            #[serde(rename = "sourceCodeLocation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_code_location: Option<SourceCodeLocation>,
+        }
+        impl UserReidentificationIssueDetails {
+            pub fn new(r#type: impl Into<UserReidentificationIssueType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    request: None,
+                    source_code_location: None,
+                }
+            }
+        }
+        impl UserReidentificationIssueDetails {
+            pub fn builder() -> UserReidentificationIssueDetailsBuilder {
+                UserReidentificationIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UserReidentificationIssueDetailsBuilder {
+            r#type: Option<UserReidentificationIssueType>,
+            request: Option<AffectedRequest>,
+            source_code_location: Option<SourceCodeLocation>,
+        }
+        impl UserReidentificationIssueDetailsBuilder {
+            pub fn r#type(mut self, r#type: impl Into<UserReidentificationIssueType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn request(mut self, request: impl Into<AffectedRequest>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn source_code_location(
+                mut self,
+                source_code_location: impl Into<SourceCodeLocation>,
+            ) -> Self {
+                self.source_code_location = Some(source_code_location.into());
+                self
+            }
+            pub fn build(self) -> Result<UserReidentificationIssueDetails, String> {
+                Ok(UserReidentificationIssueDetails {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    request: self.request,
+                    source_code_location: self.source_code_location,
+                })
+            }
+        }
+        impl UserReidentificationIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.UserReidentificationIssueDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PermissionElementIssueType {
+            #[serde(rename = "InvalidType")]
+            InvalidType,
+            #[serde(rename = "FencedFrameDisallowed")]
+            FencedFrameDisallowed,
+            #[serde(rename = "CspFrameAncestorsMissing")]
+            CspFrameAncestorsMissing,
+            #[serde(rename = "PermissionsPolicyBlocked")]
+            PermissionsPolicyBlocked,
+            #[serde(rename = "PaddingRightUnsupported")]
+            PaddingRightUnsupported,
+            #[serde(rename = "PaddingBottomUnsupported")]
+            PaddingBottomUnsupported,
+            #[serde(rename = "InsetBoxShadowUnsupported")]
+            InsetBoxShadowUnsupported,
+            #[serde(rename = "RequestInProgress")]
+            RequestInProgress,
+            #[serde(rename = "UntrustedEvent")]
+            UntrustedEvent,
+            #[serde(rename = "RegistrationFailed")]
+            RegistrationFailed,
+            #[serde(rename = "TypeNotSupported")]
+            TypeNotSupported,
+            #[serde(rename = "InvalidTypeActivation")]
+            InvalidTypeActivation,
+            #[serde(rename = "SecurityChecksFailed")]
+            SecurityChecksFailed,
+            #[serde(rename = "ActivationDisabled")]
+            ActivationDisabled,
+            #[serde(rename = "GeolocationDeprecated")]
+            GeolocationDeprecated,
+            #[serde(rename = "InvalidDisplayStyle")]
+            InvalidDisplayStyle,
+            #[serde(rename = "NonOpaqueColor")]
+            NonOpaqueColor,
+            #[serde(rename = "LowContrast")]
+            LowContrast,
+            #[serde(rename = "FontSizeTooSmall")]
+            FontSizeTooSmall,
+            #[serde(rename = "FontSizeTooLarge")]
+            FontSizeTooLarge,
+            #[serde(rename = "InvalidSizeValue")]
+            InvalidSizeValue,
+        }
+        impl AsRef<str> for PermissionElementIssueType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PermissionElementIssueType::InvalidType => "InvalidType",
+                    PermissionElementIssueType::FencedFrameDisallowed => "FencedFrameDisallowed",
+                    PermissionElementIssueType::CspFrameAncestorsMissing => {
+                        "CspFrameAncestorsMissing"
+                    }
+                    PermissionElementIssueType::PermissionsPolicyBlocked => {
+                        "PermissionsPolicyBlocked"
+                    }
+                    PermissionElementIssueType::PaddingRightUnsupported => {
+                        "PaddingRightUnsupported"
+                    }
+                    PermissionElementIssueType::PaddingBottomUnsupported => {
+                        "PaddingBottomUnsupported"
+                    }
+                    PermissionElementIssueType::InsetBoxShadowUnsupported => {
+                        "InsetBoxShadowUnsupported"
+                    }
+                    PermissionElementIssueType::RequestInProgress => "RequestInProgress",
+                    PermissionElementIssueType::UntrustedEvent => "UntrustedEvent",
+                    PermissionElementIssueType::RegistrationFailed => "RegistrationFailed",
+                    PermissionElementIssueType::TypeNotSupported => "TypeNotSupported",
+                    PermissionElementIssueType::InvalidTypeActivation => "InvalidTypeActivation",
+                    PermissionElementIssueType::SecurityChecksFailed => "SecurityChecksFailed",
+                    PermissionElementIssueType::ActivationDisabled => "ActivationDisabled",
+                    PermissionElementIssueType::GeolocationDeprecated => "GeolocationDeprecated",
+                    PermissionElementIssueType::InvalidDisplayStyle => "InvalidDisplayStyle",
+                    PermissionElementIssueType::NonOpaqueColor => "NonOpaqueColor",
+                    PermissionElementIssueType::LowContrast => "LowContrast",
+                    PermissionElementIssueType::FontSizeTooSmall => "FontSizeTooSmall",
+                    PermissionElementIssueType::FontSizeTooLarge => "FontSizeTooLarge",
+                    PermissionElementIssueType::InvalidSizeValue => "InvalidSizeValue",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PermissionElementIssueType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "InvalidType" | "invalidtype" => Ok(PermissionElementIssueType::InvalidType),
+                    "FencedFrameDisallowed" | "fencedframedisallowed" => {
+                        Ok(PermissionElementIssueType::FencedFrameDisallowed)
+                    }
+                    "CspFrameAncestorsMissing" | "cspframeancestorsmissing" => {
+                        Ok(PermissionElementIssueType::CspFrameAncestorsMissing)
+                    }
+                    "PermissionsPolicyBlocked" | "permissionspolicyblocked" => {
+                        Ok(PermissionElementIssueType::PermissionsPolicyBlocked)
+                    }
+                    "PaddingRightUnsupported" | "paddingrightunsupported" => {
+                        Ok(PermissionElementIssueType::PaddingRightUnsupported)
+                    }
+                    "PaddingBottomUnsupported" | "paddingbottomunsupported" => {
+                        Ok(PermissionElementIssueType::PaddingBottomUnsupported)
+                    }
+                    "InsetBoxShadowUnsupported" | "insetboxshadowunsupported" => {
+                        Ok(PermissionElementIssueType::InsetBoxShadowUnsupported)
+                    }
+                    "RequestInProgress" | "requestinprogress" => {
+                        Ok(PermissionElementIssueType::RequestInProgress)
+                    }
+                    "UntrustedEvent" | "untrustedevent" => {
+                        Ok(PermissionElementIssueType::UntrustedEvent)
+                    }
+                    "RegistrationFailed" | "registrationfailed" => {
+                        Ok(PermissionElementIssueType::RegistrationFailed)
+                    }
+                    "TypeNotSupported" | "typenotsupported" => {
+                        Ok(PermissionElementIssueType::TypeNotSupported)
+                    }
+                    "InvalidTypeActivation" | "invalidtypeactivation" => {
+                        Ok(PermissionElementIssueType::InvalidTypeActivation)
+                    }
+                    "SecurityChecksFailed" | "securitychecksfailed" => {
+                        Ok(PermissionElementIssueType::SecurityChecksFailed)
+                    }
+                    "ActivationDisabled" | "activationdisabled" => {
+                        Ok(PermissionElementIssueType::ActivationDisabled)
+                    }
+                    "GeolocationDeprecated" | "geolocationdeprecated" => {
+                        Ok(PermissionElementIssueType::GeolocationDeprecated)
+                    }
+                    "InvalidDisplayStyle" | "invaliddisplaystyle" => {
+                        Ok(PermissionElementIssueType::InvalidDisplayStyle)
+                    }
+                    "NonOpaqueColor" | "nonopaquecolor" => {
+                        Ok(PermissionElementIssueType::NonOpaqueColor)
+                    }
+                    "LowContrast" | "lowcontrast" => Ok(PermissionElementIssueType::LowContrast),
+                    "FontSizeTooSmall" | "fontsizetoosmall" => {
+                        Ok(PermissionElementIssueType::FontSizeTooSmall)
+                    }
+                    "FontSizeTooLarge" | "fontsizetoolarge" => {
+                        Ok(PermissionElementIssueType::FontSizeTooLarge)
+                    }
+                    "InvalidSizeValue" | "invalidsizevalue" => {
+                        Ok(PermissionElementIssueType::InvalidSizeValue)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "This issue warns about improper usage of the <permission> element.\n[PermissionElementIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-PermissionElementIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PermissionElementIssueDetails {
+            #[serde(rename = "issueType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub issue_type: PermissionElementIssueType,
+            #[doc = "The value of the type attribute."]
+            #[serde(rename = "type")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub r#type: Option<String>,
+            #[doc = "The node ID of the <permission> element."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "True if the issue is a warning, false if it is an error."]
+            #[serde(rename = "isWarning")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_warning: Option<bool>,
+            #[doc = "Fields for message construction:\nUsed for messages that reference a specific permission name"]
+            #[serde(rename = "permissionName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub permission_name: Option<String>,
+            #[doc = "Used for messages about occlusion"]
+            #[serde(rename = "occluderNodeInfo")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub occluder_node_info: Option<String>,
+            #[doc = "Used for messages about occluder's parent"]
+            #[serde(rename = "occluderParentNodeInfo")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub occluder_parent_node_info: Option<String>,
+            #[doc = "Used for messages about activation disabled reason"]
+            #[serde(rename = "disableReason")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub disable_reason: Option<String>,
+        }
+        impl PermissionElementIssueDetails {
+            pub fn new(issue_type: impl Into<PermissionElementIssueType>) -> Self {
+                Self {
+                    issue_type: issue_type.into(),
+                    r#type: None,
+                    node_id: None,
+                    is_warning: None,
+                    permission_name: None,
+                    occluder_node_info: None,
+                    occluder_parent_node_info: None,
+                    disable_reason: None,
+                }
+            }
+        }
+        impl PermissionElementIssueDetails {
+            pub fn builder() -> PermissionElementIssueDetailsBuilder {
+                PermissionElementIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PermissionElementIssueDetailsBuilder {
+            issue_type: Option<PermissionElementIssueType>,
+            r#type: Option<String>,
+            node_id: Option<super::dom::BackendNodeId>,
+            is_warning: Option<bool>,
+            permission_name: Option<String>,
+            occluder_node_info: Option<String>,
+            occluder_parent_node_info: Option<String>,
+            disable_reason: Option<String>,
+        }
+        impl PermissionElementIssueDetailsBuilder {
+            pub fn issue_type(mut self, issue_type: impl Into<PermissionElementIssueType>) -> Self {
+                self.issue_type = Some(issue_type.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::BackendNodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn is_warning(mut self, is_warning: impl Into<bool>) -> Self {
+                self.is_warning = Some(is_warning.into());
+                self
+            }
+            pub fn permission_name(mut self, permission_name: impl Into<String>) -> Self {
+                self.permission_name = Some(permission_name.into());
+                self
+            }
+            pub fn occluder_node_info(mut self, occluder_node_info: impl Into<String>) -> Self {
+                self.occluder_node_info = Some(occluder_node_info.into());
+                self
+            }
+            pub fn occluder_parent_node_info(
+                mut self,
+                occluder_parent_node_info: impl Into<String>,
+            ) -> Self {
+                self.occluder_parent_node_info = Some(occluder_parent_node_info.into());
+                self
+            }
+            pub fn disable_reason(mut self, disable_reason: impl Into<String>) -> Self {
+                self.disable_reason = Some(disable_reason.into());
+                self
+            }
+            pub fn build(self) -> Result<PermissionElementIssueDetails, String> {
+                Ok(PermissionElementIssueDetails {
+                    issue_type: self.issue_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(issue_type))
+                    })?,
+                    r#type: self.r#type,
+                    node_id: self.node_id,
+                    is_warning: self.is_warning,
+                    permission_name: self.permission_name,
+                    occluder_node_info: self.occluder_node_info,
+                    occluder_parent_node_info: self.occluder_parent_node_info,
+                    disable_reason: self.disable_reason,
+                })
+            }
+        }
+        impl PermissionElementIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.PermissionElementIssueDetails";
+        }
+        #[doc = "A unique identifier for the type of issue. Each type may use one of the\noptional fields in InspectorIssueDetails to convey more specific\ninformation about the kind of issue."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum InspectorIssueCode {
+            #[serde(rename = "CookieIssue")]
+            CookieIssue,
+            #[serde(rename = "MixedContentIssue")]
+            MixedContentIssue,
+            #[serde(rename = "BlockedByResponseIssue")]
+            BlockedByResponseIssue,
+            #[serde(rename = "HeavyAdIssue")]
+            HeavyAdIssue,
+            #[serde(rename = "ContentSecurityPolicyIssue")]
+            ContentSecurityPolicyIssue,
+            #[serde(rename = "SharedArrayBufferIssue")]
+            SharedArrayBufferIssue,
+            #[serde(rename = "LowTextContrastIssue")]
+            LowTextContrastIssue,
+            #[serde(rename = "CorsIssue")]
+            CorsIssue,
+            #[serde(rename = "AttributionReportingIssue")]
+            AttributionReportingIssue,
+            #[serde(rename = "QuirksModeIssue")]
+            QuirksModeIssue,
+            #[serde(rename = "PartitioningBlobURLIssue")]
+            PartitioningBlobUrlIssue,
+            #[doc = "Deprecated"]
+            #[serde(rename = "NavigatorUserAgentIssue")]
+            NavigatorUserAgentIssue,
+            #[serde(rename = "GenericIssue")]
+            GenericIssue,
+            #[serde(rename = "DeprecationIssue")]
+            DeprecationIssue,
+            #[serde(rename = "ClientHintIssue")]
+            ClientHintIssue,
+            #[serde(rename = "FederatedAuthRequestIssue")]
+            FederatedAuthRequestIssue,
+            #[serde(rename = "BounceTrackingIssue")]
+            BounceTrackingIssue,
+            #[serde(rename = "CookieDeprecationMetadataIssue")]
+            CookieDeprecationMetadataIssue,
+            #[serde(rename = "StylesheetLoadingIssue")]
+            StylesheetLoadingIssue,
+            #[serde(rename = "FederatedAuthUserInfoRequestIssue")]
+            FederatedAuthUserInfoRequestIssue,
+            #[serde(rename = "PropertyRuleIssue")]
+            PropertyRuleIssue,
+            #[serde(rename = "SharedDictionaryIssue")]
+            SharedDictionaryIssue,
+            #[serde(rename = "ElementAccessibilityIssue")]
+            ElementAccessibilityIssue,
+            #[serde(rename = "SRIMessageSignatureIssue")]
+            SriMessageSignatureIssue,
+            #[serde(rename = "UnencodedDigestIssue")]
+            UnencodedDigestIssue,
+            #[serde(rename = "UserReidentificationIssue")]
+            UserReidentificationIssue,
+            #[serde(rename = "PermissionElementIssue")]
+            PermissionElementIssue,
+        }
+        impl AsRef<str> for InspectorIssueCode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    InspectorIssueCode::CookieIssue => "CookieIssue",
+                    InspectorIssueCode::MixedContentIssue => "MixedContentIssue",
+                    InspectorIssueCode::BlockedByResponseIssue => "BlockedByResponseIssue",
+                    InspectorIssueCode::HeavyAdIssue => "HeavyAdIssue",
+                    InspectorIssueCode::ContentSecurityPolicyIssue => "ContentSecurityPolicyIssue",
+                    InspectorIssueCode::SharedArrayBufferIssue => "SharedArrayBufferIssue",
+                    InspectorIssueCode::LowTextContrastIssue => "LowTextContrastIssue",
+                    InspectorIssueCode::CorsIssue => "CorsIssue",
+                    InspectorIssueCode::AttributionReportingIssue => "AttributionReportingIssue",
+                    InspectorIssueCode::QuirksModeIssue => "QuirksModeIssue",
+                    InspectorIssueCode::PartitioningBlobUrlIssue => "PartitioningBlobURLIssue",
+                    InspectorIssueCode::NavigatorUserAgentIssue => "NavigatorUserAgentIssue",
+                    InspectorIssueCode::GenericIssue => "GenericIssue",
+                    InspectorIssueCode::DeprecationIssue => "DeprecationIssue",
+                    InspectorIssueCode::ClientHintIssue => "ClientHintIssue",
+                    InspectorIssueCode::FederatedAuthRequestIssue => "FederatedAuthRequestIssue",
+                    InspectorIssueCode::BounceTrackingIssue => "BounceTrackingIssue",
+                    InspectorIssueCode::CookieDeprecationMetadataIssue => {
+                        "CookieDeprecationMetadataIssue"
+                    }
+                    InspectorIssueCode::StylesheetLoadingIssue => "StylesheetLoadingIssue",
+                    InspectorIssueCode::FederatedAuthUserInfoRequestIssue => {
+                        "FederatedAuthUserInfoRequestIssue"
+                    }
+                    InspectorIssueCode::PropertyRuleIssue => "PropertyRuleIssue",
+                    InspectorIssueCode::SharedDictionaryIssue => "SharedDictionaryIssue",
+                    InspectorIssueCode::ElementAccessibilityIssue => "ElementAccessibilityIssue",
+                    InspectorIssueCode::SriMessageSignatureIssue => "SRIMessageSignatureIssue",
+                    InspectorIssueCode::UnencodedDigestIssue => "UnencodedDigestIssue",
+                    InspectorIssueCode::UserReidentificationIssue => "UserReidentificationIssue",
+                    InspectorIssueCode::PermissionElementIssue => "PermissionElementIssue",
+                }
+            }
+        }
+        impl ::std::str::FromStr for InspectorIssueCode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "CookieIssue" | "cookieissue" => Ok(InspectorIssueCode::CookieIssue),
+                    "MixedContentIssue" | "mixedcontentissue" => {
+                        Ok(InspectorIssueCode::MixedContentIssue)
+                    }
+                    "BlockedByResponseIssue" | "blockedbyresponseissue" => {
+                        Ok(InspectorIssueCode::BlockedByResponseIssue)
+                    }
+                    "HeavyAdIssue" | "heavyadissue" => Ok(InspectorIssueCode::HeavyAdIssue),
+                    "ContentSecurityPolicyIssue" | "contentsecuritypolicyissue" => {
+                        Ok(InspectorIssueCode::ContentSecurityPolicyIssue)
+                    }
+                    "SharedArrayBufferIssue" | "sharedarraybufferissue" => {
+                        Ok(InspectorIssueCode::SharedArrayBufferIssue)
+                    }
+                    "LowTextContrastIssue" | "lowtextcontrastissue" => {
+                        Ok(InspectorIssueCode::LowTextContrastIssue)
+                    }
+                    "CorsIssue" | "corsissue" => Ok(InspectorIssueCode::CorsIssue),
+                    "AttributionReportingIssue" | "attributionreportingissue" => {
+                        Ok(InspectorIssueCode::AttributionReportingIssue)
+                    }
+                    "QuirksModeIssue" | "quirksmodeissue" => {
+                        Ok(InspectorIssueCode::QuirksModeIssue)
+                    }
+                    "PartitioningBlobURLIssue"
+                    | "PartitioningBlobUrlIssue"
+                    | "partitioningbloburlissue" => {
+                        Ok(InspectorIssueCode::PartitioningBlobUrlIssue)
+                    }
+                    "NavigatorUserAgentIssue" | "navigatoruseragentissue" => {
+                        Ok(InspectorIssueCode::NavigatorUserAgentIssue)
+                    }
+                    "GenericIssue" | "genericissue" => Ok(InspectorIssueCode::GenericIssue),
+                    "DeprecationIssue" | "deprecationissue" => {
+                        Ok(InspectorIssueCode::DeprecationIssue)
+                    }
+                    "ClientHintIssue" | "clienthintissue" => {
+                        Ok(InspectorIssueCode::ClientHintIssue)
+                    }
+                    "FederatedAuthRequestIssue" | "federatedauthrequestissue" => {
+                        Ok(InspectorIssueCode::FederatedAuthRequestIssue)
+                    }
+                    "BounceTrackingIssue" | "bouncetrackingissue" => {
+                        Ok(InspectorIssueCode::BounceTrackingIssue)
+                    }
+                    "CookieDeprecationMetadataIssue" | "cookiedeprecationmetadataissue" => {
+                        Ok(InspectorIssueCode::CookieDeprecationMetadataIssue)
+                    }
+                    "StylesheetLoadingIssue" | "stylesheetloadingissue" => {
+                        Ok(InspectorIssueCode::StylesheetLoadingIssue)
+                    }
+                    "FederatedAuthUserInfoRequestIssue" | "federatedauthuserinforequestissue" => {
+                        Ok(InspectorIssueCode::FederatedAuthUserInfoRequestIssue)
+                    }
+                    "PropertyRuleIssue" | "propertyruleissue" => {
+                        Ok(InspectorIssueCode::PropertyRuleIssue)
+                    }
+                    "SharedDictionaryIssue" | "shareddictionaryissue" => {
+                        Ok(InspectorIssueCode::SharedDictionaryIssue)
+                    }
+                    "ElementAccessibilityIssue" | "elementaccessibilityissue" => {
+                        Ok(InspectorIssueCode::ElementAccessibilityIssue)
+                    }
+                    "SRIMessageSignatureIssue"
+                    | "SriMessageSignatureIssue"
+                    | "srimessagesignatureissue" => {
+                        Ok(InspectorIssueCode::SriMessageSignatureIssue)
+                    }
+                    "UnencodedDigestIssue" | "unencodeddigestissue" => {
+                        Ok(InspectorIssueCode::UnencodedDigestIssue)
+                    }
+                    "UserReidentificationIssue" | "userreidentificationissue" => {
+                        Ok(InspectorIssueCode::UserReidentificationIssue)
+                    }
+                    "PermissionElementIssue" | "permissionelementissue" => {
+                        Ok(InspectorIssueCode::PermissionElementIssue)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "This struct holds a list of optional fields with additional information\nspecific to the kind of issue. When adding a new issue code, please also\nadd a new optional field to this type.\n[InspectorIssueDetails](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-InspectorIssueDetails)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct InspectorIssueDetails {
+            #[serde(rename = "cookieIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cookie_issue_details: Option<CookieIssueDetails>,
+            #[serde(rename = "mixedContentIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub mixed_content_issue_details: Option<MixedContentIssueDetails>,
+            #[serde(rename = "blockedByResponseIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub blocked_by_response_issue_details: Option<BlockedByResponseIssueDetails>,
+            #[serde(rename = "heavyAdIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub heavy_ad_issue_details: Option<HeavyAdIssueDetails>,
+            #[serde(rename = "contentSecurityPolicyIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub content_security_policy_issue_details: Option<ContentSecurityPolicyIssueDetails>,
+            #[serde(rename = "sharedArrayBufferIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub shared_array_buffer_issue_details: Option<SharedArrayBufferIssueDetails>,
+            #[serde(rename = "lowTextContrastIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub low_text_contrast_issue_details: Option<LowTextContrastIssueDetails>,
+            #[serde(rename = "corsIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cors_issue_details: Option<CorsIssueDetails>,
+            #[serde(rename = "attributionReportingIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub attribution_reporting_issue_details: Option<AttributionReportingIssueDetails>,
+            #[serde(rename = "quirksModeIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub quirks_mode_issue_details: Option<QuirksModeIssueDetails>,
+            #[serde(rename = "partitioningBlobURLIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub partitioning_blob_url_issue_details: Option<PartitioningBlobUrlIssueDetails>,
+            #[serde(rename = "genericIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub generic_issue_details: Option<GenericIssueDetails>,
+            #[serde(rename = "deprecationIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub deprecation_issue_details: Option<DeprecationIssueDetails>,
+            #[serde(rename = "clientHintIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub client_hint_issue_details: Option<ClientHintIssueDetails>,
+            #[serde(rename = "federatedAuthRequestIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub federated_auth_request_issue_details: Option<FederatedAuthRequestIssueDetails>,
+            #[serde(rename = "bounceTrackingIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub bounce_tracking_issue_details: Option<BounceTrackingIssueDetails>,
+            #[serde(rename = "cookieDeprecationMetadataIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cookie_deprecation_metadata_issue_details:
+                Option<CookieDeprecationMetadataIssueDetails>,
+            #[serde(rename = "stylesheetLoadingIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stylesheet_loading_issue_details: Option<StylesheetLoadingIssueDetails>,
+            #[serde(rename = "propertyRuleIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub property_rule_issue_details: Option<PropertyRuleIssueDetails>,
+            #[serde(rename = "federatedAuthUserInfoRequestIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub federated_auth_user_info_request_issue_details:
+                Option<FederatedAuthUserInfoRequestIssueDetails>,
+            #[serde(rename = "sharedDictionaryIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub shared_dictionary_issue_details: Option<SharedDictionaryIssueDetails>,
+            #[serde(rename = "elementAccessibilityIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub element_accessibility_issue_details: Option<ElementAccessibilityIssueDetails>,
+            #[serde(rename = "sriMessageSignatureIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub sri_message_signature_issue_details: Option<SriMessageSignatureIssueDetails>,
+            #[serde(rename = "unencodedDigestIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub unencoded_digest_issue_details: Option<UnencodedDigestIssueDetails>,
+            #[serde(rename = "userReidentificationIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub user_reidentification_issue_details: Option<UserReidentificationIssueDetails>,
+            #[serde(rename = "permissionElementIssueDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub permission_element_issue_details: Option<PermissionElementIssueDetails>,
+        }
+        impl InspectorIssueDetails {
+            pub fn builder() -> InspectorIssueDetailsBuilder {
+                InspectorIssueDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InspectorIssueDetailsBuilder {
+            cookie_issue_details: Option<CookieIssueDetails>,
+            mixed_content_issue_details: Option<MixedContentIssueDetails>,
+            blocked_by_response_issue_details: Option<BlockedByResponseIssueDetails>,
+            heavy_ad_issue_details: Option<HeavyAdIssueDetails>,
+            content_security_policy_issue_details: Option<ContentSecurityPolicyIssueDetails>,
+            shared_array_buffer_issue_details: Option<SharedArrayBufferIssueDetails>,
+            low_text_contrast_issue_details: Option<LowTextContrastIssueDetails>,
+            cors_issue_details: Option<CorsIssueDetails>,
+            attribution_reporting_issue_details: Option<AttributionReportingIssueDetails>,
+            quirks_mode_issue_details: Option<QuirksModeIssueDetails>,
+            partitioning_blob_url_issue_details: Option<PartitioningBlobUrlIssueDetails>,
+            generic_issue_details: Option<GenericIssueDetails>,
+            deprecation_issue_details: Option<DeprecationIssueDetails>,
+            client_hint_issue_details: Option<ClientHintIssueDetails>,
+            federated_auth_request_issue_details: Option<FederatedAuthRequestIssueDetails>,
+            bounce_tracking_issue_details: Option<BounceTrackingIssueDetails>,
+            cookie_deprecation_metadata_issue_details:
+                Option<CookieDeprecationMetadataIssueDetails>,
+            stylesheet_loading_issue_details: Option<StylesheetLoadingIssueDetails>,
+            property_rule_issue_details: Option<PropertyRuleIssueDetails>,
+            federated_auth_user_info_request_issue_details:
+                Option<FederatedAuthUserInfoRequestIssueDetails>,
+            shared_dictionary_issue_details: Option<SharedDictionaryIssueDetails>,
+            element_accessibility_issue_details: Option<ElementAccessibilityIssueDetails>,
+            sri_message_signature_issue_details: Option<SriMessageSignatureIssueDetails>,
+            unencoded_digest_issue_details: Option<UnencodedDigestIssueDetails>,
+            user_reidentification_issue_details: Option<UserReidentificationIssueDetails>,
+            permission_element_issue_details: Option<PermissionElementIssueDetails>,
+        }
+        impl InspectorIssueDetailsBuilder {
+            pub fn cookie_issue_details(
+                mut self,
+                cookie_issue_details: impl Into<CookieIssueDetails>,
+            ) -> Self {
+                self.cookie_issue_details = Some(cookie_issue_details.into());
+                self
+            }
+            pub fn mixed_content_issue_details(
+                mut self,
+                mixed_content_issue_details: impl Into<MixedContentIssueDetails>,
+            ) -> Self {
+                self.mixed_content_issue_details = Some(mixed_content_issue_details.into());
+                self
+            }
+            pub fn blocked_by_response_issue_details(
+                mut self,
+                blocked_by_response_issue_details: impl Into<BlockedByResponseIssueDetails>,
+            ) -> Self {
+                self.blocked_by_response_issue_details =
+                    Some(blocked_by_response_issue_details.into());
+                self
+            }
+            pub fn heavy_ad_issue_details(
+                mut self,
+                heavy_ad_issue_details: impl Into<HeavyAdIssueDetails>,
+            ) -> Self {
+                self.heavy_ad_issue_details = Some(heavy_ad_issue_details.into());
+                self
+            }
+            pub fn content_security_policy_issue_details(
+                mut self,
+                content_security_policy_issue_details: impl Into<ContentSecurityPolicyIssueDetails>,
+            ) -> Self {
+                self.content_security_policy_issue_details =
+                    Some(content_security_policy_issue_details.into());
+                self
+            }
+            pub fn shared_array_buffer_issue_details(
+                mut self,
+                shared_array_buffer_issue_details: impl Into<SharedArrayBufferIssueDetails>,
+            ) -> Self {
+                self.shared_array_buffer_issue_details =
+                    Some(shared_array_buffer_issue_details.into());
+                self
+            }
+            pub fn low_text_contrast_issue_details(
+                mut self,
+                low_text_contrast_issue_details: impl Into<LowTextContrastIssueDetails>,
+            ) -> Self {
+                self.low_text_contrast_issue_details = Some(low_text_contrast_issue_details.into());
+                self
+            }
+            pub fn cors_issue_details(
+                mut self,
+                cors_issue_details: impl Into<CorsIssueDetails>,
+            ) -> Self {
+                self.cors_issue_details = Some(cors_issue_details.into());
+                self
+            }
+            pub fn attribution_reporting_issue_details(
+                mut self,
+                attribution_reporting_issue_details: impl Into<AttributionReportingIssueDetails>,
+            ) -> Self {
+                self.attribution_reporting_issue_details =
+                    Some(attribution_reporting_issue_details.into());
+                self
+            }
+            pub fn quirks_mode_issue_details(
+                mut self,
+                quirks_mode_issue_details: impl Into<QuirksModeIssueDetails>,
+            ) -> Self {
+                self.quirks_mode_issue_details = Some(quirks_mode_issue_details.into());
+                self
+            }
+            pub fn partitioning_blob_url_issue_details(
+                mut self,
+                partitioning_blob_url_issue_details: impl Into<PartitioningBlobUrlIssueDetails>,
+            ) -> Self {
+                self.partitioning_blob_url_issue_details =
+                    Some(partitioning_blob_url_issue_details.into());
+                self
+            }
+            pub fn generic_issue_details(
+                mut self,
+                generic_issue_details: impl Into<GenericIssueDetails>,
+            ) -> Self {
+                self.generic_issue_details = Some(generic_issue_details.into());
+                self
+            }
+            pub fn deprecation_issue_details(
+                mut self,
+                deprecation_issue_details: impl Into<DeprecationIssueDetails>,
+            ) -> Self {
+                self.deprecation_issue_details = Some(deprecation_issue_details.into());
+                self
+            }
+            pub fn client_hint_issue_details(
+                mut self,
+                client_hint_issue_details: impl Into<ClientHintIssueDetails>,
+            ) -> Self {
+                self.client_hint_issue_details = Some(client_hint_issue_details.into());
+                self
+            }
+            pub fn federated_auth_request_issue_details(
+                mut self,
+                federated_auth_request_issue_details: impl Into<FederatedAuthRequestIssueDetails>,
+            ) -> Self {
+                self.federated_auth_request_issue_details =
+                    Some(federated_auth_request_issue_details.into());
+                self
+            }
+            pub fn bounce_tracking_issue_details(
+                mut self,
+                bounce_tracking_issue_details: impl Into<BounceTrackingIssueDetails>,
+            ) -> Self {
+                self.bounce_tracking_issue_details = Some(bounce_tracking_issue_details.into());
+                self
+            }
+            pub fn cookie_deprecation_metadata_issue_details(
+                mut self,
+                cookie_deprecation_metadata_issue_details: impl Into<
+                    CookieDeprecationMetadataIssueDetails,
+                >,
+            ) -> Self {
+                self.cookie_deprecation_metadata_issue_details =
+                    Some(cookie_deprecation_metadata_issue_details.into());
+                self
+            }
+            pub fn stylesheet_loading_issue_details(
+                mut self,
+                stylesheet_loading_issue_details: impl Into<StylesheetLoadingIssueDetails>,
+            ) -> Self {
+                self.stylesheet_loading_issue_details =
+                    Some(stylesheet_loading_issue_details.into());
+                self
+            }
+            pub fn property_rule_issue_details(
+                mut self,
+                property_rule_issue_details: impl Into<PropertyRuleIssueDetails>,
+            ) -> Self {
+                self.property_rule_issue_details = Some(property_rule_issue_details.into());
+                self
+            }
+            pub fn federated_auth_user_info_request_issue_details(
+                mut self,
+                federated_auth_user_info_request_issue_details: impl Into<
+                    FederatedAuthUserInfoRequestIssueDetails,
+                >,
+            ) -> Self {
+                self.federated_auth_user_info_request_issue_details =
+                    Some(federated_auth_user_info_request_issue_details.into());
+                self
+            }
+            pub fn shared_dictionary_issue_details(
+                mut self,
+                shared_dictionary_issue_details: impl Into<SharedDictionaryIssueDetails>,
+            ) -> Self {
+                self.shared_dictionary_issue_details = Some(shared_dictionary_issue_details.into());
+                self
+            }
+            pub fn element_accessibility_issue_details(
+                mut self,
+                element_accessibility_issue_details: impl Into<ElementAccessibilityIssueDetails>,
+            ) -> Self {
+                self.element_accessibility_issue_details =
+                    Some(element_accessibility_issue_details.into());
+                self
+            }
+            pub fn sri_message_signature_issue_details(
+                mut self,
+                sri_message_signature_issue_details: impl Into<SriMessageSignatureIssueDetails>,
+            ) -> Self {
+                self.sri_message_signature_issue_details =
+                    Some(sri_message_signature_issue_details.into());
+                self
+            }
+            pub fn unencoded_digest_issue_details(
+                mut self,
+                unencoded_digest_issue_details: impl Into<UnencodedDigestIssueDetails>,
+            ) -> Self {
+                self.unencoded_digest_issue_details = Some(unencoded_digest_issue_details.into());
+                self
+            }
+            pub fn user_reidentification_issue_details(
+                mut self,
+                user_reidentification_issue_details: impl Into<UserReidentificationIssueDetails>,
+            ) -> Self {
+                self.user_reidentification_issue_details =
+                    Some(user_reidentification_issue_details.into());
+                self
+            }
+            pub fn permission_element_issue_details(
+                mut self,
+                permission_element_issue_details: impl Into<PermissionElementIssueDetails>,
+            ) -> Self {
+                self.permission_element_issue_details =
+                    Some(permission_element_issue_details.into());
+                self
+            }
+            pub fn build(self) -> InspectorIssueDetails {
+                InspectorIssueDetails {
+                    cookie_issue_details: self.cookie_issue_details,
+                    mixed_content_issue_details: self.mixed_content_issue_details,
+                    blocked_by_response_issue_details: self.blocked_by_response_issue_details,
+                    heavy_ad_issue_details: self.heavy_ad_issue_details,
+                    content_security_policy_issue_details: self
+                        .content_security_policy_issue_details,
+                    shared_array_buffer_issue_details: self.shared_array_buffer_issue_details,
+                    low_text_contrast_issue_details: self.low_text_contrast_issue_details,
+                    cors_issue_details: self.cors_issue_details,
+                    attribution_reporting_issue_details: self.attribution_reporting_issue_details,
+                    quirks_mode_issue_details: self.quirks_mode_issue_details,
+                    partitioning_blob_url_issue_details: self.partitioning_blob_url_issue_details,
+                    generic_issue_details: self.generic_issue_details,
+                    deprecation_issue_details: self.deprecation_issue_details,
+                    client_hint_issue_details: self.client_hint_issue_details,
+                    federated_auth_request_issue_details: self.federated_auth_request_issue_details,
+                    bounce_tracking_issue_details: self.bounce_tracking_issue_details,
+                    cookie_deprecation_metadata_issue_details: self
+                        .cookie_deprecation_metadata_issue_details,
+                    stylesheet_loading_issue_details: self.stylesheet_loading_issue_details,
+                    property_rule_issue_details: self.property_rule_issue_details,
+                    federated_auth_user_info_request_issue_details: self
+                        .federated_auth_user_info_request_issue_details,
+                    shared_dictionary_issue_details: self.shared_dictionary_issue_details,
+                    element_accessibility_issue_details: self.element_accessibility_issue_details,
+                    sri_message_signature_issue_details: self.sri_message_signature_issue_details,
+                    unencoded_digest_issue_details: self.unencoded_digest_issue_details,
+                    user_reidentification_issue_details: self.user_reidentification_issue_details,
+                    permission_element_issue_details: self.permission_element_issue_details,
+                }
+            }
+        }
+        impl InspectorIssueDetails {
+            pub const IDENTIFIER: &'static str = "Audits.InspectorIssueDetails";
+        }
+        #[doc = "A unique id for a DevTools inspector issue. Allows other entities (e.g.\nexceptions, CDP message, console messages, etc.) to reference an issue.\n[IssueId](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-IssueId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct IssueId(String);
+        impl IssueId {
+            pub fn new(val: impl Into<String>) -> Self {
+                IssueId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for IssueId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<IssueId> for String {
+            fn from(el: IssueId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for IssueId {
+            fn from(expr: String) -> Self {
+                IssueId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for IssueId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl IssueId {
+            pub const IDENTIFIER: &'static str = "Audits.IssueId";
+        }
+        #[doc = "An inspector issue reported from the back-end.\n[InspectorIssue](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#type-InspectorIssue)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct InspectorIssue {
+            #[serde(rename = "code")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub code: InspectorIssueCode,
+            #[serde(rename = "details")]
+            pub details: InspectorIssueDetails,
+            #[doc = "A unique id for this issue. May be omitted if no other entity (e.g.\nexception, CDP message, etc.) is referencing this issue."]
+            #[serde(rename = "issueId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub issue_id: Option<IssueId>,
+        }
+        impl InspectorIssue {
+            pub fn new(
+                code: impl Into<InspectorIssueCode>,
+                details: impl Into<InspectorIssueDetails>,
+            ) -> Self {
+                Self {
+                    code: code.into(),
+                    details: details.into(),
+                    issue_id: None,
+                }
+            }
+        }
+        impl InspectorIssue {
+            pub fn builder() -> InspectorIssueBuilder {
+                InspectorIssueBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InspectorIssueBuilder {
+            code: Option<InspectorIssueCode>,
+            details: Option<InspectorIssueDetails>,
+            issue_id: Option<IssueId>,
+        }
+        impl InspectorIssueBuilder {
+            pub fn code(mut self, code: impl Into<InspectorIssueCode>) -> Self {
+                self.code = Some(code.into());
+                self
+            }
+            pub fn details(mut self, details: impl Into<InspectorIssueDetails>) -> Self {
+                self.details = Some(details.into());
+                self
+            }
+            pub fn issue_id(mut self, issue_id: impl Into<IssueId>) -> Self {
+                self.issue_id = Some(issue_id.into());
+                self
+            }
+            pub fn build(self) -> Result<InspectorIssue, String> {
+                Ok(InspectorIssue {
+                    code: self.code.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(code))
+                    })?,
+                    details: self.details.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(details))
+                    })?,
+                    issue_id: self.issue_id,
+                })
+            }
+        }
+        impl InspectorIssue {
+            pub const IDENTIFIER: &'static str = "Audits.InspectorIssue";
+        }
+        #[doc = "Returns the response body and size if it were re-encoded with the specified settings. Only\napplies to images.\n[getEncodedResponse](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#method-getEncodedResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetEncodedResponseParams {
+            #[doc = "Identifier of the network request to get content for."]
+            #[serde(rename = "requestId")]
+            pub request_id: super::network::RequestId,
+            #[doc = "The encoding to use."]
+            #[serde(rename = "encoding")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub encoding: GetEncodedResponseEncoding,
+            #[doc = "The quality of the encoding (0-1). (defaults to 1)"]
+            #[serde(rename = "quality")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub quality: Option<f64>,
+            #[doc = "Whether to only return the size information (defaults to false)."]
+            #[serde(rename = "sizeOnly")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub size_only: Option<bool>,
+        }
+        #[doc = "The encoding to use."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum GetEncodedResponseEncoding {
+            #[serde(rename = "webp")]
+            Webp,
+            #[serde(rename = "jpeg")]
+            Jpeg,
+            #[serde(rename = "png")]
+            Png,
+        }
+        impl AsRef<str> for GetEncodedResponseEncoding {
+            fn as_ref(&self) -> &str {
+                match self {
+                    GetEncodedResponseEncoding::Webp => "webp",
+                    GetEncodedResponseEncoding::Jpeg => "jpeg",
+                    GetEncodedResponseEncoding::Png => "png",
+                }
+            }
+        }
+        impl ::std::str::FromStr for GetEncodedResponseEncoding {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "webp" | "Webp" => Ok(GetEncodedResponseEncoding::Webp),
+                    "jpeg" | "Jpeg" => Ok(GetEncodedResponseEncoding::Jpeg),
+                    "png" | "Png" => Ok(GetEncodedResponseEncoding::Png),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl GetEncodedResponseParams {
+            pub fn new(
+                request_id: impl Into<super::network::RequestId>,
+                encoding: impl Into<GetEncodedResponseEncoding>,
+            ) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                    encoding: encoding.into(),
+                    quality: None,
+                    size_only: None,
+                }
+            }
+        }
+        impl GetEncodedResponseParams {
+            pub fn builder() -> GetEncodedResponseParamsBuilder {
+                GetEncodedResponseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetEncodedResponseParamsBuilder {
+            request_id: Option<super::network::RequestId>,
+            encoding: Option<GetEncodedResponseEncoding>,
+            quality: Option<f64>,
+            size_only: Option<bool>,
+        }
+        impl GetEncodedResponseParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<super::network::RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn encoding(mut self, encoding: impl Into<GetEncodedResponseEncoding>) -> Self {
+                self.encoding = Some(encoding.into());
+                self
+            }
+            pub fn quality(mut self, quality: impl Into<f64>) -> Self {
+                self.quality = Some(quality.into());
+                self
+            }
+            pub fn size_only(mut self, size_only: impl Into<bool>) -> Self {
+                self.size_only = Some(size_only.into());
+                self
+            }
+            pub fn build(self) -> Result<GetEncodedResponseParams, String> {
+                Ok(GetEncodedResponseParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                    encoding: self.encoding.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(encoding))
+                    })?,
+                    quality: self.quality,
+                    size_only: self.size_only,
+                })
+            }
+        }
+        impl GetEncodedResponseParams {
+            pub const IDENTIFIER: &'static str = "Audits.getEncodedResponse";
+        }
+        impl chromiumoxide_types::Method for GetEncodedResponseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetEncodedResponseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the response body and size if it were re-encoded with the specified settings. Only\napplies to images.\n[getEncodedResponse](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#method-getEncodedResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetEncodedResponseReturns {
+            #[doc = "The encoded body as a base64 string. Omitted if sizeOnly is true."]
+            #[serde(rename = "body")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub body: Option<chromiumoxide_types::Binary>,
+            #[doc = "Size before re-encoding."]
+            #[serde(rename = "originalSize")]
+            pub original_size: i64,
+            #[doc = "Size after re-encoding."]
+            #[serde(rename = "encodedSize")]
+            pub encoded_size: i64,
+        }
+        impl GetEncodedResponseReturns {
+            pub fn new(original_size: impl Into<i64>, encoded_size: impl Into<i64>) -> Self {
+                Self {
+                    original_size: original_size.into(),
+                    encoded_size: encoded_size.into(),
+                    body: None,
+                }
+            }
+        }
+        impl GetEncodedResponseReturns {
+            pub fn builder() -> GetEncodedResponseReturnsBuilder {
+                GetEncodedResponseReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetEncodedResponseReturnsBuilder {
+            body: Option<chromiumoxide_types::Binary>,
+            original_size: Option<i64>,
+            encoded_size: Option<i64>,
+        }
+        impl GetEncodedResponseReturnsBuilder {
+            pub fn body(mut self, body: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.body = Some(body.into());
+                self
+            }
+            pub fn original_size(mut self, original_size: impl Into<i64>) -> Self {
+                self.original_size = Some(original_size.into());
+                self
+            }
+            pub fn encoded_size(mut self, encoded_size: impl Into<i64>) -> Self {
+                self.encoded_size = Some(encoded_size.into());
+                self
+            }
+            pub fn build(self) -> Result<GetEncodedResponseReturns, String> {
+                Ok(GetEncodedResponseReturns {
+                    body: self.body,
+                    original_size: self.original_size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(original_size))
+                    })?,
+                    encoded_size: self.encoded_size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(encoded_size))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetEncodedResponseParams {
+            type Response = GetEncodedResponseReturns;
+        }
+        #[doc = "Disables issues domain, prevents further issues from being reported to the client.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Audits.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables issues domain, prevents further issues from being reported to the client.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables issues domain, sends the issues collected so far to the client by means of the\n`issueAdded` event.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Audits.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables issues domain, sends the issues collected so far to the client by means of the\n`issueAdded` event.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Runs the contrast check for the target page. Found issues are reported\nusing Audits.issueAdded event.\n[checkContrast](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#method-checkContrast)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CheckContrastParams {
+            #[doc = "Whether to report WCAG AAA level issues. Default is false."]
+            #[serde(rename = "reportAAA")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub report_aaa: Option<bool>,
+        }
+        impl CheckContrastParams {
+            pub fn builder() -> CheckContrastParamsBuilder {
+                CheckContrastParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CheckContrastParamsBuilder {
+            report_aaa: Option<bool>,
+        }
+        impl CheckContrastParamsBuilder {
+            pub fn report_aaa(mut self, report_aaa: impl Into<bool>) -> Self {
+                self.report_aaa = Some(report_aaa.into());
+                self
+            }
+            pub fn build(self) -> CheckContrastParams {
+                CheckContrastParams {
+                    report_aaa: self.report_aaa,
+                }
+            }
+        }
+        impl CheckContrastParams {
+            pub const IDENTIFIER: &'static str = "Audits.checkContrast";
+        }
+        impl chromiumoxide_types::Method for CheckContrastParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CheckContrastParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Runs the contrast check for the target page. Found issues are reported\nusing Audits.issueAdded event.\n[checkContrast](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#method-checkContrast)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CheckContrastReturns {}
+        impl chromiumoxide_types::Command for CheckContrastParams {
+            type Response = CheckContrastReturns;
+        }
+        #[doc = "Runs the form issues check for the target page. Found issues are reported\nusing Audits.issueAdded event.\n[checkFormsIssues](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#method-checkFormsIssues)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CheckFormsIssuesParams {}
+        impl CheckFormsIssuesParams {
+            pub const IDENTIFIER: &'static str = "Audits.checkFormsIssues";
+        }
+        impl chromiumoxide_types::Method for CheckFormsIssuesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CheckFormsIssuesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Runs the form issues check for the target page. Found issues are reported\nusing Audits.issueAdded event.\n[checkFormsIssues](https://chromedevtools.github.io/devtools-protocol/tot/Audits/#method-checkFormsIssues)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CheckFormsIssuesReturns {
+            #[serde(rename = "formIssues")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub form_issues: Vec<GenericIssueDetails>,
+        }
+        impl CheckFormsIssuesReturns {
+            pub fn new(form_issues: Vec<GenericIssueDetails>) -> Self {
+                Self { form_issues }
+            }
+        }
+        impl CheckFormsIssuesReturns {
+            pub fn builder() -> CheckFormsIssuesReturnsBuilder {
+                CheckFormsIssuesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CheckFormsIssuesReturnsBuilder {
+            form_issues: Option<Vec<GenericIssueDetails>>,
+        }
+        impl CheckFormsIssuesReturnsBuilder {
+            pub fn form_issue(mut self, form_issue: impl Into<GenericIssueDetails>) -> Self {
+                let v = self.form_issues.get_or_insert(Vec::new());
+                v.push(form_issue.into());
+                self
+            }
+            pub fn form_issues<I, S>(mut self, form_issues: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<GenericIssueDetails>,
+            {
+                let v = self.form_issues.get_or_insert(Vec::new());
+                for val in form_issues {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<CheckFormsIssuesReturns, String> {
+                Ok(CheckFormsIssuesReturns {
+                    form_issues: self.form_issues.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(form_issues))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CheckFormsIssuesParams {
+            type Response = CheckFormsIssuesReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventIssueAdded {
+            #[serde(rename = "issue")]
+            pub issue: InspectorIssue,
+        }
+        impl EventIssueAdded {
+            pub const IDENTIFIER: &'static str = "Audits.issueAdded";
+        }
+        impl chromiumoxide_types::Method for EventIssueAdded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventIssueAdded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "Defines commands and events for Autofill."]
+    pub mod autofill {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CreditCard {
+            #[doc = "16-digit credit card number."]
+            #[serde(rename = "number")]
+            pub number: String,
+            #[doc = "Name of the credit card owner."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "2-digit expiry month."]
+            #[serde(rename = "expiryMonth")]
+            pub expiry_month: String,
+            #[doc = "4-digit expiry year."]
+            #[serde(rename = "expiryYear")]
+            pub expiry_year: String,
+            #[doc = "3-digit card verification code."]
+            #[serde(rename = "cvc")]
+            pub cvc: String,
+        }
+        impl CreditCard {
+            pub fn builder() -> CreditCardBuilder {
+                CreditCardBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CreditCardBuilder {
+            number: Option<String>,
+            name: Option<String>,
+            expiry_month: Option<String>,
+            expiry_year: Option<String>,
+            cvc: Option<String>,
+        }
+        impl CreditCardBuilder {
+            pub fn number(mut self, number: impl Into<String>) -> Self {
+                self.number = Some(number.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn expiry_month(mut self, expiry_month: impl Into<String>) -> Self {
+                self.expiry_month = Some(expiry_month.into());
+                self
+            }
+            pub fn expiry_year(mut self, expiry_year: impl Into<String>) -> Self {
+                self.expiry_year = Some(expiry_year.into());
+                self
+            }
+            pub fn cvc(mut self, cvc: impl Into<String>) -> Self {
+                self.cvc = Some(cvc.into());
+                self
+            }
+            pub fn build(self) -> Result<CreditCard, String> {
+                Ok(CreditCard {
+                    number: self.number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(number))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    expiry_month: self.expiry_month.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expiry_month))
+                    })?,
+                    expiry_year: self.expiry_year.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expiry_year))
+                    })?,
+                    cvc: self
+                        .cvc
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(cvc)))?,
+                })
+            }
+        }
+        impl CreditCard {
+            pub const IDENTIFIER: &'static str = "Autofill.CreditCard";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddressField {
+            #[doc = "address field name, for example GIVEN_NAME.\nThe full list of supported field names:\nhttps://source.chromium.org/chromium/chromium/src/+/main:components/autofill/core/browser/field_types.cc;l=38"]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "address field value, for example Jon Doe."]
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl AddressField {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl AddressField {
+            pub fn builder() -> AddressFieldBuilder {
+                AddressFieldBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddressFieldBuilder {
+            name: Option<String>,
+            value: Option<String>,
+        }
+        impl AddressFieldBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<AddressField, String> {
+                Ok(AddressField {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl AddressField {
+            pub const IDENTIFIER: &'static str = "Autofill.AddressField";
+        }
+        #[doc = "A list of address fields.\n[AddressFields](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#type-AddressFields)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddressFields {
+            #[serde(rename = "fields")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub fields: Vec<AddressField>,
+        }
+        impl AddressFields {
+            pub fn new(fields: Vec<AddressField>) -> Self {
+                Self { fields }
+            }
+        }
+        impl AddressFields {
+            pub fn builder() -> AddressFieldsBuilder {
+                AddressFieldsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddressFieldsBuilder {
+            fields: Option<Vec<AddressField>>,
+        }
+        impl AddressFieldsBuilder {
+            pub fn field(mut self, field: impl Into<AddressField>) -> Self {
+                let v = self.fields.get_or_insert(Vec::new());
+                v.push(field.into());
+                self
+            }
+            pub fn fields<I, S>(mut self, fields: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AddressField>,
+            {
+                let v = self.fields.get_or_insert(Vec::new());
+                for val in fields {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<AddressFields, String> {
+                Ok(AddressFields {
+                    fields: self.fields.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(fields))
+                    })?,
+                })
+            }
+        }
+        impl AddressFields {
+            pub const IDENTIFIER: &'static str = "Autofill.AddressFields";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Address {
+            #[doc = "fields and values defining an address."]
+            #[serde(rename = "fields")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub fields: Vec<AddressField>,
+        }
+        impl Address {
+            pub fn new(fields: Vec<AddressField>) -> Self {
+                Self { fields }
+            }
+        }
+        impl Address {
+            pub fn builder() -> AddressBuilder {
+                AddressBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddressBuilder {
+            fields: Option<Vec<AddressField>>,
+        }
+        impl AddressBuilder {
+            pub fn field(mut self, field: impl Into<AddressField>) -> Self {
+                let v = self.fields.get_or_insert(Vec::new());
+                v.push(field.into());
+                self
+            }
+            pub fn fields<I, S>(mut self, fields: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AddressField>,
+            {
+                let v = self.fields.get_or_insert(Vec::new());
+                for val in fields {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<Address, String> {
+                Ok(Address {
+                    fields: self.fields.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(fields))
+                    })?,
+                })
+            }
+        }
+        impl Address {
+            pub const IDENTIFIER: &'static str = "Autofill.Address";
+        }
+        #[doc = "Defines how an address can be displayed like in chrome://settings/addresses.\nAddress UI is a two dimensional array, each inner array is an \"address information line\", and when rendered in a UI surface should be displayed as such.\nThe following address UI for instance:\n[[{name: \"GIVE_NAME\", value: \"Jon\"}, {name: \"FAMILY_NAME\", value: \"Doe\"}], [{name: \"CITY\", value: \"Munich\"}, {name: \"ZIP\", value: \"81456\"}]]\nshould allow the receiver to render:\nJon Doe\nMunich 81456\n[AddressUI](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#type-AddressUI)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddressUi {
+            #[doc = "A two dimension array containing the representation of values from an address profile."]
+            #[serde(rename = "addressFields")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub address_fields: Vec<AddressFields>,
+        }
+        impl AddressUi {
+            pub fn new(address_fields: Vec<AddressFields>) -> Self {
+                Self { address_fields }
+            }
+        }
+        impl AddressUi {
+            pub fn builder() -> AddressUiBuilder {
+                AddressUiBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddressUiBuilder {
+            address_fields: Option<Vec<AddressFields>>,
+        }
+        impl AddressUiBuilder {
+            pub fn address_field(mut self, address_field: impl Into<AddressFields>) -> Self {
+                let v = self.address_fields.get_or_insert(Vec::new());
+                v.push(address_field.into());
+                self
+            }
+            pub fn address_fields<I, S>(mut self, address_fields: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AddressFields>,
+            {
+                let v = self.address_fields.get_or_insert(Vec::new());
+                for val in address_fields {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<AddressUi, String> {
+                Ok(AddressUi {
+                    address_fields: self.address_fields.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(address_fields))
+                    })?,
+                })
+            }
+        }
+        impl AddressUi {
+            pub const IDENTIFIER: &'static str = "Autofill.AddressUI";
+        }
+        #[doc = "Specified whether a filled field was done so by using the html autocomplete attribute or autofill heuristics."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum FillingStrategy {
+            #[serde(rename = "autocompleteAttribute")]
+            AutocompleteAttribute,
+            #[serde(rename = "autofillInferred")]
+            AutofillInferred,
+        }
+        impl AsRef<str> for FillingStrategy {
+            fn as_ref(&self) -> &str {
+                match self {
+                    FillingStrategy::AutocompleteAttribute => "autocompleteAttribute",
+                    FillingStrategy::AutofillInferred => "autofillInferred",
+                }
+            }
+        }
+        impl ::std::str::FromStr for FillingStrategy {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "autocompleteAttribute" | "AutocompleteAttribute" | "autocompleteattribute" => {
+                        Ok(FillingStrategy::AutocompleteAttribute)
+                    }
+                    "autofillInferred" | "AutofillInferred" | "autofillinferred" => {
+                        Ok(FillingStrategy::AutofillInferred)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FilledField {
+            #[doc = "The type of the field, e.g text, password etc."]
+            #[serde(rename = "htmlType")]
+            pub html_type: String,
+            #[doc = "the html id"]
+            #[serde(rename = "id")]
+            pub id: String,
+            #[doc = "the html name"]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "the field value"]
+            #[serde(rename = "value")]
+            pub value: String,
+            #[doc = "The actual field type, e.g FAMILY_NAME"]
+            #[serde(rename = "autofillType")]
+            pub autofill_type: String,
+            #[doc = "The filling strategy"]
+            #[serde(rename = "fillingStrategy")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub filling_strategy: FillingStrategy,
+            #[doc = "The frame the field belongs to"]
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+            #[doc = "The form field's DOM node"]
+            #[serde(rename = "fieldId")]
+            pub field_id: super::dom::BackendNodeId,
+        }
+        impl FilledField {
+            pub fn builder() -> FilledFieldBuilder {
+                FilledFieldBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FilledFieldBuilder {
+            html_type: Option<String>,
+            id: Option<String>,
+            name: Option<String>,
+            value: Option<String>,
+            autofill_type: Option<String>,
+            filling_strategy: Option<FillingStrategy>,
+            frame_id: Option<super::page::FrameId>,
+            field_id: Option<super::dom::BackendNodeId>,
+        }
+        impl FilledFieldBuilder {
+            pub fn html_type(mut self, html_type: impl Into<String>) -> Self {
+                self.html_type = Some(html_type.into());
+                self
+            }
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn autofill_type(mut self, autofill_type: impl Into<String>) -> Self {
+                self.autofill_type = Some(autofill_type.into());
+                self
+            }
+            pub fn filling_strategy(
+                mut self,
+                filling_strategy: impl Into<FillingStrategy>,
+            ) -> Self {
+                self.filling_strategy = Some(filling_strategy.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn field_id(mut self, field_id: impl Into<super::dom::BackendNodeId>) -> Self {
+                self.field_id = Some(field_id.into());
+                self
+            }
+            pub fn build(self) -> Result<FilledField, String> {
+                Ok(FilledField {
+                    html_type: self.html_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(html_type))
+                    })?,
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    autofill_type: self.autofill_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(autofill_type))
+                    })?,
+                    filling_strategy: self.filling_strategy.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(filling_strategy)
+                        )
+                    })?,
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    field_id: self.field_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(field_id))
+                    })?,
+                })
+            }
+        }
+        impl FilledField {
+            pub const IDENTIFIER: &'static str = "Autofill.FilledField";
+        }
+        #[doc = "Trigger autofill on a form identified by the fieldId.\nIf the field and related form cannot be autofilled, returns an error.\n[trigger](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#method-trigger)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TriggerParams {
+            #[doc = "Identifies a field that serves as an anchor for autofill."]
+            #[serde(rename = "fieldId")]
+            pub field_id: super::dom::BackendNodeId,
+            #[doc = "Identifies the frame that field belongs to."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+            #[doc = "Credit card information to fill out the form. Credit card data is not saved.  Mutually exclusive with `address`."]
+            #[serde(rename = "card")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub card: Option<CreditCard>,
+            #[doc = "Address to fill out the form. Address data is not saved. Mutually exclusive with `card`."]
+            #[serde(rename = "address")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub address: Option<Address>,
+        }
+        impl TriggerParams {
+            pub fn new(field_id: impl Into<super::dom::BackendNodeId>) -> Self {
+                Self {
+                    field_id: field_id.into(),
+                    frame_id: None,
+                    card: None,
+                    address: None,
+                }
+            }
+        }
+        impl TriggerParams {
+            pub fn builder() -> TriggerParamsBuilder {
+                TriggerParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TriggerParamsBuilder {
+            field_id: Option<super::dom::BackendNodeId>,
+            frame_id: Option<super::page::FrameId>,
+            card: Option<CreditCard>,
+            address: Option<Address>,
+        }
+        impl TriggerParamsBuilder {
+            pub fn field_id(mut self, field_id: impl Into<super::dom::BackendNodeId>) -> Self {
+                self.field_id = Some(field_id.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn card(mut self, card: impl Into<CreditCard>) -> Self {
+                self.card = Some(card.into());
+                self
+            }
+            pub fn address(mut self, address: impl Into<Address>) -> Self {
+                self.address = Some(address.into());
+                self
+            }
+            pub fn build(self) -> Result<TriggerParams, String> {
+                Ok(TriggerParams {
+                    field_id: self.field_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(field_id))
+                    })?,
+                    frame_id: self.frame_id,
+                    card: self.card,
+                    address: self.address,
+                })
+            }
+        }
+        impl TriggerParams {
+            pub const IDENTIFIER: &'static str = "Autofill.trigger";
+        }
+        impl chromiumoxide_types::Method for TriggerParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TriggerParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Trigger autofill on a form identified by the fieldId.\nIf the field and related form cannot be autofilled, returns an error.\n[trigger](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#method-trigger)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TriggerReturns {}
+        impl chromiumoxide_types::Command for TriggerParams {
+            type Response = TriggerReturns;
+        }
+        #[doc = "Set addresses so that developers can verify their forms implementation.\n[setAddresses](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#method-setAddresses)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAddressesParams {
+            #[doc = "Test addresses for the available countries."]
+            #[serde(rename = "addresses")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub addresses: Vec<Address>,
+        }
+        impl SetAddressesParams {
+            pub fn new(addresses: Vec<Address>) -> Self {
+                Self { addresses }
+            }
+        }
+        impl SetAddressesParams {
+            pub fn builder() -> SetAddressesParamsBuilder {
+                SetAddressesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAddressesParamsBuilder {
+            addresses: Option<Vec<Address>>,
+        }
+        impl SetAddressesParamsBuilder {
+            pub fn addresse(mut self, addresse: impl Into<Address>) -> Self {
+                let v = self.addresses.get_or_insert(Vec::new());
+                v.push(addresse.into());
+                self
+            }
+            pub fn addresses<I, S>(mut self, addresses: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Address>,
+            {
+                let v = self.addresses.get_or_insert(Vec::new());
+                for val in addresses {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetAddressesParams, String> {
+                Ok(SetAddressesParams {
+                    addresses: self.addresses.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(addresses))
+                    })?,
+                })
+            }
+        }
+        impl SetAddressesParams {
+            pub const IDENTIFIER: &'static str = "Autofill.setAddresses";
+        }
+        impl chromiumoxide_types::Method for SetAddressesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAddressesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set addresses so that developers can verify their forms implementation.\n[setAddresses](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#method-setAddresses)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAddressesReturns {}
+        impl chromiumoxide_types::Command for SetAddressesParams {
+            type Response = SetAddressesReturns;
+        }
+        #[doc = "Disables autofill domain notifications.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Autofill.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables autofill domain notifications.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables autofill domain notifications.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Autofill.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables autofill domain notifications.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Emitted when an address form is filled.\n[addressFormFilled](https://chromedevtools.github.io/devtools-protocol/tot/Autofill/#event-addressFormFilled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAddressFormFilled {
+            #[doc = "Information about the fields that were filled"]
+            #[serde(rename = "filledFields")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub filled_fields: Vec<FilledField>,
+            #[doc = "An UI representation of the address used to fill the form.\nConsists of a 2D array where each child represents an address/profile line."]
+            #[serde(rename = "addressUi")]
+            pub address_ui: AddressUi,
+        }
+        impl EventAddressFormFilled {
+            pub const IDENTIFIER: &'static str = "Autofill.addressFormFilled";
+        }
+        impl chromiumoxide_types::Method for EventAddressFormFilled {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAddressFormFilled {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "Defines events for background web platform features."]
+    pub mod background_service {
+        use serde::{Deserialize, Serialize};
+        #[doc = "The Background Service that will be associated with the commands/events.\nEvery Background Service operates independently, but they share the same\nAPI."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ServiceName {
+            #[serde(rename = "backgroundFetch")]
+            BackgroundFetch,
+            #[serde(rename = "backgroundSync")]
+            BackgroundSync,
+            #[serde(rename = "pushMessaging")]
+            PushMessaging,
+            #[serde(rename = "notifications")]
+            Notifications,
+            #[serde(rename = "paymentHandler")]
+            PaymentHandler,
+            #[serde(rename = "periodicBackgroundSync")]
+            PeriodicBackgroundSync,
+        }
+        impl AsRef<str> for ServiceName {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ServiceName::BackgroundFetch => "backgroundFetch",
+                    ServiceName::BackgroundSync => "backgroundSync",
+                    ServiceName::PushMessaging => "pushMessaging",
+                    ServiceName::Notifications => "notifications",
+                    ServiceName::PaymentHandler => "paymentHandler",
+                    ServiceName::PeriodicBackgroundSync => "periodicBackgroundSync",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ServiceName {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "backgroundFetch" | "BackgroundFetch" | "backgroundfetch" => {
+                        Ok(ServiceName::BackgroundFetch)
+                    }
+                    "backgroundSync" | "BackgroundSync" | "backgroundsync" => {
+                        Ok(ServiceName::BackgroundSync)
+                    }
+                    "pushMessaging" | "PushMessaging" | "pushmessaging" => {
+                        Ok(ServiceName::PushMessaging)
+                    }
+                    "notifications" | "Notifications" => Ok(ServiceName::Notifications),
+                    "paymentHandler" | "PaymentHandler" | "paymenthandler" => {
+                        Ok(ServiceName::PaymentHandler)
+                    }
+                    "periodicBackgroundSync"
+                    | "PeriodicBackgroundSync"
+                    | "periodicbackgroundsync" => Ok(ServiceName::PeriodicBackgroundSync),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "A key-value pair for additional event information to pass along.\n[EventMetadata](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#type-EventMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventMetadata {
+            #[serde(rename = "key")]
+            pub key: String,
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl EventMetadata {
+            pub fn new(key: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    key: key.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl EventMetadata {
+            pub fn builder() -> EventMetadataBuilder {
+                EventMetadataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EventMetadataBuilder {
+            key: Option<String>,
+            value: Option<String>,
+        }
+        impl EventMetadataBuilder {
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<EventMetadata, String> {
+                Ok(EventMetadata {
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl EventMetadata {
+            pub const IDENTIFIER: &'static str = "BackgroundService.EventMetadata";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BackgroundServiceEvent {
+            #[doc = "Timestamp of the event (in seconds)."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: super::network::TimeSinceEpoch,
+            #[doc = "The origin this event belongs to."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "The Service Worker ID that initiated the event."]
+            #[serde(rename = "serviceWorkerRegistrationId")]
+            pub service_worker_registration_id: super::service_worker::RegistrationId,
+            #[doc = "The Background Service this event belongs to."]
+            #[serde(rename = "service")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub service: ServiceName,
+            #[doc = "A description of the event."]
+            #[serde(rename = "eventName")]
+            pub event_name: String,
+            #[doc = "An identifier that groups related events together."]
+            #[serde(rename = "instanceId")]
+            pub instance_id: String,
+            #[doc = "A list of event-specific information."]
+            #[serde(rename = "eventMetadata")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub event_metadata: Vec<EventMetadata>,
+            #[doc = "Storage key this event belongs to."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+        }
+        impl BackgroundServiceEvent {
+            pub fn builder() -> BackgroundServiceEventBuilder {
+                BackgroundServiceEventBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BackgroundServiceEventBuilder {
+            timestamp: Option<super::network::TimeSinceEpoch>,
+            origin: Option<String>,
+            service_worker_registration_id: Option<super::service_worker::RegistrationId>,
+            service: Option<ServiceName>,
+            event_name: Option<String>,
+            instance_id: Option<String>,
+            event_metadata: Option<Vec<EventMetadata>>,
+            storage_key: Option<String>,
+        }
+        impl BackgroundServiceEventBuilder {
+            pub fn timestamp(
+                mut self,
+                timestamp: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn service_worker_registration_id(
+                mut self,
+                service_worker_registration_id: impl Into<super::service_worker::RegistrationId>,
+            ) -> Self {
+                self.service_worker_registration_id = Some(service_worker_registration_id.into());
+                self
+            }
+            pub fn service(mut self, service: impl Into<ServiceName>) -> Self {
+                self.service = Some(service.into());
+                self
+            }
+            pub fn event_name(mut self, event_name: impl Into<String>) -> Self {
+                self.event_name = Some(event_name.into());
+                self
+            }
+            pub fn instance_id(mut self, instance_id: impl Into<String>) -> Self {
+                self.instance_id = Some(instance_id.into());
+                self
+            }
+            pub fn event_metadata(mut self, event_metadata: impl Into<EventMetadata>) -> Self {
+                let v = self.event_metadata.get_or_insert(Vec::new());
+                v.push(event_metadata.into());
+                self
+            }
+            pub fn event_metadatas<I, S>(mut self, event_metadatas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<EventMetadata>,
+            {
+                let v = self.event_metadata.get_or_insert(Vec::new());
+                for val in event_metadatas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn build(self) -> Result<BackgroundServiceEvent, String> {
+                Ok(BackgroundServiceEvent {
+                    timestamp: self.timestamp.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(timestamp))
+                    })?,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    service_worker_registration_id: self
+                        .service_worker_registration_id
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(service_worker_registration_id)
+                            )
+                        })?,
+                    service: self.service.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(service))
+                    })?,
+                    event_name: self.event_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(event_name))
+                    })?,
+                    instance_id: self.instance_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(instance_id))
+                    })?,
+                    event_metadata: self.event_metadata.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(event_metadata))
+                    })?,
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                })
+            }
+        }
+        impl BackgroundServiceEvent {
+            pub const IDENTIFIER: &'static str = "BackgroundService.BackgroundServiceEvent";
+        }
+        #[doc = "Enables event updates for the service.\n[startObserving](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#method-startObserving)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StartObservingParams {
+            #[serde(rename = "service")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub service: ServiceName,
+        }
+        impl StartObservingParams {
+            pub fn new(service: impl Into<ServiceName>) -> Self {
+                Self {
+                    service: service.into(),
+                }
+            }
+        }
+        impl StartObservingParams {
+            pub fn builder() -> StartObservingParamsBuilder {
+                StartObservingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartObservingParamsBuilder {
+            service: Option<ServiceName>,
+        }
+        impl StartObservingParamsBuilder {
+            pub fn service(mut self, service: impl Into<ServiceName>) -> Self {
+                self.service = Some(service.into());
+                self
+            }
+            pub fn build(self) -> Result<StartObservingParams, String> {
+                Ok(StartObservingParams {
+                    service: self.service.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(service))
+                    })?,
+                })
+            }
+        }
+        impl StartObservingParams {
+            pub const IDENTIFIER: &'static str = "BackgroundService.startObserving";
+        }
+        impl chromiumoxide_types::Method for StartObservingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartObservingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables event updates for the service.\n[startObserving](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#method-startObserving)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartObservingReturns {}
+        impl chromiumoxide_types::Command for StartObservingParams {
+            type Response = StartObservingReturns;
+        }
+        #[doc = "Disables event updates for the service.\n[stopObserving](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#method-stopObserving)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StopObservingParams {
+            #[serde(rename = "service")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub service: ServiceName,
+        }
+        impl StopObservingParams {
+            pub fn new(service: impl Into<ServiceName>) -> Self {
+                Self {
+                    service: service.into(),
+                }
+            }
+        }
+        impl StopObservingParams {
+            pub fn builder() -> StopObservingParamsBuilder {
+                StopObservingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StopObservingParamsBuilder {
+            service: Option<ServiceName>,
+        }
+        impl StopObservingParamsBuilder {
+            pub fn service(mut self, service: impl Into<ServiceName>) -> Self {
+                self.service = Some(service.into());
+                self
+            }
+            pub fn build(self) -> Result<StopObservingParams, String> {
+                Ok(StopObservingParams {
+                    service: self.service.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(service))
+                    })?,
+                })
+            }
+        }
+        impl StopObservingParams {
+            pub const IDENTIFIER: &'static str = "BackgroundService.stopObserving";
+        }
+        impl chromiumoxide_types::Method for StopObservingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopObservingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables event updates for the service.\n[stopObserving](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#method-stopObserving)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopObservingReturns {}
+        impl chromiumoxide_types::Command for StopObservingParams {
+            type Response = StopObservingReturns;
+        }
+        #[doc = "Set the recording state for the service.\n[setRecording](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#method-setRecording)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetRecordingParams {
+            #[serde(rename = "shouldRecord")]
+            pub should_record: bool,
+            #[serde(rename = "service")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub service: ServiceName,
+        }
+        impl SetRecordingParams {
+            pub fn new(should_record: impl Into<bool>, service: impl Into<ServiceName>) -> Self {
+                Self {
+                    should_record: should_record.into(),
+                    service: service.into(),
+                }
+            }
+        }
+        impl SetRecordingParams {
+            pub fn builder() -> SetRecordingParamsBuilder {
+                SetRecordingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetRecordingParamsBuilder {
+            should_record: Option<bool>,
+            service: Option<ServiceName>,
+        }
+        impl SetRecordingParamsBuilder {
+            pub fn should_record(mut self, should_record: impl Into<bool>) -> Self {
+                self.should_record = Some(should_record.into());
+                self
+            }
+            pub fn service(mut self, service: impl Into<ServiceName>) -> Self {
+                self.service = Some(service.into());
+                self
+            }
+            pub fn build(self) -> Result<SetRecordingParams, String> {
+                Ok(SetRecordingParams {
+                    should_record: self.should_record.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(should_record))
+                    })?,
+                    service: self.service.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(service))
+                    })?,
+                })
+            }
+        }
+        impl SetRecordingParams {
+            pub const IDENTIFIER: &'static str = "BackgroundService.setRecording";
+        }
+        impl chromiumoxide_types::Method for SetRecordingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetRecordingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set the recording state for the service.\n[setRecording](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#method-setRecording)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetRecordingReturns {}
+        impl chromiumoxide_types::Command for SetRecordingParams {
+            type Response = SetRecordingReturns;
+        }
+        #[doc = "Clears all stored data for the service.\n[clearEvents](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#method-clearEvents)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClearEventsParams {
+            #[serde(rename = "service")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub service: ServiceName,
+        }
+        impl ClearEventsParams {
+            pub fn new(service: impl Into<ServiceName>) -> Self {
+                Self {
+                    service: service.into(),
+                }
+            }
+        }
+        impl ClearEventsParams {
+            pub fn builder() -> ClearEventsParamsBuilder {
+                ClearEventsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearEventsParamsBuilder {
+            service: Option<ServiceName>,
+        }
+        impl ClearEventsParamsBuilder {
+            pub fn service(mut self, service: impl Into<ServiceName>) -> Self {
+                self.service = Some(service.into());
+                self
+            }
+            pub fn build(self) -> Result<ClearEventsParams, String> {
+                Ok(ClearEventsParams {
+                    service: self.service.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(service))
+                    })?,
+                })
+            }
+        }
+        impl ClearEventsParams {
+            pub const IDENTIFIER: &'static str = "BackgroundService.clearEvents";
+        }
+        impl chromiumoxide_types::Method for ClearEventsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearEventsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears all stored data for the service.\n[clearEvents](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#method-clearEvents)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearEventsReturns {}
+        impl chromiumoxide_types::Command for ClearEventsParams {
+            type Response = ClearEventsReturns;
+        }
+        #[doc = "Called when the recording state for the service has been updated.\n[recordingStateChanged](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#event-recordingStateChanged)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventRecordingStateChanged {
+            #[serde(rename = "isRecording")]
+            pub is_recording: bool,
+            #[serde(rename = "service")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub service: ServiceName,
+        }
+        impl EventRecordingStateChanged {
+            pub const IDENTIFIER: &'static str = "BackgroundService.recordingStateChanged";
+        }
+        impl chromiumoxide_types::Method for EventRecordingStateChanged {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventRecordingStateChanged {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Called with all existing backgroundServiceEvents when enabled, and all new\nevents afterwards if enabled and recording.\n[backgroundServiceEventReceived](https://chromedevtools.github.io/devtools-protocol/tot/BackgroundService/#event-backgroundServiceEventReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventBackgroundServiceEventReceived {
+            #[serde(rename = "backgroundServiceEvent")]
+            pub background_service_event: BackgroundServiceEvent,
+        }
+        impl EventBackgroundServiceEventReceived {
+            pub const IDENTIFIER: &'static str = "BackgroundService.backgroundServiceEventReceived";
+        }
+        impl chromiumoxide_types::Method for EventBackgroundServiceEventReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventBackgroundServiceEventReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "This domain allows configuring virtual Bluetooth devices to test\nthe web-bluetooth API."]
+    pub mod bluetooth_emulation {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Indicates the various states of Central."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CentralState {
+            #[serde(rename = "absent")]
+            Absent,
+            #[serde(rename = "powered-off")]
+            PoweredOff,
+            #[serde(rename = "powered-on")]
+            PoweredOn,
+        }
+        impl AsRef<str> for CentralState {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CentralState::Absent => "absent",
+                    CentralState::PoweredOff => "powered-off",
+                    CentralState::PoweredOn => "powered-on",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CentralState {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "absent" | "Absent" => Ok(CentralState::Absent),
+                    "powered-off" | "PoweredOff" => Ok(CentralState::PoweredOff),
+                    "powered-on" | "PoweredOn" => Ok(CentralState::PoweredOn),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Indicates the various types of GATT event."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum GattOperationType {
+            #[serde(rename = "connection")]
+            Connection,
+            #[serde(rename = "discovery")]
+            Discovery,
+        }
+        impl AsRef<str> for GattOperationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    GattOperationType::Connection => "connection",
+                    GattOperationType::Discovery => "discovery",
+                }
+            }
+        }
+        impl ::std::str::FromStr for GattOperationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "connection" | "Connection" => Ok(GattOperationType::Connection),
+                    "discovery" | "Discovery" => Ok(GattOperationType::Discovery),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Indicates the various types of characteristic write."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CharacteristicWriteType {
+            #[serde(rename = "write-default-deprecated")]
+            WriteDefaultDeprecated,
+            #[serde(rename = "write-with-response")]
+            WriteWithResponse,
+            #[serde(rename = "write-without-response")]
+            WriteWithoutResponse,
+        }
+        impl AsRef<str> for CharacteristicWriteType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CharacteristicWriteType::WriteDefaultDeprecated => "write-default-deprecated",
+                    CharacteristicWriteType::WriteWithResponse => "write-with-response",
+                    CharacteristicWriteType::WriteWithoutResponse => "write-without-response",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CharacteristicWriteType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "write-default-deprecated" | "WriteDefaultDeprecated" => {
+                        Ok(CharacteristicWriteType::WriteDefaultDeprecated)
+                    }
+                    "write-with-response" | "WriteWithResponse" => {
+                        Ok(CharacteristicWriteType::WriteWithResponse)
+                    }
+                    "write-without-response" | "WriteWithoutResponse" => {
+                        Ok(CharacteristicWriteType::WriteWithoutResponse)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Indicates the various types of characteristic operation."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CharacteristicOperationType {
+            #[serde(rename = "read")]
+            Read,
+            #[serde(rename = "write")]
+            Write,
+            #[serde(rename = "subscribe-to-notifications")]
+            SubscribeToNotifications,
+            #[serde(rename = "unsubscribe-from-notifications")]
+            UnsubscribeFromNotifications,
+        }
+        impl AsRef<str> for CharacteristicOperationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CharacteristicOperationType::Read => "read",
+                    CharacteristicOperationType::Write => "write",
+                    CharacteristicOperationType::SubscribeToNotifications => {
+                        "subscribe-to-notifications"
+                    }
+                    CharacteristicOperationType::UnsubscribeFromNotifications => {
+                        "unsubscribe-from-notifications"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for CharacteristicOperationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "read" | "Read" => Ok(CharacteristicOperationType::Read),
+                    "write" | "Write" => Ok(CharacteristicOperationType::Write),
+                    "subscribe-to-notifications" | "SubscribeToNotifications" => {
+                        Ok(CharacteristicOperationType::SubscribeToNotifications)
+                    }
+                    "unsubscribe-from-notifications" | "UnsubscribeFromNotifications" => {
+                        Ok(CharacteristicOperationType::UnsubscribeFromNotifications)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Indicates the various types of descriptor operation."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DescriptorOperationType {
+            #[serde(rename = "read")]
+            Read,
+            #[serde(rename = "write")]
+            Write,
+        }
+        impl AsRef<str> for DescriptorOperationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DescriptorOperationType::Read => "read",
+                    DescriptorOperationType::Write => "write",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DescriptorOperationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "read" | "Read" => Ok(DescriptorOperationType::Read),
+                    "write" | "Write" => Ok(DescriptorOperationType::Write),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Stores the manufacturer data\n[ManufacturerData](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#type-ManufacturerData)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ManufacturerData {
+            #[doc = "Company identifier\nhttps://bitbucket.org/bluetooth-SIG/public/src/main/assigned_numbers/company_identifiers/company_identifiers.yaml\nhttps://usb.org/developers"]
+            #[serde(rename = "key")]
+            pub key: i64,
+            #[doc = "Manufacturer-specific data"]
+            #[serde(rename = "data")]
+            pub data: chromiumoxide_types::Binary,
+        }
+        impl ManufacturerData {
+            pub fn new(key: impl Into<i64>, data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                Self {
+                    key: key.into(),
+                    data: data.into(),
+                }
+            }
+        }
+        impl ManufacturerData {
+            pub fn builder() -> ManufacturerDataBuilder {
+                ManufacturerDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ManufacturerDataBuilder {
+            key: Option<i64>,
+            data: Option<chromiumoxide_types::Binary>,
+        }
+        impl ManufacturerDataBuilder {
+            pub fn key(mut self, key: impl Into<i64>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn data(mut self, data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn build(self) -> Result<ManufacturerData, String> {
+                Ok(ManufacturerData {
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                })
+            }
+        }
+        impl ManufacturerData {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.ManufacturerData";
+        }
+        #[doc = "Stores the byte data of the advertisement packet sent by a Bluetooth device.\n[ScanRecord](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#type-ScanRecord)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ScanRecord {
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[serde(rename = "uuids")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub uuids: Option<Vec<String>>,
+            #[doc = "Stores the external appearance description of the device."]
+            #[serde(rename = "appearance")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub appearance: Option<i64>,
+            #[doc = "Stores the transmission power of a broadcasting device."]
+            #[serde(rename = "txPower")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub tx_power: Option<i64>,
+            #[doc = "Key is the company identifier and the value is an array of bytes of\nmanufacturer specific data."]
+            #[serde(rename = "manufacturerData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub manufacturer_data: Option<Vec<ManufacturerData>>,
+        }
+        impl ScanRecord {
+            pub fn builder() -> ScanRecordBuilder {
+                ScanRecordBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScanRecordBuilder {
+            name: Option<String>,
+            uuids: Option<Vec<String>>,
+            appearance: Option<i64>,
+            tx_power: Option<i64>,
+            manufacturer_data: Option<Vec<ManufacturerData>>,
+        }
+        impl ScanRecordBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn uuid(mut self, uuid: impl Into<String>) -> Self {
+                let v = self.uuids.get_or_insert(Vec::new());
+                v.push(uuid.into());
+                self
+            }
+            pub fn uuids<I, S>(mut self, uuids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.uuids.get_or_insert(Vec::new());
+                for val in uuids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn appearance(mut self, appearance: impl Into<i64>) -> Self {
+                self.appearance = Some(appearance.into());
+                self
+            }
+            pub fn tx_power(mut self, tx_power: impl Into<i64>) -> Self {
+                self.tx_power = Some(tx_power.into());
+                self
+            }
+            pub fn manufacturer_data(
+                mut self,
+                manufacturer_data: impl Into<ManufacturerData>,
+            ) -> Self {
+                let v = self.manufacturer_data.get_or_insert(Vec::new());
+                v.push(manufacturer_data.into());
+                self
+            }
+            pub fn manufacturer_datas<I, S>(mut self, manufacturer_datas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ManufacturerData>,
+            {
+                let v = self.manufacturer_data.get_or_insert(Vec::new());
+                for val in manufacturer_datas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> ScanRecord {
+                ScanRecord {
+                    name: self.name,
+                    uuids: self.uuids,
+                    appearance: self.appearance,
+                    tx_power: self.tx_power,
+                    manufacturer_data: self.manufacturer_data,
+                }
+            }
+        }
+        impl ScanRecord {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.ScanRecord";
+        }
+        #[doc = "Stores the advertisement packet information that is sent by a Bluetooth device.\n[ScanEntry](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#type-ScanEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScanEntry {
+            #[serde(rename = "deviceAddress")]
+            pub device_address: String,
+            #[serde(rename = "rssi")]
+            pub rssi: i64,
+            #[serde(rename = "scanRecord")]
+            pub scan_record: ScanRecord,
+        }
+        impl ScanEntry {
+            pub fn new(
+                device_address: impl Into<String>,
+                rssi: impl Into<i64>,
+                scan_record: impl Into<ScanRecord>,
+            ) -> Self {
+                Self {
+                    device_address: device_address.into(),
+                    rssi: rssi.into(),
+                    scan_record: scan_record.into(),
+                }
+            }
+        }
+        impl ScanEntry {
+            pub fn builder() -> ScanEntryBuilder {
+                ScanEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScanEntryBuilder {
+            device_address: Option<String>,
+            rssi: Option<i64>,
+            scan_record: Option<ScanRecord>,
+        }
+        impl ScanEntryBuilder {
+            pub fn device_address(mut self, device_address: impl Into<String>) -> Self {
+                self.device_address = Some(device_address.into());
+                self
+            }
+            pub fn rssi(mut self, rssi: impl Into<i64>) -> Self {
+                self.rssi = Some(rssi.into());
+                self
+            }
+            pub fn scan_record(mut self, scan_record: impl Into<ScanRecord>) -> Self {
+                self.scan_record = Some(scan_record.into());
+                self
+            }
+            pub fn build(self) -> Result<ScanEntry, String> {
+                Ok(ScanEntry {
+                    device_address: self.device_address.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(device_address))
+                    })?,
+                    rssi: self.rssi.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rssi))
+                    })?,
+                    scan_record: self.scan_record.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scan_record))
+                    })?,
+                })
+            }
+        }
+        impl ScanEntry {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.ScanEntry";
+        }
+        #[doc = "Describes the properties of a characteristic. This follows Bluetooth Core\nSpecification BT 4.2 Vol 3 Part G 3.3.1. Characteristic Properties.\n[CharacteristicProperties](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#type-CharacteristicProperties)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CharacteristicProperties {
+            #[serde(rename = "broadcast")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub broadcast: Option<bool>,
+            #[serde(rename = "read")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub read: Option<bool>,
+            #[serde(rename = "writeWithoutResponse")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub write_without_response: Option<bool>,
+            #[serde(rename = "write")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub write: Option<bool>,
+            #[serde(rename = "notify")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub notify: Option<bool>,
+            #[serde(rename = "indicate")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub indicate: Option<bool>,
+            #[serde(rename = "authenticatedSignedWrites")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub authenticated_signed_writes: Option<bool>,
+            #[serde(rename = "extendedProperties")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub extended_properties: Option<bool>,
+        }
+        impl CharacteristicProperties {
+            pub fn builder() -> CharacteristicPropertiesBuilder {
+                CharacteristicPropertiesBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CharacteristicPropertiesBuilder {
+            broadcast: Option<bool>,
+            read: Option<bool>,
+            write_without_response: Option<bool>,
+            write: Option<bool>,
+            notify: Option<bool>,
+            indicate: Option<bool>,
+            authenticated_signed_writes: Option<bool>,
+            extended_properties: Option<bool>,
+        }
+        impl CharacteristicPropertiesBuilder {
+            pub fn broadcast(mut self, broadcast: impl Into<bool>) -> Self {
+                self.broadcast = Some(broadcast.into());
+                self
+            }
+            pub fn read(mut self, read: impl Into<bool>) -> Self {
+                self.read = Some(read.into());
+                self
+            }
+            pub fn write_without_response(
+                mut self,
+                write_without_response: impl Into<bool>,
+            ) -> Self {
+                self.write_without_response = Some(write_without_response.into());
+                self
+            }
+            pub fn write(mut self, write: impl Into<bool>) -> Self {
+                self.write = Some(write.into());
+                self
+            }
+            pub fn notify(mut self, notify: impl Into<bool>) -> Self {
+                self.notify = Some(notify.into());
+                self
+            }
+            pub fn indicate(mut self, indicate: impl Into<bool>) -> Self {
+                self.indicate = Some(indicate.into());
+                self
+            }
+            pub fn authenticated_signed_writes(
+                mut self,
+                authenticated_signed_writes: impl Into<bool>,
+            ) -> Self {
+                self.authenticated_signed_writes = Some(authenticated_signed_writes.into());
+                self
+            }
+            pub fn extended_properties(mut self, extended_properties: impl Into<bool>) -> Self {
+                self.extended_properties = Some(extended_properties.into());
+                self
+            }
+            pub fn build(self) -> CharacteristicProperties {
+                CharacteristicProperties {
+                    broadcast: self.broadcast,
+                    read: self.read,
+                    write_without_response: self.write_without_response,
+                    write: self.write,
+                    notify: self.notify,
+                    indicate: self.indicate,
+                    authenticated_signed_writes: self.authenticated_signed_writes,
+                    extended_properties: self.extended_properties,
+                }
+            }
+        }
+        impl CharacteristicProperties {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.CharacteristicProperties";
+        }
+        #[doc = "Enable the BluetoothEmulation domain.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[doc = "State of the simulated central."]
+            #[serde(rename = "state")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub state: CentralState,
+            #[doc = "If the simulated central supports low-energy."]
+            #[serde(rename = "leSupported")]
+            pub le_supported: bool,
+        }
+        impl EnableParams {
+            pub fn new(state: impl Into<CentralState>, le_supported: impl Into<bool>) -> Self {
+                Self {
+                    state: state.into(),
+                    le_supported: le_supported.into(),
+                }
+            }
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            state: Option<CentralState>,
+            le_supported: Option<bool>,
+        }
+        impl EnableParamsBuilder {
+            pub fn state(mut self, state: impl Into<CentralState>) -> Self {
+                self.state = Some(state.into());
+                self
+            }
+            pub fn le_supported(mut self, le_supported: impl Into<bool>) -> Self {
+                self.le_supported = Some(le_supported.into());
+                self
+            }
+            pub fn build(self) -> Result<EnableParams, String> {
+                Ok(EnableParams {
+                    state: self.state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(state))
+                    })?,
+                    le_supported: self.le_supported.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(le_supported))
+                    })?,
+                })
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enable the BluetoothEmulation domain.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Set the state of the simulated central.\n[setSimulatedCentralState](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-setSimulatedCentralState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSimulatedCentralStateParams {
+            #[doc = "State of the simulated central."]
+            #[serde(rename = "state")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub state: CentralState,
+        }
+        impl SetSimulatedCentralStateParams {
+            pub fn new(state: impl Into<CentralState>) -> Self {
+                Self {
+                    state: state.into(),
+                }
+            }
+        }
+        impl SetSimulatedCentralStateParams {
+            pub fn builder() -> SetSimulatedCentralStateParamsBuilder {
+                SetSimulatedCentralStateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSimulatedCentralStateParamsBuilder {
+            state: Option<CentralState>,
+        }
+        impl SetSimulatedCentralStateParamsBuilder {
+            pub fn state(mut self, state: impl Into<CentralState>) -> Self {
+                self.state = Some(state.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSimulatedCentralStateParams, String> {
+                Ok(SetSimulatedCentralStateParams {
+                    state: self.state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(state))
+                    })?,
+                })
+            }
+        }
+        impl SetSimulatedCentralStateParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.setSimulatedCentralState";
+        }
+        impl chromiumoxide_types::Method for SetSimulatedCentralStateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSimulatedCentralStateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set the state of the simulated central.\n[setSimulatedCentralState](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-setSimulatedCentralState)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSimulatedCentralStateReturns {}
+        impl chromiumoxide_types::Command for SetSimulatedCentralStateParams {
+            type Response = SetSimulatedCentralStateReturns;
+        }
+        #[doc = "Disable the BluetoothEmulation domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disable the BluetoothEmulation domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Simulates a peripheral with |address|, |name| and |knownServiceUuids|\nthat has already been connected to the system.\n[simulatePreconnectedPeripheral](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulatePreconnectedPeripheral)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SimulatePreconnectedPeripheralParams {
+            #[serde(rename = "address")]
+            pub address: String,
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "manufacturerData")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub manufacturer_data: Vec<ManufacturerData>,
+            #[serde(rename = "knownServiceUuids")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub known_service_uuids: Vec<String>,
+        }
+        impl SimulatePreconnectedPeripheralParams {
+            pub fn new(
+                address: impl Into<String>,
+                name: impl Into<String>,
+                manufacturer_data: Vec<ManufacturerData>,
+                known_service_uuids: Vec<String>,
+            ) -> Self {
+                Self {
+                    address: address.into(),
+                    name: name.into(),
+                    manufacturer_data,
+                    known_service_uuids,
+                }
+            }
+        }
+        impl SimulatePreconnectedPeripheralParams {
+            pub fn builder() -> SimulatePreconnectedPeripheralParamsBuilder {
+                SimulatePreconnectedPeripheralParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SimulatePreconnectedPeripheralParamsBuilder {
+            address: Option<String>,
+            name: Option<String>,
+            manufacturer_data: Option<Vec<ManufacturerData>>,
+            known_service_uuids: Option<Vec<String>>,
+        }
+        impl SimulatePreconnectedPeripheralParamsBuilder {
+            pub fn address(mut self, address: impl Into<String>) -> Self {
+                self.address = Some(address.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn manufacturer_data(
+                mut self,
+                manufacturer_data: impl Into<ManufacturerData>,
+            ) -> Self {
+                let v = self.manufacturer_data.get_or_insert(Vec::new());
+                v.push(manufacturer_data.into());
+                self
+            }
+            pub fn manufacturer_datas<I, S>(mut self, manufacturer_datas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ManufacturerData>,
+            {
+                let v = self.manufacturer_data.get_or_insert(Vec::new());
+                for val in manufacturer_datas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn known_service_uuid(mut self, known_service_uuid: impl Into<String>) -> Self {
+                let v = self.known_service_uuids.get_or_insert(Vec::new());
+                v.push(known_service_uuid.into());
+                self
+            }
+            pub fn known_service_uuids<I, S>(mut self, known_service_uuids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.known_service_uuids.get_or_insert(Vec::new());
+                for val in known_service_uuids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SimulatePreconnectedPeripheralParams, String> {
+                Ok(SimulatePreconnectedPeripheralParams {
+                    address: self.address.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(address))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    manufacturer_data: self.manufacturer_data.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(manufacturer_data)
+                        )
+                    })?,
+                    known_service_uuids: self.known_service_uuids.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(known_service_uuids)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl SimulatePreconnectedPeripheralParams {
+            pub const IDENTIFIER: &'static str =
+                "BluetoothEmulation.simulatePreconnectedPeripheral";
+        }
+        impl chromiumoxide_types::Method for SimulatePreconnectedPeripheralParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SimulatePreconnectedPeripheralParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Simulates a peripheral with |address|, |name| and |knownServiceUuids|\nthat has already been connected to the system.\n[simulatePreconnectedPeripheral](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulatePreconnectedPeripheral)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SimulatePreconnectedPeripheralReturns {}
+        impl chromiumoxide_types::Command for SimulatePreconnectedPeripheralParams {
+            type Response = SimulatePreconnectedPeripheralReturns;
+        }
+        #[doc = "Simulates an advertisement packet described in |entry| being received by\nthe central.\n[simulateAdvertisement](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulateAdvertisement)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SimulateAdvertisementParams {
+            #[serde(rename = "entry")]
+            pub entry: ScanEntry,
+        }
+        impl SimulateAdvertisementParams {
+            pub fn new(entry: impl Into<ScanEntry>) -> Self {
+                Self {
+                    entry: entry.into(),
+                }
+            }
+        }
+        impl SimulateAdvertisementParams {
+            pub fn builder() -> SimulateAdvertisementParamsBuilder {
+                SimulateAdvertisementParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SimulateAdvertisementParamsBuilder {
+            entry: Option<ScanEntry>,
+        }
+        impl SimulateAdvertisementParamsBuilder {
+            pub fn entry(mut self, entry: impl Into<ScanEntry>) -> Self {
+                self.entry = Some(entry.into());
+                self
+            }
+            pub fn build(self) -> Result<SimulateAdvertisementParams, String> {
+                Ok(SimulateAdvertisementParams {
+                    entry: self.entry.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(entry))
+                    })?,
+                })
+            }
+        }
+        impl SimulateAdvertisementParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.simulateAdvertisement";
+        }
+        impl chromiumoxide_types::Method for SimulateAdvertisementParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SimulateAdvertisementParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Simulates an advertisement packet described in |entry| being received by\nthe central.\n[simulateAdvertisement](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulateAdvertisement)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SimulateAdvertisementReturns {}
+        impl chromiumoxide_types::Command for SimulateAdvertisementParams {
+            type Response = SimulateAdvertisementReturns;
+        }
+        #[doc = "Simulates the response code from the peripheral with |address| for a\nGATT operation of |type|. The |code| value follows the HCI Error Codes from\nBluetooth Core Specification Vol 2 Part D 1.3 List Of Error Codes.\n[simulateGATTOperationResponse](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulateGATTOperationResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SimulateGattOperationResponseParams {
+            #[serde(rename = "address")]
+            pub address: String,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: GattOperationType,
+            #[serde(rename = "code")]
+            pub code: i64,
+        }
+        impl SimulateGattOperationResponseParams {
+            pub fn new(
+                address: impl Into<String>,
+                r#type: impl Into<GattOperationType>,
+                code: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    address: address.into(),
+                    r#type: r#type.into(),
+                    code: code.into(),
+                }
+            }
+        }
+        impl SimulateGattOperationResponseParams {
+            pub fn builder() -> SimulateGattOperationResponseParamsBuilder {
+                SimulateGattOperationResponseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SimulateGattOperationResponseParamsBuilder {
+            address: Option<String>,
+            r#type: Option<GattOperationType>,
+            code: Option<i64>,
+        }
+        impl SimulateGattOperationResponseParamsBuilder {
+            pub fn address(mut self, address: impl Into<String>) -> Self {
+                self.address = Some(address.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<GattOperationType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn code(mut self, code: impl Into<i64>) -> Self {
+                self.code = Some(code.into());
+                self
+            }
+            pub fn build(self) -> Result<SimulateGattOperationResponseParams, String> {
+                Ok(SimulateGattOperationResponseParams {
+                    address: self.address.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(address))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    code: self.code.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(code))
+                    })?,
+                })
+            }
+        }
+        impl SimulateGattOperationResponseParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.simulateGATTOperationResponse";
+        }
+        impl chromiumoxide_types::Method for SimulateGattOperationResponseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SimulateGattOperationResponseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Simulates the response code from the peripheral with |address| for a\nGATT operation of |type|. The |code| value follows the HCI Error Codes from\nBluetooth Core Specification Vol 2 Part D 1.3 List Of Error Codes.\n[simulateGATTOperationResponse](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulateGATTOperationResponse)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SimulateGattOperationResponseReturns {}
+        impl chromiumoxide_types::Command for SimulateGattOperationResponseParams {
+            type Response = SimulateGattOperationResponseReturns;
+        }
+        #[doc = "Simulates the response from the characteristic with |characteristicId| for a\ncharacteristic operation of |type|. The |code| value follows the Error\nCodes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.\nThe |data| is expected to exist when simulating a successful read operation\nresponse.\n[simulateCharacteristicOperationResponse](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulateCharacteristicOperationResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SimulateCharacteristicOperationResponseParams {
+            #[serde(rename = "characteristicId")]
+            pub characteristic_id: String,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: CharacteristicOperationType,
+            #[serde(rename = "code")]
+            pub code: i64,
+            #[serde(rename = "data")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub data: Option<chromiumoxide_types::Binary>,
+        }
+        impl SimulateCharacteristicOperationResponseParams {
+            pub fn new(
+                characteristic_id: impl Into<String>,
+                r#type: impl Into<CharacteristicOperationType>,
+                code: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    characteristic_id: characteristic_id.into(),
+                    r#type: r#type.into(),
+                    code: code.into(),
+                    data: None,
+                }
+            }
+        }
+        impl SimulateCharacteristicOperationResponseParams {
+            pub fn builder() -> SimulateCharacteristicOperationResponseParamsBuilder {
+                SimulateCharacteristicOperationResponseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SimulateCharacteristicOperationResponseParamsBuilder {
+            characteristic_id: Option<String>,
+            r#type: Option<CharacteristicOperationType>,
+            code: Option<i64>,
+            data: Option<chromiumoxide_types::Binary>,
+        }
+        impl SimulateCharacteristicOperationResponseParamsBuilder {
+            pub fn characteristic_id(mut self, characteristic_id: impl Into<String>) -> Self {
+                self.characteristic_id = Some(characteristic_id.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<CharacteristicOperationType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn code(mut self, code: impl Into<i64>) -> Self {
+                self.code = Some(code.into());
+                self
+            }
+            pub fn data(mut self, data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn build(self) -> Result<SimulateCharacteristicOperationResponseParams, String> {
+                Ok(SimulateCharacteristicOperationResponseParams {
+                    characteristic_id: self.characteristic_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(characteristic_id)
+                        )
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    code: self.code.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(code))
+                    })?,
+                    data: self.data,
+                })
+            }
+        }
+        impl SimulateCharacteristicOperationResponseParams {
+            pub const IDENTIFIER: &'static str =
+                "BluetoothEmulation.simulateCharacteristicOperationResponse";
+        }
+        impl chromiumoxide_types::Method for SimulateCharacteristicOperationResponseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SimulateCharacteristicOperationResponseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Simulates the response from the characteristic with |characteristicId| for a\ncharacteristic operation of |type|. The |code| value follows the Error\nCodes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.\nThe |data| is expected to exist when simulating a successful read operation\nresponse.\n[simulateCharacteristicOperationResponse](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulateCharacteristicOperationResponse)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SimulateCharacteristicOperationResponseReturns {}
+        impl chromiumoxide_types::Command for SimulateCharacteristicOperationResponseParams {
+            type Response = SimulateCharacteristicOperationResponseReturns;
+        }
+        #[doc = "Simulates the response from the descriptor with |descriptorId| for a\ndescriptor operation of |type|. The |code| value follows the Error\nCodes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.\nThe |data| is expected to exist when simulating a successful read operation\nresponse.\n[simulateDescriptorOperationResponse](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulateDescriptorOperationResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SimulateDescriptorOperationResponseParams {
+            #[serde(rename = "descriptorId")]
+            pub descriptor_id: String,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DescriptorOperationType,
+            #[serde(rename = "code")]
+            pub code: i64,
+            #[serde(rename = "data")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub data: Option<chromiumoxide_types::Binary>,
+        }
+        impl SimulateDescriptorOperationResponseParams {
+            pub fn new(
+                descriptor_id: impl Into<String>,
+                r#type: impl Into<DescriptorOperationType>,
+                code: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    descriptor_id: descriptor_id.into(),
+                    r#type: r#type.into(),
+                    code: code.into(),
+                    data: None,
+                }
+            }
+        }
+        impl SimulateDescriptorOperationResponseParams {
+            pub fn builder() -> SimulateDescriptorOperationResponseParamsBuilder {
+                SimulateDescriptorOperationResponseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SimulateDescriptorOperationResponseParamsBuilder {
+            descriptor_id: Option<String>,
+            r#type: Option<DescriptorOperationType>,
+            code: Option<i64>,
+            data: Option<chromiumoxide_types::Binary>,
+        }
+        impl SimulateDescriptorOperationResponseParamsBuilder {
+            pub fn descriptor_id(mut self, descriptor_id: impl Into<String>) -> Self {
+                self.descriptor_id = Some(descriptor_id.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<DescriptorOperationType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn code(mut self, code: impl Into<i64>) -> Self {
+                self.code = Some(code.into());
+                self
+            }
+            pub fn data(mut self, data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn build(self) -> Result<SimulateDescriptorOperationResponseParams, String> {
+                Ok(SimulateDescriptorOperationResponseParams {
+                    descriptor_id: self.descriptor_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(descriptor_id))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    code: self.code.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(code))
+                    })?,
+                    data: self.data,
+                })
+            }
+        }
+        impl SimulateDescriptorOperationResponseParams {
+            pub const IDENTIFIER: &'static str =
+                "BluetoothEmulation.simulateDescriptorOperationResponse";
+        }
+        impl chromiumoxide_types::Method for SimulateDescriptorOperationResponseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SimulateDescriptorOperationResponseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Simulates the response from the descriptor with |descriptorId| for a\ndescriptor operation of |type|. The |code| value follows the Error\nCodes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.\nThe |data| is expected to exist when simulating a successful read operation\nresponse.\n[simulateDescriptorOperationResponse](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulateDescriptorOperationResponse)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SimulateDescriptorOperationResponseReturns {}
+        impl chromiumoxide_types::Command for SimulateDescriptorOperationResponseParams {
+            type Response = SimulateDescriptorOperationResponseReturns;
+        }
+        #[doc = "Adds a service with |serviceUuid| to the peripheral with |address|.\n[addService](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-addService)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddServiceParams {
+            #[serde(rename = "address")]
+            pub address: String,
+            #[serde(rename = "serviceUuid")]
+            pub service_uuid: String,
+        }
+        impl AddServiceParams {
+            pub fn new(address: impl Into<String>, service_uuid: impl Into<String>) -> Self {
+                Self {
+                    address: address.into(),
+                    service_uuid: service_uuid.into(),
+                }
+            }
+        }
+        impl AddServiceParams {
+            pub fn builder() -> AddServiceParamsBuilder {
+                AddServiceParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddServiceParamsBuilder {
+            address: Option<String>,
+            service_uuid: Option<String>,
+        }
+        impl AddServiceParamsBuilder {
+            pub fn address(mut self, address: impl Into<String>) -> Self {
+                self.address = Some(address.into());
+                self
+            }
+            pub fn service_uuid(mut self, service_uuid: impl Into<String>) -> Self {
+                self.service_uuid = Some(service_uuid.into());
+                self
+            }
+            pub fn build(self) -> Result<AddServiceParams, String> {
+                Ok(AddServiceParams {
+                    address: self.address.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(address))
+                    })?,
+                    service_uuid: self.service_uuid.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(service_uuid))
+                    })?,
+                })
+            }
+        }
+        impl AddServiceParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.addService";
+        }
+        impl chromiumoxide_types::Method for AddServiceParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddServiceParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Adds a service with |serviceUuid| to the peripheral with |address|.\n[addService](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-addService)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddServiceReturns {
+            #[doc = "An identifier that uniquely represents this service."]
+            #[serde(rename = "serviceId")]
+            pub service_id: String,
+        }
+        impl AddServiceReturns {
+            pub fn new(service_id: impl Into<String>) -> Self {
+                Self {
+                    service_id: service_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for AddServiceReturns {
+            fn from(url: T) -> Self {
+                AddServiceReturns::new(url)
+            }
+        }
+        impl AddServiceReturns {
+            pub fn builder() -> AddServiceReturnsBuilder {
+                AddServiceReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddServiceReturnsBuilder {
+            service_id: Option<String>,
+        }
+        impl AddServiceReturnsBuilder {
+            pub fn service_id(mut self, service_id: impl Into<String>) -> Self {
+                self.service_id = Some(service_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AddServiceReturns, String> {
+                Ok(AddServiceReturns {
+                    service_id: self.service_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(service_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for AddServiceParams {
+            type Response = AddServiceReturns;
+        }
+        #[doc = "Removes the service respresented by |serviceId| from the simulated central.\n[removeService](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-removeService)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveServiceParams {
+            #[serde(rename = "serviceId")]
+            pub service_id: String,
+        }
+        impl RemoveServiceParams {
+            pub fn new(service_id: impl Into<String>) -> Self {
+                Self {
+                    service_id: service_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for RemoveServiceParams {
+            fn from(url: T) -> Self {
+                RemoveServiceParams::new(url)
+            }
+        }
+        impl RemoveServiceParams {
+            pub fn builder() -> RemoveServiceParamsBuilder {
+                RemoveServiceParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveServiceParamsBuilder {
+            service_id: Option<String>,
+        }
+        impl RemoveServiceParamsBuilder {
+            pub fn service_id(mut self, service_id: impl Into<String>) -> Self {
+                self.service_id = Some(service_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveServiceParams, String> {
+                Ok(RemoveServiceParams {
+                    service_id: self.service_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(service_id))
+                    })?,
+                })
+            }
+        }
+        impl RemoveServiceParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.removeService";
+        }
+        impl chromiumoxide_types::Method for RemoveServiceParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveServiceParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes the service respresented by |serviceId| from the simulated central.\n[removeService](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-removeService)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveServiceReturns {}
+        impl chromiumoxide_types::Command for RemoveServiceParams {
+            type Response = RemoveServiceReturns;
+        }
+        #[doc = "Adds a characteristic with |characteristicUuid| and |properties| to the\nservice represented by |serviceId|.\n[addCharacteristic](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-addCharacteristic)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddCharacteristicParams {
+            #[serde(rename = "serviceId")]
+            pub service_id: String,
+            #[serde(rename = "characteristicUuid")]
+            pub characteristic_uuid: String,
+            #[serde(rename = "properties")]
+            pub properties: CharacteristicProperties,
+        }
+        impl AddCharacteristicParams {
+            pub fn new(
+                service_id: impl Into<String>,
+                characteristic_uuid: impl Into<String>,
+                properties: impl Into<CharacteristicProperties>,
+            ) -> Self {
+                Self {
+                    service_id: service_id.into(),
+                    characteristic_uuid: characteristic_uuid.into(),
+                    properties: properties.into(),
+                }
+            }
+        }
+        impl AddCharacteristicParams {
+            pub fn builder() -> AddCharacteristicParamsBuilder {
+                AddCharacteristicParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddCharacteristicParamsBuilder {
+            service_id: Option<String>,
+            characteristic_uuid: Option<String>,
+            properties: Option<CharacteristicProperties>,
+        }
+        impl AddCharacteristicParamsBuilder {
+            pub fn service_id(mut self, service_id: impl Into<String>) -> Self {
+                self.service_id = Some(service_id.into());
+                self
+            }
+            pub fn characteristic_uuid(mut self, characteristic_uuid: impl Into<String>) -> Self {
+                self.characteristic_uuid = Some(characteristic_uuid.into());
+                self
+            }
+            pub fn properties(mut self, properties: impl Into<CharacteristicProperties>) -> Self {
+                self.properties = Some(properties.into());
+                self
+            }
+            pub fn build(self) -> Result<AddCharacteristicParams, String> {
+                Ok(AddCharacteristicParams {
+                    service_id: self.service_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(service_id))
+                    })?,
+                    characteristic_uuid: self.characteristic_uuid.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(characteristic_uuid)
+                        )
+                    })?,
+                    properties: self.properties.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(properties))
+                    })?,
+                })
+            }
+        }
+        impl AddCharacteristicParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.addCharacteristic";
+        }
+        impl chromiumoxide_types::Method for AddCharacteristicParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddCharacteristicParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Adds a characteristic with |characteristicUuid| and |properties| to the\nservice represented by |serviceId|.\n[addCharacteristic](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-addCharacteristic)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddCharacteristicReturns {
+            #[doc = "An identifier that uniquely represents this characteristic."]
+            #[serde(rename = "characteristicId")]
+            pub characteristic_id: String,
+        }
+        impl AddCharacteristicReturns {
+            pub fn new(characteristic_id: impl Into<String>) -> Self {
+                Self {
+                    characteristic_id: characteristic_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for AddCharacteristicReturns {
+            fn from(url: T) -> Self {
+                AddCharacteristicReturns::new(url)
+            }
+        }
+        impl AddCharacteristicReturns {
+            pub fn builder() -> AddCharacteristicReturnsBuilder {
+                AddCharacteristicReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddCharacteristicReturnsBuilder {
+            characteristic_id: Option<String>,
+        }
+        impl AddCharacteristicReturnsBuilder {
+            pub fn characteristic_id(mut self, characteristic_id: impl Into<String>) -> Self {
+                self.characteristic_id = Some(characteristic_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AddCharacteristicReturns, String> {
+                Ok(AddCharacteristicReturns {
+                    characteristic_id: self.characteristic_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(characteristic_id)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for AddCharacteristicParams {
+            type Response = AddCharacteristicReturns;
+        }
+        #[doc = "Removes the characteristic respresented by |characteristicId| from the\nsimulated central.\n[removeCharacteristic](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-removeCharacteristic)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveCharacteristicParams {
+            #[serde(rename = "characteristicId")]
+            pub characteristic_id: String,
+        }
+        impl RemoveCharacteristicParams {
+            pub fn new(characteristic_id: impl Into<String>) -> Self {
+                Self {
+                    characteristic_id: characteristic_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for RemoveCharacteristicParams {
+            fn from(url: T) -> Self {
+                RemoveCharacteristicParams::new(url)
+            }
+        }
+        impl RemoveCharacteristicParams {
+            pub fn builder() -> RemoveCharacteristicParamsBuilder {
+                RemoveCharacteristicParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveCharacteristicParamsBuilder {
+            characteristic_id: Option<String>,
+        }
+        impl RemoveCharacteristicParamsBuilder {
+            pub fn characteristic_id(mut self, characteristic_id: impl Into<String>) -> Self {
+                self.characteristic_id = Some(characteristic_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveCharacteristicParams, String> {
+                Ok(RemoveCharacteristicParams {
+                    characteristic_id: self.characteristic_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(characteristic_id)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl RemoveCharacteristicParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.removeCharacteristic";
+        }
+        impl chromiumoxide_types::Method for RemoveCharacteristicParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveCharacteristicParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes the characteristic respresented by |characteristicId| from the\nsimulated central.\n[removeCharacteristic](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-removeCharacteristic)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveCharacteristicReturns {}
+        impl chromiumoxide_types::Command for RemoveCharacteristicParams {
+            type Response = RemoveCharacteristicReturns;
+        }
+        #[doc = "Adds a descriptor with |descriptorUuid| to the characteristic respresented\nby |characteristicId|.\n[addDescriptor](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-addDescriptor)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddDescriptorParams {
+            #[serde(rename = "characteristicId")]
+            pub characteristic_id: String,
+            #[serde(rename = "descriptorUuid")]
+            pub descriptor_uuid: String,
+        }
+        impl AddDescriptorParams {
+            pub fn new(
+                characteristic_id: impl Into<String>,
+                descriptor_uuid: impl Into<String>,
+            ) -> Self {
+                Self {
+                    characteristic_id: characteristic_id.into(),
+                    descriptor_uuid: descriptor_uuid.into(),
+                }
+            }
+        }
+        impl AddDescriptorParams {
+            pub fn builder() -> AddDescriptorParamsBuilder {
+                AddDescriptorParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddDescriptorParamsBuilder {
+            characteristic_id: Option<String>,
+            descriptor_uuid: Option<String>,
+        }
+        impl AddDescriptorParamsBuilder {
+            pub fn characteristic_id(mut self, characteristic_id: impl Into<String>) -> Self {
+                self.characteristic_id = Some(characteristic_id.into());
+                self
+            }
+            pub fn descriptor_uuid(mut self, descriptor_uuid: impl Into<String>) -> Self {
+                self.descriptor_uuid = Some(descriptor_uuid.into());
+                self
+            }
+            pub fn build(self) -> Result<AddDescriptorParams, String> {
+                Ok(AddDescriptorParams {
+                    characteristic_id: self.characteristic_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(characteristic_id)
+                        )
+                    })?,
+                    descriptor_uuid: self.descriptor_uuid.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(descriptor_uuid))
+                    })?,
+                })
+            }
+        }
+        impl AddDescriptorParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.addDescriptor";
+        }
+        impl chromiumoxide_types::Method for AddDescriptorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddDescriptorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Adds a descriptor with |descriptorUuid| to the characteristic respresented\nby |characteristicId|.\n[addDescriptor](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-addDescriptor)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddDescriptorReturns {
+            #[doc = "An identifier that uniquely represents this descriptor."]
+            #[serde(rename = "descriptorId")]
+            pub descriptor_id: String,
+        }
+        impl AddDescriptorReturns {
+            pub fn new(descriptor_id: impl Into<String>) -> Self {
+                Self {
+                    descriptor_id: descriptor_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for AddDescriptorReturns {
+            fn from(url: T) -> Self {
+                AddDescriptorReturns::new(url)
+            }
+        }
+        impl AddDescriptorReturns {
+            pub fn builder() -> AddDescriptorReturnsBuilder {
+                AddDescriptorReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddDescriptorReturnsBuilder {
+            descriptor_id: Option<String>,
+        }
+        impl AddDescriptorReturnsBuilder {
+            pub fn descriptor_id(mut self, descriptor_id: impl Into<String>) -> Self {
+                self.descriptor_id = Some(descriptor_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AddDescriptorReturns, String> {
+                Ok(AddDescriptorReturns {
+                    descriptor_id: self.descriptor_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(descriptor_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for AddDescriptorParams {
+            type Response = AddDescriptorReturns;
+        }
+        #[doc = "Removes the descriptor with |descriptorId| from the simulated central.\n[removeDescriptor](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-removeDescriptor)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveDescriptorParams {
+            #[serde(rename = "descriptorId")]
+            pub descriptor_id: String,
+        }
+        impl RemoveDescriptorParams {
+            pub fn new(descriptor_id: impl Into<String>) -> Self {
+                Self {
+                    descriptor_id: descriptor_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for RemoveDescriptorParams {
+            fn from(url: T) -> Self {
+                RemoveDescriptorParams::new(url)
+            }
+        }
+        impl RemoveDescriptorParams {
+            pub fn builder() -> RemoveDescriptorParamsBuilder {
+                RemoveDescriptorParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveDescriptorParamsBuilder {
+            descriptor_id: Option<String>,
+        }
+        impl RemoveDescriptorParamsBuilder {
+            pub fn descriptor_id(mut self, descriptor_id: impl Into<String>) -> Self {
+                self.descriptor_id = Some(descriptor_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveDescriptorParams, String> {
+                Ok(RemoveDescriptorParams {
+                    descriptor_id: self.descriptor_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(descriptor_id))
+                    })?,
+                })
+            }
+        }
+        impl RemoveDescriptorParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.removeDescriptor";
+        }
+        impl chromiumoxide_types::Method for RemoveDescriptorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveDescriptorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes the descriptor with |descriptorId| from the simulated central.\n[removeDescriptor](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-removeDescriptor)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveDescriptorReturns {}
+        impl chromiumoxide_types::Command for RemoveDescriptorParams {
+            type Response = RemoveDescriptorReturns;
+        }
+        #[doc = "Simulates a GATT disconnection from the peripheral with |address|.\n[simulateGATTDisconnection](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulateGATTDisconnection)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SimulateGattDisconnectionParams {
+            #[serde(rename = "address")]
+            pub address: String,
+        }
+        impl SimulateGattDisconnectionParams {
+            pub fn new(address: impl Into<String>) -> Self {
+                Self {
+                    address: address.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for SimulateGattDisconnectionParams {
+            fn from(url: T) -> Self {
+                SimulateGattDisconnectionParams::new(url)
+            }
+        }
+        impl SimulateGattDisconnectionParams {
+            pub fn builder() -> SimulateGattDisconnectionParamsBuilder {
+                SimulateGattDisconnectionParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SimulateGattDisconnectionParamsBuilder {
+            address: Option<String>,
+        }
+        impl SimulateGattDisconnectionParamsBuilder {
+            pub fn address(mut self, address: impl Into<String>) -> Self {
+                self.address = Some(address.into());
+                self
+            }
+            pub fn build(self) -> Result<SimulateGattDisconnectionParams, String> {
+                Ok(SimulateGattDisconnectionParams {
+                    address: self.address.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(address))
+                    })?,
+                })
+            }
+        }
+        impl SimulateGattDisconnectionParams {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.simulateGATTDisconnection";
+        }
+        impl chromiumoxide_types::Method for SimulateGattDisconnectionParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SimulateGattDisconnectionParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Simulates a GATT disconnection from the peripheral with |address|.\n[simulateGATTDisconnection](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#method-simulateGATTDisconnection)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SimulateGattDisconnectionReturns {}
+        impl chromiumoxide_types::Command for SimulateGattDisconnectionParams {
+            type Response = SimulateGattDisconnectionReturns;
+        }
+        #[doc = "Event for when a GATT operation of |type| to the peripheral with |address|\nhappened.\n[gattOperationReceived](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#event-gattOperationReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventGattOperationReceived {
+            #[serde(rename = "address")]
+            pub address: String,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: GattOperationType,
+        }
+        impl EventGattOperationReceived {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.gattOperationReceived";
+        }
+        impl chromiumoxide_types::Method for EventGattOperationReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventGattOperationReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Event for when a characteristic operation of |type| to the characteristic\nrespresented by |characteristicId| happened. |data| and |writeType| is\nexpected to exist when |type| is write.\n[characteristicOperationReceived](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#event-characteristicOperationReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventCharacteristicOperationReceived {
+            #[serde(rename = "characteristicId")]
+            pub characteristic_id: String,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: CharacteristicOperationType,
+            #[serde(rename = "data")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub data: Option<chromiumoxide_types::Binary>,
+            #[serde(rename = "writeType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub write_type: Option<CharacteristicWriteType>,
+        }
+        impl EventCharacteristicOperationReceived {
+            pub const IDENTIFIER: &'static str =
+                "BluetoothEmulation.characteristicOperationReceived";
+        }
+        impl chromiumoxide_types::Method for EventCharacteristicOperationReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventCharacteristicOperationReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Event for when a descriptor operation of |type| to the descriptor\nrespresented by |descriptorId| happened. |data| is expected to exist when\n|type| is write.\n[descriptorOperationReceived](https://chromedevtools.github.io/devtools-protocol/tot/BluetoothEmulation/#event-descriptorOperationReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDescriptorOperationReceived {
+            #[serde(rename = "descriptorId")]
+            pub descriptor_id: String,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DescriptorOperationType,
+            #[serde(rename = "data")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub data: Option<chromiumoxide_types::Binary>,
+        }
+        impl EventDescriptorOperationReceived {
+            pub const IDENTIFIER: &'static str = "BluetoothEmulation.descriptorOperationReceived";
+        }
+        impl chromiumoxide_types::Method for EventDescriptorOperationReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDescriptorOperationReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "The Browser domain defines methods and events for browser managing."]
+    pub mod browser {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct BrowserContextId(String);
+        impl BrowserContextId {
+            pub fn new(val: impl Into<String>) -> Self {
+                BrowserContextId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for BrowserContextId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<BrowserContextId> for String {
+            fn from(el: BrowserContextId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for BrowserContextId {
+            fn from(expr: String) -> Self {
+                BrowserContextId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for BrowserContextId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl BrowserContextId {
+            pub const IDENTIFIER: &'static str = "Browser.BrowserContextID";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Copy, Hash)]
+        pub struct WindowId(i64);
+        impl WindowId {
+            pub fn new(val: impl Into<i64>) -> Self {
+                WindowId(val.into())
+            }
+            pub fn inner(&self) -> &i64 {
+                &self.0
+            }
+        }
+        impl WindowId {
+            pub const IDENTIFIER: &'static str = "Browser.WindowID";
+        }
+        #[doc = "The state of the browser window."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum WindowState {
+            #[serde(rename = "normal")]
+            Normal,
+            #[serde(rename = "minimized")]
+            Minimized,
+            #[serde(rename = "maximized")]
+            Maximized,
+            #[serde(rename = "fullscreen")]
+            Fullscreen,
+        }
+        impl AsRef<str> for WindowState {
+            fn as_ref(&self) -> &str {
+                match self {
+                    WindowState::Normal => "normal",
+                    WindowState::Minimized => "minimized",
+                    WindowState::Maximized => "maximized",
+                    WindowState::Fullscreen => "fullscreen",
+                }
+            }
+        }
+        impl ::std::str::FromStr for WindowState {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "normal" | "Normal" => Ok(WindowState::Normal),
+                    "minimized" | "Minimized" => Ok(WindowState::Minimized),
+                    "maximized" | "Maximized" => Ok(WindowState::Maximized),
+                    "fullscreen" | "Fullscreen" => Ok(WindowState::Fullscreen),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Browser window bounds information\n[Bounds](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#type-Bounds)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct Bounds {
+            #[doc = "The offset from the left edge of the screen to the window in pixels."]
+            #[serde(rename = "left")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub left: Option<i64>,
+            #[doc = "The offset from the top edge of the screen to the window in pixels."]
+            #[serde(rename = "top")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub top: Option<i64>,
+            #[doc = "The window width in pixels."]
+            #[serde(rename = "width")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub width: Option<i64>,
+            #[doc = "The window height in pixels."]
+            #[serde(rename = "height")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub height: Option<i64>,
+            #[doc = "The window state. Default to normal."]
+            #[serde(rename = "windowState")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub window_state: Option<WindowState>,
+        }
+        impl Bounds {
+            pub fn builder() -> BoundsBuilder {
+                BoundsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BoundsBuilder {
+            left: Option<i64>,
+            top: Option<i64>,
+            width: Option<i64>,
+            height: Option<i64>,
+            window_state: Option<WindowState>,
+        }
+        impl BoundsBuilder {
+            pub fn left(mut self, left: impl Into<i64>) -> Self {
+                self.left = Some(left.into());
+                self
+            }
+            pub fn top(mut self, top: impl Into<i64>) -> Self {
+                self.top = Some(top.into());
+                self
+            }
+            pub fn width(mut self, width: impl Into<i64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<i64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn window_state(mut self, window_state: impl Into<WindowState>) -> Self {
+                self.window_state = Some(window_state.into());
+                self
+            }
+            pub fn build(self) -> Bounds {
+                Bounds {
+                    left: self.left,
+                    top: self.top,
+                    width: self.width,
+                    height: self.height,
+                    window_state: self.window_state,
+                }
+            }
+        }
+        impl Bounds {
+            pub const IDENTIFIER: &'static str = "Browser.Bounds";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PermissionType {
+            #[serde(rename = "ar")]
+            Ar,
+            #[serde(rename = "audioCapture")]
+            AudioCapture,
+            #[serde(rename = "automaticFullscreen")]
+            AutomaticFullscreen,
+            #[serde(rename = "backgroundFetch")]
+            BackgroundFetch,
+            #[serde(rename = "backgroundSync")]
+            BackgroundSync,
+            #[serde(rename = "cameraPanTiltZoom")]
+            CameraPanTiltZoom,
+            #[serde(rename = "capturedSurfaceControl")]
+            CapturedSurfaceControl,
+            #[serde(rename = "clipboardReadWrite")]
+            ClipboardReadWrite,
+            #[serde(rename = "clipboardSanitizedWrite")]
+            ClipboardSanitizedWrite,
+            #[serde(rename = "displayCapture")]
+            DisplayCapture,
+            #[serde(rename = "durableStorage")]
+            DurableStorage,
+            #[serde(rename = "geolocation")]
+            Geolocation,
+            #[serde(rename = "handTracking")]
+            HandTracking,
+            #[serde(rename = "idleDetection")]
+            IdleDetection,
+            #[serde(rename = "keyboardLock")]
+            KeyboardLock,
+            #[serde(rename = "localFonts")]
+            LocalFonts,
+            #[serde(rename = "localNetwork")]
+            LocalNetwork,
+            #[serde(rename = "localNetworkAccess")]
+            LocalNetworkAccess,
+            #[serde(rename = "loopbackNetwork")]
+            LoopbackNetwork,
+            #[serde(rename = "midi")]
+            Midi,
+            #[serde(rename = "midiSysex")]
+            MidiSysex,
+            #[serde(rename = "nfc")]
+            Nfc,
+            #[serde(rename = "notifications")]
+            Notifications,
+            #[serde(rename = "paymentHandler")]
+            PaymentHandler,
+            #[serde(rename = "periodicBackgroundSync")]
+            PeriodicBackgroundSync,
+            #[serde(rename = "pointerLock")]
+            PointerLock,
+            #[serde(rename = "protectedMediaIdentifier")]
+            ProtectedMediaIdentifier,
+            #[serde(rename = "sensors")]
+            Sensors,
+            #[serde(rename = "smartCard")]
+            SmartCard,
+            #[serde(rename = "speakerSelection")]
+            SpeakerSelection,
+            #[serde(rename = "storageAccess")]
+            StorageAccess,
+            #[serde(rename = "topLevelStorageAccess")]
+            TopLevelStorageAccess,
+            #[serde(rename = "videoCapture")]
+            VideoCapture,
+            #[serde(rename = "vr")]
+            Vr,
+            #[serde(rename = "wakeLockScreen")]
+            WakeLockScreen,
+            #[serde(rename = "wakeLockSystem")]
+            WakeLockSystem,
+            #[serde(rename = "webAppInstallation")]
+            WebAppInstallation,
+            #[serde(rename = "webPrinting")]
+            WebPrinting,
+            #[serde(rename = "windowManagement")]
+            WindowManagement,
+        }
+        impl AsRef<str> for PermissionType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PermissionType::Ar => "ar",
+                    PermissionType::AudioCapture => "audioCapture",
+                    PermissionType::AutomaticFullscreen => "automaticFullscreen",
+                    PermissionType::BackgroundFetch => "backgroundFetch",
+                    PermissionType::BackgroundSync => "backgroundSync",
+                    PermissionType::CameraPanTiltZoom => "cameraPanTiltZoom",
+                    PermissionType::CapturedSurfaceControl => "capturedSurfaceControl",
+                    PermissionType::ClipboardReadWrite => "clipboardReadWrite",
+                    PermissionType::ClipboardSanitizedWrite => "clipboardSanitizedWrite",
+                    PermissionType::DisplayCapture => "displayCapture",
+                    PermissionType::DurableStorage => "durableStorage",
+                    PermissionType::Geolocation => "geolocation",
+                    PermissionType::HandTracking => "handTracking",
+                    PermissionType::IdleDetection => "idleDetection",
+                    PermissionType::KeyboardLock => "keyboardLock",
+                    PermissionType::LocalFonts => "localFonts",
+                    PermissionType::LocalNetwork => "localNetwork",
+                    PermissionType::LocalNetworkAccess => "localNetworkAccess",
+                    PermissionType::LoopbackNetwork => "loopbackNetwork",
+                    PermissionType::Midi => "midi",
+                    PermissionType::MidiSysex => "midiSysex",
+                    PermissionType::Nfc => "nfc",
+                    PermissionType::Notifications => "notifications",
+                    PermissionType::PaymentHandler => "paymentHandler",
+                    PermissionType::PeriodicBackgroundSync => "periodicBackgroundSync",
+                    PermissionType::PointerLock => "pointerLock",
+                    PermissionType::ProtectedMediaIdentifier => "protectedMediaIdentifier",
+                    PermissionType::Sensors => "sensors",
+                    PermissionType::SmartCard => "smartCard",
+                    PermissionType::SpeakerSelection => "speakerSelection",
+                    PermissionType::StorageAccess => "storageAccess",
+                    PermissionType::TopLevelStorageAccess => "topLevelStorageAccess",
+                    PermissionType::VideoCapture => "videoCapture",
+                    PermissionType::Vr => "vr",
+                    PermissionType::WakeLockScreen => "wakeLockScreen",
+                    PermissionType::WakeLockSystem => "wakeLockSystem",
+                    PermissionType::WebAppInstallation => "webAppInstallation",
+                    PermissionType::WebPrinting => "webPrinting",
+                    PermissionType::WindowManagement => "windowManagement",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PermissionType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "ar" | "Ar" => Ok(PermissionType::Ar),
+                    "audioCapture" | "AudioCapture" | "audiocapture" => {
+                        Ok(PermissionType::AudioCapture)
+                    }
+                    "automaticFullscreen" | "AutomaticFullscreen" | "automaticfullscreen" => {
+                        Ok(PermissionType::AutomaticFullscreen)
+                    }
+                    "backgroundFetch" | "BackgroundFetch" | "backgroundfetch" => {
+                        Ok(PermissionType::BackgroundFetch)
+                    }
+                    "backgroundSync" | "BackgroundSync" | "backgroundsync" => {
+                        Ok(PermissionType::BackgroundSync)
+                    }
+                    "cameraPanTiltZoom" | "CameraPanTiltZoom" | "camerapantiltzoom" => {
+                        Ok(PermissionType::CameraPanTiltZoom)
+                    }
+                    "capturedSurfaceControl"
+                    | "CapturedSurfaceControl"
+                    | "capturedsurfacecontrol" => Ok(PermissionType::CapturedSurfaceControl),
+                    "clipboardReadWrite" | "ClipboardReadWrite" | "clipboardreadwrite" => {
+                        Ok(PermissionType::ClipboardReadWrite)
+                    }
+                    "clipboardSanitizedWrite"
+                    | "ClipboardSanitizedWrite"
+                    | "clipboardsanitizedwrite" => Ok(PermissionType::ClipboardSanitizedWrite),
+                    "displayCapture" | "DisplayCapture" | "displaycapture" => {
+                        Ok(PermissionType::DisplayCapture)
+                    }
+                    "durableStorage" | "DurableStorage" | "durablestorage" => {
+                        Ok(PermissionType::DurableStorage)
+                    }
+                    "geolocation" | "Geolocation" => Ok(PermissionType::Geolocation),
+                    "handTracking" | "HandTracking" | "handtracking" => {
+                        Ok(PermissionType::HandTracking)
+                    }
+                    "idleDetection" | "IdleDetection" | "idledetection" => {
+                        Ok(PermissionType::IdleDetection)
+                    }
+                    "keyboardLock" | "KeyboardLock" | "keyboardlock" => {
+                        Ok(PermissionType::KeyboardLock)
+                    }
+                    "localFonts" | "LocalFonts" | "localfonts" => Ok(PermissionType::LocalFonts),
+                    "localNetwork" | "LocalNetwork" | "localnetwork" => {
+                        Ok(PermissionType::LocalNetwork)
+                    }
+                    "localNetworkAccess" | "LocalNetworkAccess" | "localnetworkaccess" => {
+                        Ok(PermissionType::LocalNetworkAccess)
+                    }
+                    "loopbackNetwork" | "LoopbackNetwork" | "loopbacknetwork" => {
+                        Ok(PermissionType::LoopbackNetwork)
+                    }
+                    "midi" | "Midi" => Ok(PermissionType::Midi),
+                    "midiSysex" | "MidiSysex" | "midisysex" => Ok(PermissionType::MidiSysex),
+                    "nfc" | "Nfc" => Ok(PermissionType::Nfc),
+                    "notifications" | "Notifications" => Ok(PermissionType::Notifications),
+                    "paymentHandler" | "PaymentHandler" | "paymenthandler" => {
+                        Ok(PermissionType::PaymentHandler)
+                    }
+                    "periodicBackgroundSync"
+                    | "PeriodicBackgroundSync"
+                    | "periodicbackgroundsync" => Ok(PermissionType::PeriodicBackgroundSync),
+                    "pointerLock" | "PointerLock" | "pointerlock" => {
+                        Ok(PermissionType::PointerLock)
+                    }
+                    "protectedMediaIdentifier"
+                    | "ProtectedMediaIdentifier"
+                    | "protectedmediaidentifier" => Ok(PermissionType::ProtectedMediaIdentifier),
+                    "sensors" | "Sensors" => Ok(PermissionType::Sensors),
+                    "smartCard" | "SmartCard" | "smartcard" => Ok(PermissionType::SmartCard),
+                    "speakerSelection" | "SpeakerSelection" | "speakerselection" => {
+                        Ok(PermissionType::SpeakerSelection)
+                    }
+                    "storageAccess" | "StorageAccess" | "storageaccess" => {
+                        Ok(PermissionType::StorageAccess)
+                    }
+                    "topLevelStorageAccess" | "TopLevelStorageAccess" | "toplevelstorageaccess" => {
+                        Ok(PermissionType::TopLevelStorageAccess)
+                    }
+                    "videoCapture" | "VideoCapture" | "videocapture" => {
+                        Ok(PermissionType::VideoCapture)
+                    }
+                    "vr" | "Vr" => Ok(PermissionType::Vr),
+                    "wakeLockScreen" | "WakeLockScreen" | "wakelockscreen" => {
+                        Ok(PermissionType::WakeLockScreen)
+                    }
+                    "wakeLockSystem" | "WakeLockSystem" | "wakelocksystem" => {
+                        Ok(PermissionType::WakeLockSystem)
+                    }
+                    "webAppInstallation" | "WebAppInstallation" | "webappinstallation" => {
+                        Ok(PermissionType::WebAppInstallation)
+                    }
+                    "webPrinting" | "WebPrinting" | "webprinting" => {
+                        Ok(PermissionType::WebPrinting)
+                    }
+                    "windowManagement" | "WindowManagement" | "windowmanagement" => {
+                        Ok(PermissionType::WindowManagement)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PermissionSetting {
+            #[serde(rename = "granted")]
+            Granted,
+            #[serde(rename = "denied")]
+            Denied,
+            #[serde(rename = "prompt")]
+            Prompt,
+        }
+        impl AsRef<str> for PermissionSetting {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PermissionSetting::Granted => "granted",
+                    PermissionSetting::Denied => "denied",
+                    PermissionSetting::Prompt => "prompt",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PermissionSetting {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "granted" | "Granted" => Ok(PermissionSetting::Granted),
+                    "denied" | "Denied" => Ok(PermissionSetting::Denied),
+                    "prompt" | "Prompt" => Ok(PermissionSetting::Prompt),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Definition of PermissionDescriptor defined in the Permissions API:\nhttps://w3c.github.io/permissions/#dom-permissiondescriptor.\n[PermissionDescriptor](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#type-PermissionDescriptor)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PermissionDescriptor {
+            #[doc = "Name of permission.\nSee https://cs.chromium.org/chromium/src/third_party/blink/renderer/modules/permissions/permission_descriptor.idl for valid permission names."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "For \"midi\" permission, may also specify sysex control."]
+            #[serde(rename = "sysex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub sysex: Option<bool>,
+            #[doc = "For \"push\" permission, may specify userVisibleOnly.\nNote that userVisibleOnly = true is the only currently supported type."]
+            #[serde(rename = "userVisibleOnly")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub user_visible_only: Option<bool>,
+            #[doc = "For \"clipboard\" permission, may specify allowWithoutSanitization."]
+            #[serde(rename = "allowWithoutSanitization")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub allow_without_sanitization: Option<bool>,
+            #[doc = "For \"fullscreen\" permission, must specify allowWithoutGesture:true."]
+            #[serde(rename = "allowWithoutGesture")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub allow_without_gesture: Option<bool>,
+            #[doc = "For \"camera\" permission, may specify panTiltZoom."]
+            #[serde(rename = "panTiltZoom")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pan_tilt_zoom: Option<bool>,
+        }
+        impl PermissionDescriptor {
+            pub fn new(name: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    sysex: None,
+                    user_visible_only: None,
+                    allow_without_sanitization: None,
+                    allow_without_gesture: None,
+                    pan_tilt_zoom: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for PermissionDescriptor {
+            fn from(url: T) -> Self {
+                PermissionDescriptor::new(url)
+            }
+        }
+        impl PermissionDescriptor {
+            pub fn builder() -> PermissionDescriptorBuilder {
+                PermissionDescriptorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PermissionDescriptorBuilder {
+            name: Option<String>,
+            sysex: Option<bool>,
+            user_visible_only: Option<bool>,
+            allow_without_sanitization: Option<bool>,
+            allow_without_gesture: Option<bool>,
+            pan_tilt_zoom: Option<bool>,
+        }
+        impl PermissionDescriptorBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn sysex(mut self, sysex: impl Into<bool>) -> Self {
+                self.sysex = Some(sysex.into());
+                self
+            }
+            pub fn user_visible_only(mut self, user_visible_only: impl Into<bool>) -> Self {
+                self.user_visible_only = Some(user_visible_only.into());
+                self
+            }
+            pub fn allow_without_sanitization(
+                mut self,
+                allow_without_sanitization: impl Into<bool>,
+            ) -> Self {
+                self.allow_without_sanitization = Some(allow_without_sanitization.into());
+                self
+            }
+            pub fn allow_without_gesture(mut self, allow_without_gesture: impl Into<bool>) -> Self {
+                self.allow_without_gesture = Some(allow_without_gesture.into());
+                self
+            }
+            pub fn pan_tilt_zoom(mut self, pan_tilt_zoom: impl Into<bool>) -> Self {
+                self.pan_tilt_zoom = Some(pan_tilt_zoom.into());
+                self
+            }
+            pub fn build(self) -> Result<PermissionDescriptor, String> {
+                Ok(PermissionDescriptor {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    sysex: self.sysex,
+                    user_visible_only: self.user_visible_only,
+                    allow_without_sanitization: self.allow_without_sanitization,
+                    allow_without_gesture: self.allow_without_gesture,
+                    pan_tilt_zoom: self.pan_tilt_zoom,
+                })
+            }
+        }
+        impl PermissionDescriptor {
+            pub const IDENTIFIER: &'static str = "Browser.PermissionDescriptor";
+        }
+        #[doc = "Browser command ids used by executeBrowserCommand."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum BrowserCommandId {
+            #[serde(rename = "openTabSearch")]
+            OpenTabSearch,
+            #[serde(rename = "closeTabSearch")]
+            CloseTabSearch,
+            #[serde(rename = "openGlic")]
+            OpenGlic,
+        }
+        impl AsRef<str> for BrowserCommandId {
+            fn as_ref(&self) -> &str {
+                match self {
+                    BrowserCommandId::OpenTabSearch => "openTabSearch",
+                    BrowserCommandId::CloseTabSearch => "closeTabSearch",
+                    BrowserCommandId::OpenGlic => "openGlic",
+                }
+            }
+        }
+        impl ::std::str::FromStr for BrowserCommandId {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "openTabSearch" | "OpenTabSearch" | "opentabsearch" => {
+                        Ok(BrowserCommandId::OpenTabSearch)
+                    }
+                    "closeTabSearch" | "CloseTabSearch" | "closetabsearch" => {
+                        Ok(BrowserCommandId::CloseTabSearch)
+                    }
+                    "openGlic" | "OpenGlic" | "openglic" => Ok(BrowserCommandId::OpenGlic),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Chrome histogram bucket.\n[Bucket](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#type-Bucket)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Bucket {
+            #[doc = "Minimum value (inclusive)."]
+            #[serde(rename = "low")]
+            pub low: i64,
+            #[doc = "Maximum value (exclusive)."]
+            #[serde(rename = "high")]
+            pub high: i64,
+            #[doc = "Number of samples."]
+            #[serde(rename = "count")]
+            pub count: i64,
+        }
+        impl Bucket {
+            pub fn new(low: impl Into<i64>, high: impl Into<i64>, count: impl Into<i64>) -> Self {
+                Self {
+                    low: low.into(),
+                    high: high.into(),
+                    count: count.into(),
+                }
+            }
+        }
+        impl Bucket {
+            pub fn builder() -> BucketBuilder {
+                BucketBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BucketBuilder {
+            low: Option<i64>,
+            high: Option<i64>,
+            count: Option<i64>,
+        }
+        impl BucketBuilder {
+            pub fn low(mut self, low: impl Into<i64>) -> Self {
+                self.low = Some(low.into());
+                self
+            }
+            pub fn high(mut self, high: impl Into<i64>) -> Self {
+                self.high = Some(high.into());
+                self
+            }
+            pub fn count(mut self, count: impl Into<i64>) -> Self {
+                self.count = Some(count.into());
+                self
+            }
+            pub fn build(self) -> Result<Bucket, String> {
+                Ok(Bucket {
+                    low: self
+                        .low
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(low)))?,
+                    high: self.high.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(high))
+                    })?,
+                    count: self.count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(count))
+                    })?,
+                })
+            }
+        }
+        impl Bucket {
+            pub const IDENTIFIER: &'static str = "Browser.Bucket";
+        }
+        #[doc = "Chrome histogram.\n[Histogram](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#type-Histogram)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Histogram {
+            #[doc = "Name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Sum of sample values."]
+            #[serde(rename = "sum")]
+            pub sum: i64,
+            #[doc = "Total number of samples."]
+            #[serde(rename = "count")]
+            pub count: i64,
+            #[doc = "Buckets."]
+            #[serde(rename = "buckets")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub buckets: Vec<Bucket>,
+        }
+        impl Histogram {
+            pub fn new(
+                name: impl Into<String>,
+                sum: impl Into<i64>,
+                count: impl Into<i64>,
+                buckets: Vec<Bucket>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    sum: sum.into(),
+                    count: count.into(),
+                    buckets,
+                }
+            }
+        }
+        impl Histogram {
+            pub fn builder() -> HistogramBuilder {
+                HistogramBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HistogramBuilder {
+            name: Option<String>,
+            sum: Option<i64>,
+            count: Option<i64>,
+            buckets: Option<Vec<Bucket>>,
+        }
+        impl HistogramBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn sum(mut self, sum: impl Into<i64>) -> Self {
+                self.sum = Some(sum.into());
+                self
+            }
+            pub fn count(mut self, count: impl Into<i64>) -> Self {
+                self.count = Some(count.into());
+                self
+            }
+            pub fn bucket(mut self, bucket: impl Into<Bucket>) -> Self {
+                let v = self.buckets.get_or_insert(Vec::new());
+                v.push(bucket.into());
+                self
+            }
+            pub fn buckets<I, S>(mut self, buckets: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Bucket>,
+            {
+                let v = self.buckets.get_or_insert(Vec::new());
+                for val in buckets {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<Histogram, String> {
+                Ok(Histogram {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    sum: self
+                        .sum
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(sum)))?,
+                    count: self.count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(count))
+                    })?,
+                    buckets: self.buckets.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(buckets))
+                    })?,
+                })
+            }
+        }
+        impl Histogram {
+            pub const IDENTIFIER: &'static str = "Browser.Histogram";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PrivacySandboxApi {
+            #[serde(rename = "BiddingAndAuctionServices")]
+            BiddingAndAuctionServices,
+            #[serde(rename = "TrustedKeyValue")]
+            TrustedKeyValue,
+        }
+        impl AsRef<str> for PrivacySandboxApi {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PrivacySandboxApi::BiddingAndAuctionServices => "BiddingAndAuctionServices",
+                    PrivacySandboxApi::TrustedKeyValue => "TrustedKeyValue",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PrivacySandboxApi {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "BiddingAndAuctionServices" | "biddingandauctionservices" => {
+                        Ok(PrivacySandboxApi::BiddingAndAuctionServices)
+                    }
+                    "TrustedKeyValue" | "trustedkeyvalue" => Ok(PrivacySandboxApi::TrustedKeyValue),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Set permission settings for given embedding and embedded origins.\n[setPermission](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-setPermission)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPermissionParams {
+            #[doc = "Descriptor of permission to override."]
+            #[serde(rename = "permission")]
+            pub permission: PermissionDescriptor,
+            #[doc = "Setting of the permission."]
+            #[serde(rename = "setting")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub setting: PermissionSetting,
+            #[doc = "Embedding origin the permission applies to, all origins if not specified."]
+            #[serde(rename = "origin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub origin: Option<String>,
+            #[doc = "Embedded origin the permission applies to. It is ignored unless the embedding origin is\npresent and valid. If the embedding origin is provided but the embedded origin isn't, the\nembedding origin is used as the embedded origin."]
+            #[serde(rename = "embeddedOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub embedded_origin: Option<String>,
+            #[doc = "Context to override. When omitted, default browser context is used."]
+            #[serde(rename = "browserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub browser_context_id: Option<BrowserContextId>,
+        }
+        impl SetPermissionParams {
+            pub fn new(
+                permission: impl Into<PermissionDescriptor>,
+                setting: impl Into<PermissionSetting>,
+            ) -> Self {
+                Self {
+                    permission: permission.into(),
+                    setting: setting.into(),
+                    origin: None,
+                    embedded_origin: None,
+                    browser_context_id: None,
+                }
+            }
+        }
+        impl SetPermissionParams {
+            pub fn builder() -> SetPermissionParamsBuilder {
+                SetPermissionParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPermissionParamsBuilder {
+            permission: Option<PermissionDescriptor>,
+            setting: Option<PermissionSetting>,
+            origin: Option<String>,
+            embedded_origin: Option<String>,
+            browser_context_id: Option<BrowserContextId>,
+        }
+        impl SetPermissionParamsBuilder {
+            pub fn permission(mut self, permission: impl Into<PermissionDescriptor>) -> Self {
+                self.permission = Some(permission.into());
+                self
+            }
+            pub fn setting(mut self, setting: impl Into<PermissionSetting>) -> Self {
+                self.setting = Some(setting.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn embedded_origin(mut self, embedded_origin: impl Into<String>) -> Self {
+                self.embedded_origin = Some(embedded_origin.into());
+                self
+            }
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPermissionParams, String> {
+                Ok(SetPermissionParams {
+                    permission: self.permission.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(permission))
+                    })?,
+                    setting: self.setting.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(setting))
+                    })?,
+                    origin: self.origin,
+                    embedded_origin: self.embedded_origin,
+                    browser_context_id: self.browser_context_id,
+                })
+            }
+        }
+        impl SetPermissionParams {
+            pub const IDENTIFIER: &'static str = "Browser.setPermission";
+        }
+        impl chromiumoxide_types::Method for SetPermissionParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPermissionParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set permission settings for given embedding and embedded origins.\n[setPermission](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-setPermission)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPermissionReturns {}
+        impl chromiumoxide_types::Command for SetPermissionParams {
+            type Response = SetPermissionReturns;
+        }
+        #[doc = "Reset all permission management for all origins.\n[resetPermissions](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-resetPermissions)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResetPermissionsParams {
+            #[doc = "BrowserContext to reset permissions. When omitted, default browser context is used."]
+            #[serde(rename = "browserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub browser_context_id: Option<BrowserContextId>,
+        }
+        impl ResetPermissionsParams {
+            pub fn builder() -> ResetPermissionsParamsBuilder {
+                ResetPermissionsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResetPermissionsParamsBuilder {
+            browser_context_id: Option<BrowserContextId>,
+        }
+        impl ResetPermissionsParamsBuilder {
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn build(self) -> ResetPermissionsParams {
+                ResetPermissionsParams {
+                    browser_context_id: self.browser_context_id,
+                }
+            }
+        }
+        impl ResetPermissionsParams {
+            pub const IDENTIFIER: &'static str = "Browser.resetPermissions";
+        }
+        impl chromiumoxide_types::Method for ResetPermissionsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ResetPermissionsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Reset all permission management for all origins.\n[resetPermissions](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-resetPermissions)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResetPermissionsReturns {}
+        impl chromiumoxide_types::Command for ResetPermissionsParams {
+            type Response = ResetPermissionsReturns;
+        }
+        #[doc = "Set the behavior when downloading a file.\n[setDownloadBehavior](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-setDownloadBehavior)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDownloadBehaviorParams {
+            #[doc = "Whether to allow all or deny all download requests, or use default Chrome behavior if\navailable (otherwise deny). |allowAndName| allows download and names files according to\ntheir download guids."]
+            #[serde(rename = "behavior")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub behavior: SetDownloadBehaviorBehavior,
+            #[doc = "BrowserContext to set download behavior. When omitted, default browser context is used."]
+            #[serde(rename = "browserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub browser_context_id: Option<BrowserContextId>,
+            #[doc = "The default path to save downloaded files to. This is required if behavior is set to 'allow'\nor 'allowAndName'."]
+            #[serde(rename = "downloadPath")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub download_path: Option<String>,
+            #[doc = "Whether to emit download events (defaults to false)."]
+            #[serde(rename = "eventsEnabled")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub events_enabled: Option<bool>,
+        }
+        #[doc = "Whether to allow all or deny all download requests, or use default Chrome behavior if\navailable (otherwise deny). |allowAndName| allows download and names files according to\ntheir download guids."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SetDownloadBehaviorBehavior {
+            #[serde(rename = "deny")]
+            Deny,
+            #[serde(rename = "allow")]
+            Allow,
+            #[serde(rename = "allowAndName")]
+            AllowAndName,
+            #[serde(rename = "default")]
+            Default,
+        }
+        impl AsRef<str> for SetDownloadBehaviorBehavior {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SetDownloadBehaviorBehavior::Deny => "deny",
+                    SetDownloadBehaviorBehavior::Allow => "allow",
+                    SetDownloadBehaviorBehavior::AllowAndName => "allowAndName",
+                    SetDownloadBehaviorBehavior::Default => "default",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SetDownloadBehaviorBehavior {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "deny" | "Deny" => Ok(SetDownloadBehaviorBehavior::Deny),
+                    "allow" | "Allow" => Ok(SetDownloadBehaviorBehavior::Allow),
+                    "allowAndName" | "AllowAndName" | "allowandname" => {
+                        Ok(SetDownloadBehaviorBehavior::AllowAndName)
+                    }
+                    "default" | "Default" => Ok(SetDownloadBehaviorBehavior::Default),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl SetDownloadBehaviorParams {
+            pub fn new(behavior: impl Into<SetDownloadBehaviorBehavior>) -> Self {
+                Self {
+                    behavior: behavior.into(),
+                    browser_context_id: None,
+                    download_path: None,
+                    events_enabled: None,
+                }
+            }
+        }
+        impl SetDownloadBehaviorParams {
+            pub fn builder() -> SetDownloadBehaviorParamsBuilder {
+                SetDownloadBehaviorParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDownloadBehaviorParamsBuilder {
+            behavior: Option<SetDownloadBehaviorBehavior>,
+            browser_context_id: Option<BrowserContextId>,
+            download_path: Option<String>,
+            events_enabled: Option<bool>,
+        }
+        impl SetDownloadBehaviorParamsBuilder {
+            pub fn behavior(mut self, behavior: impl Into<SetDownloadBehaviorBehavior>) -> Self {
+                self.behavior = Some(behavior.into());
+                self
+            }
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn download_path(mut self, download_path: impl Into<String>) -> Self {
+                self.download_path = Some(download_path.into());
+                self
+            }
+            pub fn events_enabled(mut self, events_enabled: impl Into<bool>) -> Self {
+                self.events_enabled = Some(events_enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetDownloadBehaviorParams, String> {
+                Ok(SetDownloadBehaviorParams {
+                    behavior: self.behavior.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(behavior))
+                    })?,
+                    browser_context_id: self.browser_context_id,
+                    download_path: self.download_path,
+                    events_enabled: self.events_enabled,
+                })
+            }
+        }
+        impl SetDownloadBehaviorParams {
+            pub const IDENTIFIER: &'static str = "Browser.setDownloadBehavior";
+        }
+        impl chromiumoxide_types::Method for SetDownloadBehaviorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDownloadBehaviorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set the behavior when downloading a file.\n[setDownloadBehavior](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-setDownloadBehavior)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDownloadBehaviorReturns {}
+        impl chromiumoxide_types::Command for SetDownloadBehaviorParams {
+            type Response = SetDownloadBehaviorReturns;
+        }
+        #[doc = "Cancel a download if in progress\n[cancelDownload](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-cancelDownload)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CancelDownloadParams {
+            #[doc = "Global unique identifier of the download."]
+            #[serde(rename = "guid")]
+            pub guid: String,
+            #[doc = "BrowserContext to perform the action in. When omitted, default browser context is used."]
+            #[serde(rename = "browserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub browser_context_id: Option<BrowserContextId>,
+        }
+        impl CancelDownloadParams {
+            pub fn new(guid: impl Into<String>) -> Self {
+                Self {
+                    guid: guid.into(),
+                    browser_context_id: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for CancelDownloadParams {
+            fn from(url: T) -> Self {
+                CancelDownloadParams::new(url)
+            }
+        }
+        impl CancelDownloadParams {
+            pub fn builder() -> CancelDownloadParamsBuilder {
+                CancelDownloadParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CancelDownloadParamsBuilder {
+            guid: Option<String>,
+            browser_context_id: Option<BrowserContextId>,
+        }
+        impl CancelDownloadParamsBuilder {
+            pub fn guid(mut self, guid: impl Into<String>) -> Self {
+                self.guid = Some(guid.into());
+                self
+            }
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CancelDownloadParams, String> {
+                Ok(CancelDownloadParams {
+                    guid: self.guid.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(guid))
+                    })?,
+                    browser_context_id: self.browser_context_id,
+                })
+            }
+        }
+        impl CancelDownloadParams {
+            pub const IDENTIFIER: &'static str = "Browser.cancelDownload";
+        }
+        impl chromiumoxide_types::Method for CancelDownloadParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CancelDownloadParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Cancel a download if in progress\n[cancelDownload](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-cancelDownload)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CancelDownloadReturns {}
+        impl chromiumoxide_types::Command for CancelDownloadParams {
+            type Response = CancelDownloadReturns;
+        }
+        #[doc = "Close browser gracefully.\n[close](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-close)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CloseParams {}
+        impl CloseParams {
+            pub const IDENTIFIER: &'static str = "Browser.close";
+        }
+        impl chromiumoxide_types::Method for CloseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CloseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Close browser gracefully.\n[close](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-close)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CloseReturns {}
+        impl chromiumoxide_types::Command for CloseParams {
+            type Response = CloseReturns;
+        }
+        #[doc = "Crashes browser on the main thread.\n[crash](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-crash)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CrashParams {}
+        impl CrashParams {
+            pub const IDENTIFIER: &'static str = "Browser.crash";
+        }
+        impl chromiumoxide_types::Method for CrashParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CrashParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Crashes browser on the main thread.\n[crash](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-crash)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CrashReturns {}
+        impl chromiumoxide_types::Command for CrashParams {
+            type Response = CrashReturns;
+        }
+        #[doc = "Crashes GPU process.\n[crashGpuProcess](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-crashGpuProcess)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CrashGpuProcessParams {}
+        impl CrashGpuProcessParams {
+            pub const IDENTIFIER: &'static str = "Browser.crashGpuProcess";
+        }
+        impl chromiumoxide_types::Method for CrashGpuProcessParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CrashGpuProcessParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Crashes GPU process.\n[crashGpuProcess](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-crashGpuProcess)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CrashGpuProcessReturns {}
+        impl chromiumoxide_types::Command for CrashGpuProcessParams {
+            type Response = CrashGpuProcessReturns;
+        }
+        #[doc = "Returns version information.\n[getVersion](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getVersion)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetVersionParams {}
+        impl GetVersionParams {
+            pub const IDENTIFIER: &'static str = "Browser.getVersion";
+        }
+        impl chromiumoxide_types::Method for GetVersionParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetVersionParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns version information.\n[getVersion](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getVersion)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetVersionReturns {
+            #[doc = "Protocol version."]
+            #[serde(rename = "protocolVersion")]
+            pub protocol_version: String,
+            #[doc = "Product name."]
+            #[serde(rename = "product")]
+            pub product: String,
+            #[doc = "Product revision."]
+            #[serde(rename = "revision")]
+            pub revision: String,
+            #[doc = "User-Agent."]
+            #[serde(rename = "userAgent")]
+            pub user_agent: String,
+            #[doc = "V8 version."]
+            #[serde(rename = "jsVersion")]
+            pub js_version: String,
+        }
+        impl GetVersionReturns {
+            pub fn builder() -> GetVersionReturnsBuilder {
+                GetVersionReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetVersionReturnsBuilder {
+            protocol_version: Option<String>,
+            product: Option<String>,
+            revision: Option<String>,
+            user_agent: Option<String>,
+            js_version: Option<String>,
+        }
+        impl GetVersionReturnsBuilder {
+            pub fn protocol_version(mut self, protocol_version: impl Into<String>) -> Self {
+                self.protocol_version = Some(protocol_version.into());
+                self
+            }
+            pub fn product(mut self, product: impl Into<String>) -> Self {
+                self.product = Some(product.into());
+                self
+            }
+            pub fn revision(mut self, revision: impl Into<String>) -> Self {
+                self.revision = Some(revision.into());
+                self
+            }
+            pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
+                self.user_agent = Some(user_agent.into());
+                self
+            }
+            pub fn js_version(mut self, js_version: impl Into<String>) -> Self {
+                self.js_version = Some(js_version.into());
+                self
+            }
+            pub fn build(self) -> Result<GetVersionReturns, String> {
+                Ok(GetVersionReturns {
+                    protocol_version: self.protocol_version.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(protocol_version)
+                        )
+                    })?,
+                    product: self.product.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(product))
+                    })?,
+                    revision: self.revision.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(revision))
+                    })?,
+                    user_agent: self.user_agent.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(user_agent))
+                    })?,
+                    js_version: self.js_version.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(js_version))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetVersionParams {
+            type Response = GetVersionReturns;
+        }
+        #[doc = "Returns the command line switches for the browser process if, and only if\n--enable-automation is on the commandline.\n[getBrowserCommandLine](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getBrowserCommandLine)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetBrowserCommandLineParams {}
+        impl GetBrowserCommandLineParams {
+            pub const IDENTIFIER: &'static str = "Browser.getBrowserCommandLine";
+        }
+        impl chromiumoxide_types::Method for GetBrowserCommandLineParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetBrowserCommandLineParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the command line switches for the browser process if, and only if\n--enable-automation is on the commandline.\n[getBrowserCommandLine](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getBrowserCommandLine)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetBrowserCommandLineReturns {
+            #[doc = "Commandline parameters"]
+            #[serde(rename = "arguments")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub arguments: Vec<String>,
+        }
+        impl GetBrowserCommandLineReturns {
+            pub fn new(arguments: Vec<String>) -> Self {
+                Self { arguments }
+            }
+        }
+        impl GetBrowserCommandLineReturns {
+            pub fn builder() -> GetBrowserCommandLineReturnsBuilder {
+                GetBrowserCommandLineReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetBrowserCommandLineReturnsBuilder {
+            arguments: Option<Vec<String>>,
+        }
+        impl GetBrowserCommandLineReturnsBuilder {
+            pub fn argument(mut self, argument: impl Into<String>) -> Self {
+                let v = self.arguments.get_or_insert(Vec::new());
+                v.push(argument.into());
+                self
+            }
+            pub fn arguments<I, S>(mut self, arguments: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.arguments.get_or_insert(Vec::new());
+                for val in arguments {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetBrowserCommandLineReturns, String> {
+                Ok(GetBrowserCommandLineReturns {
+                    arguments: self.arguments.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(arguments))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetBrowserCommandLineParams {
+            type Response = GetBrowserCommandLineReturns;
+        }
+        #[doc = "Get Chrome histograms.\n[getHistograms](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getHistograms)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetHistogramsParams {
+            #[doc = "Requested substring in name. Only histograms which have query as a\nsubstring in their name are extracted. An empty or absent query returns\nall histograms."]
+            #[serde(rename = "query")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub query: Option<String>,
+            #[doc = "If true, retrieve delta since last delta call."]
+            #[serde(rename = "delta")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub delta: Option<bool>,
+        }
+        impl GetHistogramsParams {
+            pub fn builder() -> GetHistogramsParamsBuilder {
+                GetHistogramsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetHistogramsParamsBuilder {
+            query: Option<String>,
+            delta: Option<bool>,
+        }
+        impl GetHistogramsParamsBuilder {
+            pub fn query(mut self, query: impl Into<String>) -> Self {
+                self.query = Some(query.into());
+                self
+            }
+            pub fn delta(mut self, delta: impl Into<bool>) -> Self {
+                self.delta = Some(delta.into());
+                self
+            }
+            pub fn build(self) -> GetHistogramsParams {
+                GetHistogramsParams {
+                    query: self.query,
+                    delta: self.delta,
+                }
+            }
+        }
+        impl GetHistogramsParams {
+            pub const IDENTIFIER: &'static str = "Browser.getHistograms";
+        }
+        impl chromiumoxide_types::Method for GetHistogramsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetHistogramsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Get Chrome histograms.\n[getHistograms](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getHistograms)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetHistogramsReturns {
+            #[doc = "Histograms."]
+            #[serde(rename = "histograms")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub histograms: Vec<Histogram>,
+        }
+        impl GetHistogramsReturns {
+            pub fn new(histograms: Vec<Histogram>) -> Self {
+                Self { histograms }
+            }
+        }
+        impl GetHistogramsReturns {
+            pub fn builder() -> GetHistogramsReturnsBuilder {
+                GetHistogramsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetHistogramsReturnsBuilder {
+            histograms: Option<Vec<Histogram>>,
+        }
+        impl GetHistogramsReturnsBuilder {
+            pub fn histogram(mut self, histogram: impl Into<Histogram>) -> Self {
+                let v = self.histograms.get_or_insert(Vec::new());
+                v.push(histogram.into());
+                self
+            }
+            pub fn histograms<I, S>(mut self, histograms: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Histogram>,
+            {
+                let v = self.histograms.get_or_insert(Vec::new());
+                for val in histograms {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetHistogramsReturns, String> {
+                Ok(GetHistogramsReturns {
+                    histograms: self.histograms.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(histograms))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetHistogramsParams {
+            type Response = GetHistogramsReturns;
+        }
+        #[doc = "Get a Chrome histogram by name.\n[getHistogram](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getHistogram)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetHistogramParams {
+            #[doc = "Requested histogram name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "If true, retrieve delta since last delta call."]
+            #[serde(rename = "delta")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub delta: Option<bool>,
+        }
+        impl GetHistogramParams {
+            pub fn new(name: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    delta: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetHistogramParams {
+            fn from(url: T) -> Self {
+                GetHistogramParams::new(url)
+            }
+        }
+        impl GetHistogramParams {
+            pub fn builder() -> GetHistogramParamsBuilder {
+                GetHistogramParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetHistogramParamsBuilder {
+            name: Option<String>,
+            delta: Option<bool>,
+        }
+        impl GetHistogramParamsBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn delta(mut self, delta: impl Into<bool>) -> Self {
+                self.delta = Some(delta.into());
+                self
+            }
+            pub fn build(self) -> Result<GetHistogramParams, String> {
+                Ok(GetHistogramParams {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    delta: self.delta,
+                })
+            }
+        }
+        impl GetHistogramParams {
+            pub const IDENTIFIER: &'static str = "Browser.getHistogram";
+        }
+        impl chromiumoxide_types::Method for GetHistogramParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetHistogramParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Get a Chrome histogram by name.\n[getHistogram](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getHistogram)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetHistogramReturns {
+            #[doc = "Histogram."]
+            #[serde(rename = "histogram")]
+            pub histogram: Histogram,
+        }
+        impl GetHistogramReturns {
+            pub fn new(histogram: impl Into<Histogram>) -> Self {
+                Self {
+                    histogram: histogram.into(),
+                }
+            }
+        }
+        impl GetHistogramReturns {
+            pub fn builder() -> GetHistogramReturnsBuilder {
+                GetHistogramReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetHistogramReturnsBuilder {
+            histogram: Option<Histogram>,
+        }
+        impl GetHistogramReturnsBuilder {
+            pub fn histogram(mut self, histogram: impl Into<Histogram>) -> Self {
+                self.histogram = Some(histogram.into());
+                self
+            }
+            pub fn build(self) -> Result<GetHistogramReturns, String> {
+                Ok(GetHistogramReturns {
+                    histogram: self.histogram.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(histogram))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetHistogramParams {
+            type Response = GetHistogramReturns;
+        }
+        #[doc = "Get position and size of the browser window.\n[getWindowBounds](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getWindowBounds)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetWindowBoundsParams {
+            #[doc = "Browser window id."]
+            #[serde(rename = "windowId")]
+            pub window_id: WindowId,
+        }
+        impl GetWindowBoundsParams {
+            pub fn new(window_id: impl Into<WindowId>) -> Self {
+                Self {
+                    window_id: window_id.into(),
+                }
+            }
+        }
+        impl GetWindowBoundsParams {
+            pub fn builder() -> GetWindowBoundsParamsBuilder {
+                GetWindowBoundsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetWindowBoundsParamsBuilder {
+            window_id: Option<WindowId>,
+        }
+        impl GetWindowBoundsParamsBuilder {
+            pub fn window_id(mut self, window_id: impl Into<WindowId>) -> Self {
+                self.window_id = Some(window_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetWindowBoundsParams, String> {
+                Ok(GetWindowBoundsParams {
+                    window_id: self.window_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(window_id))
+                    })?,
+                })
+            }
+        }
+        impl GetWindowBoundsParams {
+            pub const IDENTIFIER: &'static str = "Browser.getWindowBounds";
+        }
+        impl chromiumoxide_types::Method for GetWindowBoundsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetWindowBoundsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Get position and size of the browser window.\n[getWindowBounds](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getWindowBounds)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetWindowBoundsReturns {
+            #[doc = "Bounds information of the window. When window state is 'minimized', the restored window\nposition and size are returned."]
+            #[serde(rename = "bounds")]
+            pub bounds: Bounds,
+        }
+        impl GetWindowBoundsReturns {
+            pub fn new(bounds: impl Into<Bounds>) -> Self {
+                Self {
+                    bounds: bounds.into(),
+                }
+            }
+        }
+        impl GetWindowBoundsReturns {
+            pub fn builder() -> GetWindowBoundsReturnsBuilder {
+                GetWindowBoundsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetWindowBoundsReturnsBuilder {
+            bounds: Option<Bounds>,
+        }
+        impl GetWindowBoundsReturnsBuilder {
+            pub fn bounds(mut self, bounds: impl Into<Bounds>) -> Self {
+                self.bounds = Some(bounds.into());
+                self
+            }
+            pub fn build(self) -> Result<GetWindowBoundsReturns, String> {
+                Ok(GetWindowBoundsReturns {
+                    bounds: self.bounds.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bounds))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetWindowBoundsParams {
+            type Response = GetWindowBoundsReturns;
+        }
+        #[doc = "Get the browser window that contains the devtools target.\n[getWindowForTarget](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getWindowForTarget)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetWindowForTargetParams {
+            #[doc = "Devtools agent host id. If called as a part of the session, associated targetId is used."]
+            #[serde(rename = "targetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub target_id: Option<super::target::TargetId>,
+        }
+        impl GetWindowForTargetParams {
+            pub fn builder() -> GetWindowForTargetParamsBuilder {
+                GetWindowForTargetParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetWindowForTargetParamsBuilder {
+            target_id: Option<super::target::TargetId>,
+        }
+        impl GetWindowForTargetParamsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<super::target::TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn build(self) -> GetWindowForTargetParams {
+                GetWindowForTargetParams {
+                    target_id: self.target_id,
+                }
+            }
+        }
+        impl GetWindowForTargetParams {
+            pub const IDENTIFIER: &'static str = "Browser.getWindowForTarget";
+        }
+        impl chromiumoxide_types::Method for GetWindowForTargetParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetWindowForTargetParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Get the browser window that contains the devtools target.\n[getWindowForTarget](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-getWindowForTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetWindowForTargetReturns {
+            #[doc = "Browser window id."]
+            #[serde(rename = "windowId")]
+            pub window_id: WindowId,
+            #[doc = "Bounds information of the window. When window state is 'minimized', the restored window\nposition and size are returned."]
+            #[serde(rename = "bounds")]
+            pub bounds: Bounds,
+        }
+        impl GetWindowForTargetReturns {
+            pub fn new(window_id: impl Into<WindowId>, bounds: impl Into<Bounds>) -> Self {
+                Self {
+                    window_id: window_id.into(),
+                    bounds: bounds.into(),
+                }
+            }
+        }
+        impl GetWindowForTargetReturns {
+            pub fn builder() -> GetWindowForTargetReturnsBuilder {
+                GetWindowForTargetReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetWindowForTargetReturnsBuilder {
+            window_id: Option<WindowId>,
+            bounds: Option<Bounds>,
+        }
+        impl GetWindowForTargetReturnsBuilder {
+            pub fn window_id(mut self, window_id: impl Into<WindowId>) -> Self {
+                self.window_id = Some(window_id.into());
+                self
+            }
+            pub fn bounds(mut self, bounds: impl Into<Bounds>) -> Self {
+                self.bounds = Some(bounds.into());
+                self
+            }
+            pub fn build(self) -> Result<GetWindowForTargetReturns, String> {
+                Ok(GetWindowForTargetReturns {
+                    window_id: self.window_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(window_id))
+                    })?,
+                    bounds: self.bounds.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bounds))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetWindowForTargetParams {
+            type Response = GetWindowForTargetReturns;
+        }
+        #[doc = "Set position and/or size of the browser window.\n[setWindowBounds](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-setWindowBounds)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetWindowBoundsParams {
+            #[doc = "Browser window id."]
+            #[serde(rename = "windowId")]
+            pub window_id: WindowId,
+            #[doc = "New window bounds. The 'minimized', 'maximized' and 'fullscreen' states cannot be combined\nwith 'left', 'top', 'width' or 'height'. Leaves unspecified fields unchanged."]
+            #[serde(rename = "bounds")]
+            pub bounds: Bounds,
+        }
+        impl SetWindowBoundsParams {
+            pub fn new(window_id: impl Into<WindowId>, bounds: impl Into<Bounds>) -> Self {
+                Self {
+                    window_id: window_id.into(),
+                    bounds: bounds.into(),
+                }
+            }
+        }
+        impl SetWindowBoundsParams {
+            pub fn builder() -> SetWindowBoundsParamsBuilder {
+                SetWindowBoundsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetWindowBoundsParamsBuilder {
+            window_id: Option<WindowId>,
+            bounds: Option<Bounds>,
+        }
+        impl SetWindowBoundsParamsBuilder {
+            pub fn window_id(mut self, window_id: impl Into<WindowId>) -> Self {
+                self.window_id = Some(window_id.into());
+                self
+            }
+            pub fn bounds(mut self, bounds: impl Into<Bounds>) -> Self {
+                self.bounds = Some(bounds.into());
+                self
+            }
+            pub fn build(self) -> Result<SetWindowBoundsParams, String> {
+                Ok(SetWindowBoundsParams {
+                    window_id: self.window_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(window_id))
+                    })?,
+                    bounds: self.bounds.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bounds))
+                    })?,
+                })
+            }
+        }
+        impl SetWindowBoundsParams {
+            pub const IDENTIFIER: &'static str = "Browser.setWindowBounds";
+        }
+        impl chromiumoxide_types::Method for SetWindowBoundsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetWindowBoundsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set position and/or size of the browser window.\n[setWindowBounds](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-setWindowBounds)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetWindowBoundsReturns {}
+        impl chromiumoxide_types::Command for SetWindowBoundsParams {
+            type Response = SetWindowBoundsReturns;
+        }
+        #[doc = "Set size of the browser contents resizing browser window as necessary.\n[setContentsSize](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-setContentsSize)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetContentsSizeParams {
+            #[doc = "Browser window id."]
+            #[serde(rename = "windowId")]
+            pub window_id: WindowId,
+            #[doc = "The window contents width in DIP. Assumes current width if omitted.\nMust be specified if 'height' is omitted."]
+            #[serde(rename = "width")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub width: Option<i64>,
+            #[doc = "The window contents height in DIP. Assumes current height if omitted.\nMust be specified if 'width' is omitted."]
+            #[serde(rename = "height")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub height: Option<i64>,
+        }
+        impl SetContentsSizeParams {
+            pub fn new(window_id: impl Into<WindowId>) -> Self {
+                Self {
+                    window_id: window_id.into(),
+                    width: None,
+                    height: None,
+                }
+            }
+        }
+        impl SetContentsSizeParams {
+            pub fn builder() -> SetContentsSizeParamsBuilder {
+                SetContentsSizeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetContentsSizeParamsBuilder {
+            window_id: Option<WindowId>,
+            width: Option<i64>,
+            height: Option<i64>,
+        }
+        impl SetContentsSizeParamsBuilder {
+            pub fn window_id(mut self, window_id: impl Into<WindowId>) -> Self {
+                self.window_id = Some(window_id.into());
+                self
+            }
+            pub fn width(mut self, width: impl Into<i64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<i64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn build(self) -> Result<SetContentsSizeParams, String> {
+                Ok(SetContentsSizeParams {
+                    window_id: self.window_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(window_id))
+                    })?,
+                    width: self.width,
+                    height: self.height,
+                })
+            }
+        }
+        impl SetContentsSizeParams {
+            pub const IDENTIFIER: &'static str = "Browser.setContentsSize";
+        }
+        impl chromiumoxide_types::Method for SetContentsSizeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetContentsSizeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set size of the browser contents resizing browser window as necessary.\n[setContentsSize](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-setContentsSize)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetContentsSizeReturns {}
+        impl chromiumoxide_types::Command for SetContentsSizeParams {
+            type Response = SetContentsSizeReturns;
+        }
+        #[doc = "Set dock tile details, platform-specific.\n[setDockTile](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-setDockTile)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDockTileParams {
+            #[serde(rename = "badgeLabel")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub badge_label: Option<String>,
+            #[doc = "Png encoded image."]
+            #[serde(rename = "image")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub image: Option<chromiumoxide_types::Binary>,
+        }
+        impl SetDockTileParams {
+            pub fn builder() -> SetDockTileParamsBuilder {
+                SetDockTileParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDockTileParamsBuilder {
+            badge_label: Option<String>,
+            image: Option<chromiumoxide_types::Binary>,
+        }
+        impl SetDockTileParamsBuilder {
+            pub fn badge_label(mut self, badge_label: impl Into<String>) -> Self {
+                self.badge_label = Some(badge_label.into());
+                self
+            }
+            pub fn image(mut self, image: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.image = Some(image.into());
+                self
+            }
+            pub fn build(self) -> SetDockTileParams {
+                SetDockTileParams {
+                    badge_label: self.badge_label,
+                    image: self.image,
+                }
+            }
+        }
+        impl SetDockTileParams {
+            pub const IDENTIFIER: &'static str = "Browser.setDockTile";
+        }
+        impl chromiumoxide_types::Method for SetDockTileParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDockTileParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set dock tile details, platform-specific.\n[setDockTile](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-setDockTile)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDockTileReturns {}
+        impl chromiumoxide_types::Command for SetDockTileParams {
+            type Response = SetDockTileReturns;
+        }
+        #[doc = "Invoke custom browser commands used by telemetry.\n[executeBrowserCommand](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-executeBrowserCommand)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ExecuteBrowserCommandParams {
+            #[serde(rename = "commandId")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub command_id: BrowserCommandId,
+        }
+        impl ExecuteBrowserCommandParams {
+            pub fn new(command_id: impl Into<BrowserCommandId>) -> Self {
+                Self {
+                    command_id: command_id.into(),
+                }
+            }
+        }
+        impl ExecuteBrowserCommandParams {
+            pub fn builder() -> ExecuteBrowserCommandParamsBuilder {
+                ExecuteBrowserCommandParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ExecuteBrowserCommandParamsBuilder {
+            command_id: Option<BrowserCommandId>,
+        }
+        impl ExecuteBrowserCommandParamsBuilder {
+            pub fn command_id(mut self, command_id: impl Into<BrowserCommandId>) -> Self {
+                self.command_id = Some(command_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ExecuteBrowserCommandParams, String> {
+                Ok(ExecuteBrowserCommandParams {
+                    command_id: self.command_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(command_id))
+                    })?,
+                })
+            }
+        }
+        impl ExecuteBrowserCommandParams {
+            pub const IDENTIFIER: &'static str = "Browser.executeBrowserCommand";
+        }
+        impl chromiumoxide_types::Method for ExecuteBrowserCommandParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ExecuteBrowserCommandParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Invoke custom browser commands used by telemetry.\n[executeBrowserCommand](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-executeBrowserCommand)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ExecuteBrowserCommandReturns {}
+        impl chromiumoxide_types::Command for ExecuteBrowserCommandParams {
+            type Response = ExecuteBrowserCommandReturns;
+        }
+        #[doc = "Allows a site to use privacy sandbox features that require enrollment\nwithout the site actually being enrolled. Only supported on page targets.\n[addPrivacySandboxEnrollmentOverride](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-addPrivacySandboxEnrollmentOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddPrivacySandboxEnrollmentOverrideParams {
+            #[serde(rename = "url")]
+            pub url: String,
+        }
+        impl AddPrivacySandboxEnrollmentOverrideParams {
+            pub fn new(url: impl Into<String>) -> Self {
+                Self { url: url.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for AddPrivacySandboxEnrollmentOverrideParams {
+            fn from(url: T) -> Self {
+                AddPrivacySandboxEnrollmentOverrideParams::new(url)
+            }
+        }
+        impl AddPrivacySandboxEnrollmentOverrideParams {
+            pub fn builder() -> AddPrivacySandboxEnrollmentOverrideParamsBuilder {
+                AddPrivacySandboxEnrollmentOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddPrivacySandboxEnrollmentOverrideParamsBuilder {
+            url: Option<String>,
+        }
+        impl AddPrivacySandboxEnrollmentOverrideParamsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn build(self) -> Result<AddPrivacySandboxEnrollmentOverrideParams, String> {
+                Ok(AddPrivacySandboxEnrollmentOverrideParams {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                })
+            }
+        }
+        impl AddPrivacySandboxEnrollmentOverrideParams {
+            pub const IDENTIFIER: &'static str = "Browser.addPrivacySandboxEnrollmentOverride";
+        }
+        impl chromiumoxide_types::Method for AddPrivacySandboxEnrollmentOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddPrivacySandboxEnrollmentOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Allows a site to use privacy sandbox features that require enrollment\nwithout the site actually being enrolled. Only supported on page targets.\n[addPrivacySandboxEnrollmentOverride](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-addPrivacySandboxEnrollmentOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct AddPrivacySandboxEnrollmentOverrideReturns {}
+        impl chromiumoxide_types::Command for AddPrivacySandboxEnrollmentOverrideParams {
+            type Response = AddPrivacySandboxEnrollmentOverrideReturns;
+        }
+        #[doc = "Configures encryption keys used with a given privacy sandbox API to talk\nto a trusted coordinator.  Since this is intended for test automation only,\ncoordinatorOrigin must be a .test domain. No existing coordinator\nconfiguration for the origin may exist.\n[addPrivacySandboxCoordinatorKeyConfig](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-addPrivacySandboxCoordinatorKeyConfig)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddPrivacySandboxCoordinatorKeyConfigParams {
+            #[serde(rename = "api")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub api: PrivacySandboxApi,
+            #[serde(rename = "coordinatorOrigin")]
+            pub coordinator_origin: String,
+            #[serde(rename = "keyConfig")]
+            pub key_config: String,
+            #[doc = "BrowserContext to perform the action in. When omitted, default browser\ncontext is used."]
+            #[serde(rename = "browserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub browser_context_id: Option<BrowserContextId>,
+        }
+        impl AddPrivacySandboxCoordinatorKeyConfigParams {
+            pub fn new(
+                api: impl Into<PrivacySandboxApi>,
+                coordinator_origin: impl Into<String>,
+                key_config: impl Into<String>,
+            ) -> Self {
+                Self {
+                    api: api.into(),
+                    coordinator_origin: coordinator_origin.into(),
+                    key_config: key_config.into(),
+                    browser_context_id: None,
+                }
+            }
+        }
+        impl AddPrivacySandboxCoordinatorKeyConfigParams {
+            pub fn builder() -> AddPrivacySandboxCoordinatorKeyConfigParamsBuilder {
+                AddPrivacySandboxCoordinatorKeyConfigParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddPrivacySandboxCoordinatorKeyConfigParamsBuilder {
+            api: Option<PrivacySandboxApi>,
+            coordinator_origin: Option<String>,
+            key_config: Option<String>,
+            browser_context_id: Option<BrowserContextId>,
+        }
+        impl AddPrivacySandboxCoordinatorKeyConfigParamsBuilder {
+            pub fn api(mut self, api: impl Into<PrivacySandboxApi>) -> Self {
+                self.api = Some(api.into());
+                self
+            }
+            pub fn coordinator_origin(mut self, coordinator_origin: impl Into<String>) -> Self {
+                self.coordinator_origin = Some(coordinator_origin.into());
+                self
+            }
+            pub fn key_config(mut self, key_config: impl Into<String>) -> Self {
+                self.key_config = Some(key_config.into());
+                self
+            }
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AddPrivacySandboxCoordinatorKeyConfigParams, String> {
+                Ok(AddPrivacySandboxCoordinatorKeyConfigParams {
+                    api: self
+                        .api
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(api)))?,
+                    coordinator_origin: self.coordinator_origin.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(coordinator_origin)
+                        )
+                    })?,
+                    key_config: self.key_config.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_config))
+                    })?,
+                    browser_context_id: self.browser_context_id,
+                })
+            }
+        }
+        impl AddPrivacySandboxCoordinatorKeyConfigParams {
+            pub const IDENTIFIER: &'static str = "Browser.addPrivacySandboxCoordinatorKeyConfig";
+        }
+        impl chromiumoxide_types::Method for AddPrivacySandboxCoordinatorKeyConfigParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddPrivacySandboxCoordinatorKeyConfigParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Configures encryption keys used with a given privacy sandbox API to talk\nto a trusted coordinator.  Since this is intended for test automation only,\ncoordinatorOrigin must be a .test domain. No existing coordinator\nconfiguration for the origin may exist.\n[addPrivacySandboxCoordinatorKeyConfig](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#method-addPrivacySandboxCoordinatorKeyConfig)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct AddPrivacySandboxCoordinatorKeyConfigReturns {}
+        impl chromiumoxide_types::Command for AddPrivacySandboxCoordinatorKeyConfigParams {
+            type Response = AddPrivacySandboxCoordinatorKeyConfigReturns;
+        }
+        #[doc = "Fired when page is about to start a download.\n[downloadWillBegin](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#event-downloadWillBegin)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDownloadWillBegin {
+            #[doc = "Id of the frame that caused the download to begin."]
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+            #[doc = "Global unique identifier of the download."]
+            #[serde(rename = "guid")]
+            pub guid: String,
+            #[doc = "URL of the resource being downloaded."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Suggested file name of the resource (the actual name of the file saved on disk may differ)."]
+            #[serde(rename = "suggestedFilename")]
+            pub suggested_filename: String,
+        }
+        impl EventDownloadWillBegin {
+            pub const IDENTIFIER: &'static str = "Browser.downloadWillBegin";
+        }
+        impl chromiumoxide_types::Method for EventDownloadWillBegin {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDownloadWillBegin {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when download makes progress. Last call has |done| == true.\n[downloadProgress](https://chromedevtools.github.io/devtools-protocol/tot/Browser/#event-downloadProgress)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDownloadProgress {
+            #[doc = "Global unique identifier of the download."]
+            #[serde(rename = "guid")]
+            pub guid: String,
+            #[doc = "Total expected bytes to download."]
+            #[serde(rename = "totalBytes")]
+            pub total_bytes: f64,
+            #[doc = "Total bytes received."]
+            #[serde(rename = "receivedBytes")]
+            pub received_bytes: f64,
+            #[doc = "Download status."]
+            #[serde(rename = "state")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub state: DownloadProgressState,
+            #[doc = "If download is \"completed\", provides the path of the downloaded file.\nDepending on the platform, it is not guaranteed to be set, nor the file\nis guaranteed to exist."]
+            #[serde(rename = "filePath")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub file_path: Option<String>,
+        }
+        #[doc = "Download status."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DownloadProgressState {
+            #[serde(rename = "inProgress")]
+            InProgress,
+            #[serde(rename = "completed")]
+            Completed,
+            #[serde(rename = "canceled")]
+            Canceled,
+        }
+        impl AsRef<str> for DownloadProgressState {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DownloadProgressState::InProgress => "inProgress",
+                    DownloadProgressState::Completed => "completed",
+                    DownloadProgressState::Canceled => "canceled",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DownloadProgressState {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "inProgress" | "InProgress" | "inprogress" => {
+                        Ok(DownloadProgressState::InProgress)
+                    }
+                    "completed" | "Completed" => Ok(DownloadProgressState::Completed),
+                    "canceled" | "Canceled" => Ok(DownloadProgressState::Canceled),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EventDownloadProgress {
+            pub const IDENTIFIER: &'static str = "Browser.downloadProgress";
+        }
+        impl chromiumoxide_types::Method for EventDownloadProgress {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDownloadProgress {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "This domain exposes CSS read/write operations. All CSS objects (stylesheets, rules, and styles)\nhave an associated `id` used in subsequent operations on the related object. Each object type has\na specific `id` structure, and those are not interchangeable between objects of different kinds.\nCSS objects can be loaded using the `get*ForNode()` calls (which accept a DOM node id). A client\ncan also keep track of stylesheets via the `styleSheetAdded`/`styleSheetRemoved` events and\nsubsequently load the required stylesheet contents using the `getStyleSheet[Text]()` methods."]
+    pub mod css {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Stylesheet type: \"injected\" for stylesheets injected via extension, \"user-agent\" for user-agent\nstylesheets, \"inspector\" for stylesheets created by the inspector (i.e. those holding the \"via\ninspector\" rules), \"regular\" for regular stylesheets."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum StyleSheetOrigin {
+            #[serde(rename = "injected")]
+            Injected,
+            #[serde(rename = "user-agent")]
+            UserAgent,
+            #[serde(rename = "inspector")]
+            Inspector,
+            #[serde(rename = "regular")]
+            Regular,
+        }
+        impl AsRef<str> for StyleSheetOrigin {
+            fn as_ref(&self) -> &str {
+                match self {
+                    StyleSheetOrigin::Injected => "injected",
+                    StyleSheetOrigin::UserAgent => "user-agent",
+                    StyleSheetOrigin::Inspector => "inspector",
+                    StyleSheetOrigin::Regular => "regular",
+                }
+            }
+        }
+        impl ::std::str::FromStr for StyleSheetOrigin {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "injected" | "Injected" => Ok(StyleSheetOrigin::Injected),
+                    "user-agent" | "UserAgent" => Ok(StyleSheetOrigin::UserAgent),
+                    "inspector" | "Inspector" => Ok(StyleSheetOrigin::Inspector),
+                    "regular" | "Regular" => Ok(StyleSheetOrigin::Regular),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "CSS rule collection for a single pseudo style.\n[PseudoElementMatches](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-PseudoElementMatches)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PseudoElementMatches {
+            #[doc = "Pseudo element type."]
+            #[serde(rename = "pseudoType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub pseudo_type: super::dom::PseudoType,
+            #[doc = "Pseudo element custom ident."]
+            #[serde(rename = "pseudoIdentifier")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pseudo_identifier: Option<String>,
+            #[doc = "Matches of CSS rules applicable to the pseudo style."]
+            #[serde(rename = "matches")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub matches: Vec<RuleMatch>,
+        }
+        impl PseudoElementMatches {
+            pub fn new(
+                pseudo_type: impl Into<super::dom::PseudoType>,
+                matches: Vec<RuleMatch>,
+            ) -> Self {
+                Self {
+                    pseudo_type: pseudo_type.into(),
+                    matches,
+                    pseudo_identifier: None,
+                }
+            }
+        }
+        impl PseudoElementMatches {
+            pub fn builder() -> PseudoElementMatchesBuilder {
+                PseudoElementMatchesBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PseudoElementMatchesBuilder {
+            pseudo_type: Option<super::dom::PseudoType>,
+            pseudo_identifier: Option<String>,
+            matches: Option<Vec<RuleMatch>>,
+        }
+        impl PseudoElementMatchesBuilder {
+            pub fn pseudo_type(mut self, pseudo_type: impl Into<super::dom::PseudoType>) -> Self {
+                self.pseudo_type = Some(pseudo_type.into());
+                self
+            }
+            pub fn pseudo_identifier(mut self, pseudo_identifier: impl Into<String>) -> Self {
+                self.pseudo_identifier = Some(pseudo_identifier.into());
+                self
+            }
+            pub fn matche(mut self, matche: impl Into<RuleMatch>) -> Self {
+                let v = self.matches.get_or_insert(Vec::new());
+                v.push(matche.into());
+                self
+            }
+            pub fn matches<I, S>(mut self, matches: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<RuleMatch>,
+            {
+                let v = self.matches.get_or_insert(Vec::new());
+                for val in matches {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<PseudoElementMatches, String> {
+                Ok(PseudoElementMatches {
+                    pseudo_type: self.pseudo_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(pseudo_type))
+                    })?,
+                    pseudo_identifier: self.pseudo_identifier,
+                    matches: self.matches.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(matches))
+                    })?,
+                })
+            }
+        }
+        impl PseudoElementMatches {
+            pub const IDENTIFIER: &'static str = "CSS.PseudoElementMatches";
+        }
+        #[doc = "CSS style coming from animations with the name of the animation.\n[CSSAnimationStyle](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSAnimationStyle)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssAnimationStyle {
+            #[doc = "The name of the animation."]
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[doc = "The style coming from the animation."]
+            #[serde(rename = "style")]
+            pub style: CssStyle,
+        }
+        impl CssAnimationStyle {
+            pub fn new(style: impl Into<CssStyle>) -> Self {
+                Self {
+                    style: style.into(),
+                    name: None,
+                }
+            }
+        }
+        impl CssAnimationStyle {
+            pub fn builder() -> CssAnimationStyleBuilder {
+                CssAnimationStyleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssAnimationStyleBuilder {
+            name: Option<String>,
+            style: Option<CssStyle>,
+        }
+        impl CssAnimationStyleBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn style(mut self, style: impl Into<CssStyle>) -> Self {
+                self.style = Some(style.into());
+                self
+            }
+            pub fn build(self) -> Result<CssAnimationStyle, String> {
+                Ok(CssAnimationStyle {
+                    name: self.name,
+                    style: self.style.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style))
+                    })?,
+                })
+            }
+        }
+        impl CssAnimationStyle {
+            pub const IDENTIFIER: &'static str = "CSS.CSSAnimationStyle";
+        }
+        #[doc = "Inherited CSS rule collection from ancestor node.\n[InheritedStyleEntry](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-InheritedStyleEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct InheritedStyleEntry {
+            #[doc = "The ancestor node's inline style, if any, in the style inheritance chain."]
+            #[serde(rename = "inlineStyle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub inline_style: Option<CssStyle>,
+            #[doc = "Matches of CSS rules matching the ancestor node in the style inheritance chain."]
+            #[serde(rename = "matchedCSSRules")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub matched_css_rules: Vec<RuleMatch>,
+        }
+        impl InheritedStyleEntry {
+            pub fn new(matched_css_rules: Vec<RuleMatch>) -> Self {
+                Self {
+                    matched_css_rules,
+                    inline_style: None,
+                }
+            }
+        }
+        impl InheritedStyleEntry {
+            pub fn builder() -> InheritedStyleEntryBuilder {
+                InheritedStyleEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InheritedStyleEntryBuilder {
+            inline_style: Option<CssStyle>,
+            matched_css_rules: Option<Vec<RuleMatch>>,
+        }
+        impl InheritedStyleEntryBuilder {
+            pub fn inline_style(mut self, inline_style: impl Into<CssStyle>) -> Self {
+                self.inline_style = Some(inline_style.into());
+                self
+            }
+            pub fn matched_css_rule(mut self, matched_css_rule: impl Into<RuleMatch>) -> Self {
+                let v = self.matched_css_rules.get_or_insert(Vec::new());
+                v.push(matched_css_rule.into());
+                self
+            }
+            pub fn matched_css_rules<I, S>(mut self, matched_css_rules: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<RuleMatch>,
+            {
+                let v = self.matched_css_rules.get_or_insert(Vec::new());
+                for val in matched_css_rules {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<InheritedStyleEntry, String> {
+                Ok(InheritedStyleEntry {
+                    inline_style: self.inline_style,
+                    matched_css_rules: self.matched_css_rules.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(matched_css_rules)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl InheritedStyleEntry {
+            pub const IDENTIFIER: &'static str = "CSS.InheritedStyleEntry";
+        }
+        #[doc = "Inherited CSS style collection for animated styles from ancestor node.\n[InheritedAnimatedStyleEntry](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-InheritedAnimatedStyleEntry)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct InheritedAnimatedStyleEntry {
+            #[doc = "Styles coming from the animations of the ancestor, if any, in the style inheritance chain."]
+            #[serde(rename = "animationStyles")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub animation_styles: Option<Vec<CssAnimationStyle>>,
+            #[doc = "The style coming from the transitions of the ancestor, if any, in the style inheritance chain."]
+            #[serde(rename = "transitionsStyle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub transitions_style: Option<CssStyle>,
+        }
+        impl InheritedAnimatedStyleEntry {
+            pub fn builder() -> InheritedAnimatedStyleEntryBuilder {
+                InheritedAnimatedStyleEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InheritedAnimatedStyleEntryBuilder {
+            animation_styles: Option<Vec<CssAnimationStyle>>,
+            transitions_style: Option<CssStyle>,
+        }
+        impl InheritedAnimatedStyleEntryBuilder {
+            pub fn animation_style(
+                mut self,
+                animation_style: impl Into<CssAnimationStyle>,
+            ) -> Self {
+                let v = self.animation_styles.get_or_insert(Vec::new());
+                v.push(animation_style.into());
+                self
+            }
+            pub fn animation_styles<I, S>(mut self, animation_styles: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssAnimationStyle>,
+            {
+                let v = self.animation_styles.get_or_insert(Vec::new());
+                for val in animation_styles {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn transitions_style(mut self, transitions_style: impl Into<CssStyle>) -> Self {
+                self.transitions_style = Some(transitions_style.into());
+                self
+            }
+            pub fn build(self) -> InheritedAnimatedStyleEntry {
+                InheritedAnimatedStyleEntry {
+                    animation_styles: self.animation_styles,
+                    transitions_style: self.transitions_style,
+                }
+            }
+        }
+        impl InheritedAnimatedStyleEntry {
+            pub const IDENTIFIER: &'static str = "CSS.InheritedAnimatedStyleEntry";
+        }
+        #[doc = "Inherited pseudo element matches from pseudos of an ancestor node.\n[InheritedPseudoElementMatches](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-InheritedPseudoElementMatches)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct InheritedPseudoElementMatches {
+            #[doc = "Matches of pseudo styles from the pseudos of an ancestor node."]
+            #[serde(rename = "pseudoElements")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub pseudo_elements: Vec<PseudoElementMatches>,
+        }
+        impl InheritedPseudoElementMatches {
+            pub fn new(pseudo_elements: Vec<PseudoElementMatches>) -> Self {
+                Self { pseudo_elements }
+            }
+        }
+        impl InheritedPseudoElementMatches {
+            pub fn builder() -> InheritedPseudoElementMatchesBuilder {
+                InheritedPseudoElementMatchesBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InheritedPseudoElementMatchesBuilder {
+            pseudo_elements: Option<Vec<PseudoElementMatches>>,
+        }
+        impl InheritedPseudoElementMatchesBuilder {
+            pub fn pseudo_element(
+                mut self,
+                pseudo_element: impl Into<PseudoElementMatches>,
+            ) -> Self {
+                let v = self.pseudo_elements.get_or_insert(Vec::new());
+                v.push(pseudo_element.into());
+                self
+            }
+            pub fn pseudo_elements<I, S>(mut self, pseudo_elements: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PseudoElementMatches>,
+            {
+                let v = self.pseudo_elements.get_or_insert(Vec::new());
+                for val in pseudo_elements {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<InheritedPseudoElementMatches, String> {
+                Ok(InheritedPseudoElementMatches {
+                    pseudo_elements: self.pseudo_elements.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(pseudo_elements))
+                    })?,
+                })
+            }
+        }
+        impl InheritedPseudoElementMatches {
+            pub const IDENTIFIER: &'static str = "CSS.InheritedPseudoElementMatches";
+        }
+        #[doc = "Match data for a CSS rule.\n[RuleMatch](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-RuleMatch)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RuleMatch {
+            #[doc = "CSS rule in the match."]
+            #[serde(rename = "rule")]
+            pub rule: CssRule,
+            #[doc = "Matching selector indices in the rule's selectorList selectors (0-based)."]
+            #[serde(rename = "matchingSelectors")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub matching_selectors: Vec<i64>,
+        }
+        impl RuleMatch {
+            pub fn new(rule: impl Into<CssRule>, matching_selectors: Vec<i64>) -> Self {
+                Self {
+                    rule: rule.into(),
+                    matching_selectors,
+                }
+            }
+        }
+        impl RuleMatch {
+            pub fn builder() -> RuleMatchBuilder {
+                RuleMatchBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RuleMatchBuilder {
+            rule: Option<CssRule>,
+            matching_selectors: Option<Vec<i64>>,
+        }
+        impl RuleMatchBuilder {
+            pub fn rule(mut self, rule: impl Into<CssRule>) -> Self {
+                self.rule = Some(rule.into());
+                self
+            }
+            pub fn matching_selector(mut self, matching_selector: impl Into<i64>) -> Self {
+                let v = self.matching_selectors.get_or_insert(Vec::new());
+                v.push(matching_selector.into());
+                self
+            }
+            pub fn matching_selectors<I, S>(mut self, matching_selectors: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.matching_selectors.get_or_insert(Vec::new());
+                for val in matching_selectors {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<RuleMatch, String> {
+                Ok(RuleMatch {
+                    rule: self.rule.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rule))
+                    })?,
+                    matching_selectors: self.matching_selectors.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(matching_selectors)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl RuleMatch {
+            pub const IDENTIFIER: &'static str = "CSS.RuleMatch";
+        }
+        #[doc = "Data for a simple selector (these are delimited by commas in a selector list).\n[Value](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-Value)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Value {
+            #[doc = "Value text."]
+            #[serde(rename = "text")]
+            pub text: String,
+            #[doc = "Value range in the underlying resource (if available)."]
+            #[serde(rename = "range")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub range: Option<SourceRange>,
+            #[doc = "Specificity of the selector."]
+            #[serde(rename = "specificity")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub specificity: Option<Specificity>,
+        }
+        impl Value {
+            pub fn new(text: impl Into<String>) -> Self {
+                Self {
+                    text: text.into(),
+                    range: None,
+                    specificity: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for Value {
+            fn from(url: T) -> Self {
+                Value::new(url)
+            }
+        }
+        impl Value {
+            pub fn builder() -> ValueBuilder {
+                ValueBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ValueBuilder {
+            text: Option<String>,
+            range: Option<SourceRange>,
+            specificity: Option<Specificity>,
+        }
+        impl ValueBuilder {
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn specificity(mut self, specificity: impl Into<Specificity>) -> Self {
+                self.specificity = Some(specificity.into());
+                self
+            }
+            pub fn build(self) -> Result<Value, String> {
+                Ok(Value {
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    range: self.range,
+                    specificity: self.specificity,
+                })
+            }
+        }
+        impl Value {
+            pub const IDENTIFIER: &'static str = "CSS.Value";
+        }
+        #[doc = "Specificity:\nhttps://drafts.csswg.org/selectors/#specificity-rules\n[Specificity](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-Specificity)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Specificity {
+            #[doc = "The a component, which represents the number of ID selectors."]
+            #[serde(rename = "a")]
+            pub a: i64,
+            #[doc = "The b component, which represents the number of class selectors, attributes selectors, and\npseudo-classes."]
+            #[serde(rename = "b")]
+            pub b: i64,
+            #[doc = "The c component, which represents the number of type selectors and pseudo-elements."]
+            #[serde(rename = "c")]
+            pub c: i64,
+        }
+        impl Specificity {
+            pub fn new(a: impl Into<i64>, b: impl Into<i64>, c: impl Into<i64>) -> Self {
+                Self {
+                    a: a.into(),
+                    b: b.into(),
+                    c: c.into(),
+                }
+            }
+        }
+        impl Specificity {
+            pub fn builder() -> SpecificityBuilder {
+                SpecificityBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SpecificityBuilder {
+            a: Option<i64>,
+            b: Option<i64>,
+            c: Option<i64>,
+        }
+        impl SpecificityBuilder {
+            pub fn a(mut self, a: impl Into<i64>) -> Self {
+                self.a = Some(a.into());
+                self
+            }
+            pub fn b(mut self, b: impl Into<i64>) -> Self {
+                self.b = Some(b.into());
+                self
+            }
+            pub fn c(mut self, c: impl Into<i64>) -> Self {
+                self.c = Some(c.into());
+                self
+            }
+            pub fn build(self) -> Result<Specificity, String> {
+                Ok(Specificity {
+                    a: self
+                        .a
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(a)))?,
+                    b: self
+                        .b
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(b)))?,
+                    c: self
+                        .c
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(c)))?,
+                })
+            }
+        }
+        impl Specificity {
+            pub const IDENTIFIER: &'static str = "CSS.Specificity";
+        }
+        #[doc = "Selector list data.\n[SelectorList](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-SelectorList)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SelectorList {
+            #[doc = "Selectors in the list."]
+            #[serde(rename = "selectors")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub selectors: Vec<Value>,
+            #[doc = "Rule selector text."]
+            #[serde(rename = "text")]
+            pub text: String,
+        }
+        impl SelectorList {
+            pub fn new(selectors: Vec<Value>, text: impl Into<String>) -> Self {
+                Self {
+                    selectors,
+                    text: text.into(),
+                }
+            }
+        }
+        impl SelectorList {
+            pub fn builder() -> SelectorListBuilder {
+                SelectorListBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SelectorListBuilder {
+            selectors: Option<Vec<Value>>,
+            text: Option<String>,
+        }
+        impl SelectorListBuilder {
+            pub fn selector(mut self, selector: impl Into<Value>) -> Self {
+                let v = self.selectors.get_or_insert(Vec::new());
+                v.push(selector.into());
+                self
+            }
+            pub fn selectors<I, S>(mut self, selectors: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Value>,
+            {
+                let v = self.selectors.get_or_insert(Vec::new());
+                for val in selectors {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn build(self) -> Result<SelectorList, String> {
+                Ok(SelectorList {
+                    selectors: self.selectors.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(selectors))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                })
+            }
+        }
+        impl SelectorList {
+            pub const IDENTIFIER: &'static str = "CSS.SelectorList";
+        }
+        #[doc = "CSS stylesheet metainformation.\n[CSSStyleSheetHeader](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSStyleSheetHeader)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssStyleSheetHeader {
+            #[doc = "The stylesheet identifier."]
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[doc = "Owner frame identifier."]
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+            #[doc = "Stylesheet resource URL. Empty if this is a constructed stylesheet created using\nnew CSSStyleSheet() (but non-empty if this is a constructed stylesheet imported\nas a CSS module script)."]
+            #[serde(rename = "sourceURL")]
+            pub source_url: String,
+            #[doc = "URL of source map associated with the stylesheet (if any)."]
+            #[serde(rename = "sourceMapURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_map_url: Option<String>,
+            #[doc = "Stylesheet origin."]
+            #[serde(rename = "origin")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub origin: StyleSheetOrigin,
+            #[doc = "Stylesheet title."]
+            #[serde(rename = "title")]
+            pub title: String,
+            #[doc = "The backend id for the owner node of the stylesheet."]
+            #[serde(rename = "ownerNode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub owner_node: Option<super::dom::BackendNodeId>,
+            #[doc = "Denotes whether the stylesheet is disabled."]
+            #[serde(rename = "disabled")]
+            pub disabled: bool,
+            #[doc = "Whether the sourceURL field value comes from the sourceURL comment."]
+            #[serde(rename = "hasSourceURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_source_url: Option<bool>,
+            #[doc = "Whether this stylesheet is created for STYLE tag by parser. This flag is not set for\ndocument.written STYLE tags."]
+            #[serde(rename = "isInline")]
+            pub is_inline: bool,
+            #[doc = "Whether this stylesheet is mutable. Inline stylesheets become mutable\nafter they have been modified via CSSOM API.\n`<link>` element's stylesheets become mutable only if DevTools modifies them.\nConstructed stylesheets (new CSSStyleSheet()) are mutable immediately after creation."]
+            #[serde(rename = "isMutable")]
+            pub is_mutable: bool,
+            #[doc = "True if this stylesheet is created through new CSSStyleSheet() or imported as a\nCSS module script."]
+            #[serde(rename = "isConstructed")]
+            pub is_constructed: bool,
+            #[doc = "Line offset of the stylesheet within the resource (zero based)."]
+            #[serde(rename = "startLine")]
+            pub start_line: f64,
+            #[doc = "Column offset of the stylesheet within the resource (zero based)."]
+            #[serde(rename = "startColumn")]
+            pub start_column: f64,
+            #[doc = "Size of the content (in characters)."]
+            #[serde(rename = "length")]
+            pub length: f64,
+            #[doc = "Line offset of the end of the stylesheet within the resource (zero based)."]
+            #[serde(rename = "endLine")]
+            pub end_line: f64,
+            #[doc = "Column offset of the end of the stylesheet within the resource (zero based)."]
+            #[serde(rename = "endColumn")]
+            pub end_column: f64,
+            #[doc = "If the style sheet was loaded from a network resource, this indicates when the resource failed to load"]
+            #[serde(rename = "loadingFailed")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub loading_failed: Option<bool>,
+        }
+        impl CssStyleSheetHeader {
+            pub fn builder() -> CssStyleSheetHeaderBuilder {
+                CssStyleSheetHeaderBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssStyleSheetHeaderBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            frame_id: Option<super::page::FrameId>,
+            source_url: Option<String>,
+            source_map_url: Option<String>,
+            origin: Option<StyleSheetOrigin>,
+            title: Option<String>,
+            owner_node: Option<super::dom::BackendNodeId>,
+            disabled: Option<bool>,
+            has_source_url: Option<bool>,
+            is_inline: Option<bool>,
+            is_mutable: Option<bool>,
+            is_constructed: Option<bool>,
+            start_line: Option<f64>,
+            start_column: Option<f64>,
+            length: Option<f64>,
+            end_line: Option<f64>,
+            end_column: Option<f64>,
+            loading_failed: Option<bool>,
+        }
+        impl CssStyleSheetHeaderBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn source_url(mut self, source_url: impl Into<String>) -> Self {
+                self.source_url = Some(source_url.into());
+                self
+            }
+            pub fn source_map_url(mut self, source_map_url: impl Into<String>) -> Self {
+                self.source_map_url = Some(source_map_url.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<StyleSheetOrigin>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn title(mut self, title: impl Into<String>) -> Self {
+                self.title = Some(title.into());
+                self
+            }
+            pub fn owner_node(mut self, owner_node: impl Into<super::dom::BackendNodeId>) -> Self {
+                self.owner_node = Some(owner_node.into());
+                self
+            }
+            pub fn disabled(mut self, disabled: impl Into<bool>) -> Self {
+                self.disabled = Some(disabled.into());
+                self
+            }
+            pub fn has_source_url(mut self, has_source_url: impl Into<bool>) -> Self {
+                self.has_source_url = Some(has_source_url.into());
+                self
+            }
+            pub fn is_inline(mut self, is_inline: impl Into<bool>) -> Self {
+                self.is_inline = Some(is_inline.into());
+                self
+            }
+            pub fn is_mutable(mut self, is_mutable: impl Into<bool>) -> Self {
+                self.is_mutable = Some(is_mutable.into());
+                self
+            }
+            pub fn is_constructed(mut self, is_constructed: impl Into<bool>) -> Self {
+                self.is_constructed = Some(is_constructed.into());
+                self
+            }
+            pub fn start_line(mut self, start_line: impl Into<f64>) -> Self {
+                self.start_line = Some(start_line.into());
+                self
+            }
+            pub fn start_column(mut self, start_column: impl Into<f64>) -> Self {
+                self.start_column = Some(start_column.into());
+                self
+            }
+            pub fn length(mut self, length: impl Into<f64>) -> Self {
+                self.length = Some(length.into());
+                self
+            }
+            pub fn end_line(mut self, end_line: impl Into<f64>) -> Self {
+                self.end_line = Some(end_line.into());
+                self
+            }
+            pub fn end_column(mut self, end_column: impl Into<f64>) -> Self {
+                self.end_column = Some(end_column.into());
+                self
+            }
+            pub fn loading_failed(mut self, loading_failed: impl Into<bool>) -> Self {
+                self.loading_failed = Some(loading_failed.into());
+                self
+            }
+            pub fn build(self) -> Result<CssStyleSheetHeader, String> {
+                Ok(CssStyleSheetHeader {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    source_url: self.source_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source_url))
+                    })?,
+                    source_map_url: self.source_map_url,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    title: self.title.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(title))
+                    })?,
+                    owner_node: self.owner_node,
+                    disabled: self.disabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(disabled))
+                    })?,
+                    has_source_url: self.has_source_url,
+                    is_inline: self.is_inline.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_inline))
+                    })?,
+                    is_mutable: self.is_mutable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_mutable))
+                    })?,
+                    is_constructed: self.is_constructed.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_constructed))
+                    })?,
+                    start_line: self.start_line.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start_line))
+                    })?,
+                    start_column: self.start_column.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start_column))
+                    })?,
+                    length: self.length.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(length))
+                    })?,
+                    end_line: self.end_line.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(end_line))
+                    })?,
+                    end_column: self.end_column.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(end_column))
+                    })?,
+                    loading_failed: self.loading_failed,
+                })
+            }
+        }
+        impl CssStyleSheetHeader {
+            pub const IDENTIFIER: &'static str = "CSS.CSSStyleSheetHeader";
+        }
+        #[doc = "CSS rule representation.\n[CSSRule](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssRule {
+            #[doc = "The css style sheet identifier (absent for user agent stylesheet and user-specified\nstylesheet rules) this rule came from."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+            #[doc = "Rule selector data."]
+            #[serde(rename = "selectorList")]
+            pub selector_list: SelectorList,
+            #[doc = "Array of selectors from ancestor style rules, sorted by distance from the current rule."]
+            #[serde(rename = "nestingSelectors")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub nesting_selectors: Option<Vec<String>>,
+            #[doc = "Parent stylesheet's origin."]
+            #[serde(rename = "origin")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub origin: StyleSheetOrigin,
+            #[doc = "Associated style declaration."]
+            #[serde(rename = "style")]
+            pub style: CssStyle,
+            #[doc = "The BackendNodeId of the DOM node that constitutes the origin tree scope of this rule."]
+            #[serde(rename = "originTreeScopeNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub origin_tree_scope_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "Media list array (for rules involving media queries). The array enumerates media queries\nstarting with the innermost one, going outwards."]
+            #[serde(rename = "media")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub media: Option<Vec<CssMedia>>,
+            #[doc = "Container query list array (for rules involving container queries).\nThe array enumerates container queries starting with the innermost one, going outwards."]
+            #[serde(rename = "containerQueries")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub container_queries: Option<Vec<CssContainerQuery>>,
+            #[doc = "@supports CSS at-rule array.\nThe array enumerates @supports at-rules starting with the innermost one, going outwards."]
+            #[serde(rename = "supports")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub supports: Option<Vec<CssSupports>>,
+            #[doc = "Cascade layer array. Contains the layer hierarchy that this rule belongs to starting\nwith the innermost layer and going outwards."]
+            #[serde(rename = "layers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub layers: Option<Vec<CssLayer>>,
+            #[doc = "@scope CSS at-rule array.\nThe array enumerates @scope at-rules starting with the innermost one, going outwards."]
+            #[serde(rename = "scopes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scopes: Option<Vec<CssScope>>,
+            #[doc = "The array keeps the types of ancestor CSSRules from the innermost going outwards."]
+            #[serde(rename = "ruleTypes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub rule_types: Option<Vec<CssRuleType>>,
+            #[doc = "@starting-style CSS at-rule array.\nThe array enumerates @starting-style at-rules starting with the innermost one, going outwards."]
+            #[serde(rename = "startingStyles")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub starting_styles: Option<Vec<CssStartingStyle>>,
+        }
+        impl CssRule {
+            pub fn new(
+                selector_list: impl Into<SelectorList>,
+                origin: impl Into<StyleSheetOrigin>,
+                style: impl Into<CssStyle>,
+            ) -> Self {
+                Self {
+                    selector_list: selector_list.into(),
+                    origin: origin.into(),
+                    style: style.into(),
+                    style_sheet_id: None,
+                    nesting_selectors: None,
+                    origin_tree_scope_node_id: None,
+                    media: None,
+                    container_queries: None,
+                    supports: None,
+                    layers: None,
+                    scopes: None,
+                    rule_types: None,
+                    starting_styles: None,
+                }
+            }
+        }
+        impl CssRule {
+            pub fn builder() -> CssRuleBuilder {
+                CssRuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssRuleBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            selector_list: Option<SelectorList>,
+            nesting_selectors: Option<Vec<String>>,
+            origin: Option<StyleSheetOrigin>,
+            style: Option<CssStyle>,
+            origin_tree_scope_node_id: Option<super::dom::BackendNodeId>,
+            media: Option<Vec<CssMedia>>,
+            container_queries: Option<Vec<CssContainerQuery>>,
+            supports: Option<Vec<CssSupports>>,
+            layers: Option<Vec<CssLayer>>,
+            scopes: Option<Vec<CssScope>>,
+            rule_types: Option<Vec<CssRuleType>>,
+            starting_styles: Option<Vec<CssStartingStyle>>,
+        }
+        impl CssRuleBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn selector_list(mut self, selector_list: impl Into<SelectorList>) -> Self {
+                self.selector_list = Some(selector_list.into());
+                self
+            }
+            pub fn nesting_selector(mut self, nesting_selector: impl Into<String>) -> Self {
+                let v = self.nesting_selectors.get_or_insert(Vec::new());
+                v.push(nesting_selector.into());
+                self
+            }
+            pub fn nesting_selectors<I, S>(mut self, nesting_selectors: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.nesting_selectors.get_or_insert(Vec::new());
+                for val in nesting_selectors {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<StyleSheetOrigin>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn style(mut self, style: impl Into<CssStyle>) -> Self {
+                self.style = Some(style.into());
+                self
+            }
+            pub fn origin_tree_scope_node_id(
+                mut self,
+                origin_tree_scope_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.origin_tree_scope_node_id = Some(origin_tree_scope_node_id.into());
+                self
+            }
+            pub fn media(mut self, media: impl Into<CssMedia>) -> Self {
+                let v = self.media.get_or_insert(Vec::new());
+                v.push(media.into());
+                self
+            }
+            pub fn medias<I, S>(mut self, medias: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssMedia>,
+            {
+                let v = self.media.get_or_insert(Vec::new());
+                for val in medias {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn container_querie(
+                mut self,
+                container_querie: impl Into<CssContainerQuery>,
+            ) -> Self {
+                let v = self.container_queries.get_or_insert(Vec::new());
+                v.push(container_querie.into());
+                self
+            }
+            pub fn container_queries<I, S>(mut self, container_queries: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssContainerQuery>,
+            {
+                let v = self.container_queries.get_or_insert(Vec::new());
+                for val in container_queries {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn support(mut self, support: impl Into<CssSupports>) -> Self {
+                let v = self.supports.get_or_insert(Vec::new());
+                v.push(support.into());
+                self
+            }
+            pub fn supports<I, S>(mut self, supports: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssSupports>,
+            {
+                let v = self.supports.get_or_insert(Vec::new());
+                for val in supports {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn layer(mut self, layer: impl Into<CssLayer>) -> Self {
+                let v = self.layers.get_or_insert(Vec::new());
+                v.push(layer.into());
+                self
+            }
+            pub fn layers<I, S>(mut self, layers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssLayer>,
+            {
+                let v = self.layers.get_or_insert(Vec::new());
+                for val in layers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn scope(mut self, scope: impl Into<CssScope>) -> Self {
+                let v = self.scopes.get_or_insert(Vec::new());
+                v.push(scope.into());
+                self
+            }
+            pub fn scopes<I, S>(mut self, scopes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssScope>,
+            {
+                let v = self.scopes.get_or_insert(Vec::new());
+                for val in scopes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn rule_type(mut self, rule_type: impl Into<CssRuleType>) -> Self {
+                let v = self.rule_types.get_or_insert(Vec::new());
+                v.push(rule_type.into());
+                self
+            }
+            pub fn rule_types<I, S>(mut self, rule_types: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssRuleType>,
+            {
+                let v = self.rule_types.get_or_insert(Vec::new());
+                for val in rule_types {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn starting_style(mut self, starting_style: impl Into<CssStartingStyle>) -> Self {
+                let v = self.starting_styles.get_or_insert(Vec::new());
+                v.push(starting_style.into());
+                self
+            }
+            pub fn starting_styles<I, S>(mut self, starting_styles: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssStartingStyle>,
+            {
+                let v = self.starting_styles.get_or_insert(Vec::new());
+                for val in starting_styles {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<CssRule, String> {
+                Ok(CssRule {
+                    style_sheet_id: self.style_sheet_id,
+                    selector_list: self.selector_list.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(selector_list))
+                    })?,
+                    nesting_selectors: self.nesting_selectors,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    style: self.style.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style))
+                    })?,
+                    origin_tree_scope_node_id: self.origin_tree_scope_node_id,
+                    media: self.media,
+                    container_queries: self.container_queries,
+                    supports: self.supports,
+                    layers: self.layers,
+                    scopes: self.scopes,
+                    rule_types: self.rule_types,
+                    starting_styles: self.starting_styles,
+                })
+            }
+        }
+        impl CssRule {
+            pub const IDENTIFIER: &'static str = "CSS.CSSRule";
+        }
+        #[doc = "Enum indicating the type of a CSS rule, used to represent the order of a style rule's ancestors.\nThis list only contains rule types that are collected during the ancestor rule collection."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CssRuleType {
+            #[serde(rename = "MediaRule")]
+            MediaRule,
+            #[serde(rename = "SupportsRule")]
+            SupportsRule,
+            #[serde(rename = "ContainerRule")]
+            ContainerRule,
+            #[serde(rename = "LayerRule")]
+            LayerRule,
+            #[serde(rename = "ScopeRule")]
+            ScopeRule,
+            #[serde(rename = "StyleRule")]
+            StyleRule,
+            #[serde(rename = "StartingStyleRule")]
+            StartingStyleRule,
+        }
+        impl AsRef<str> for CssRuleType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CssRuleType::MediaRule => "MediaRule",
+                    CssRuleType::SupportsRule => "SupportsRule",
+                    CssRuleType::ContainerRule => "ContainerRule",
+                    CssRuleType::LayerRule => "LayerRule",
+                    CssRuleType::ScopeRule => "ScopeRule",
+                    CssRuleType::StyleRule => "StyleRule",
+                    CssRuleType::StartingStyleRule => "StartingStyleRule",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CssRuleType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "MediaRule" | "mediarule" => Ok(CssRuleType::MediaRule),
+                    "SupportsRule" | "supportsrule" => Ok(CssRuleType::SupportsRule),
+                    "ContainerRule" | "containerrule" => Ok(CssRuleType::ContainerRule),
+                    "LayerRule" | "layerrule" => Ok(CssRuleType::LayerRule),
+                    "ScopeRule" | "scoperule" => Ok(CssRuleType::ScopeRule),
+                    "StyleRule" | "stylerule" => Ok(CssRuleType::StyleRule),
+                    "StartingStyleRule" | "startingstylerule" => Ok(CssRuleType::StartingStyleRule),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "CSS coverage information.\n[RuleUsage](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-RuleUsage)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RuleUsage {
+            #[doc = "The css style sheet identifier (absent for user agent stylesheet and user-specified\nstylesheet rules) this rule came from."]
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[doc = "Offset of the start of the rule (including selector) from the beginning of the stylesheet."]
+            #[serde(rename = "startOffset")]
+            pub start_offset: f64,
+            #[doc = "Offset of the end of the rule body from the beginning of the stylesheet."]
+            #[serde(rename = "endOffset")]
+            pub end_offset: f64,
+            #[doc = "Indicates whether the rule was actually used by some element in the page."]
+            #[serde(rename = "used")]
+            pub used: bool,
+        }
+        impl RuleUsage {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                start_offset: impl Into<f64>,
+                end_offset: impl Into<f64>,
+                used: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    start_offset: start_offset.into(),
+                    end_offset: end_offset.into(),
+                    used: used.into(),
+                }
+            }
+        }
+        impl RuleUsage {
+            pub fn builder() -> RuleUsageBuilder {
+                RuleUsageBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RuleUsageBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            start_offset: Option<f64>,
+            end_offset: Option<f64>,
+            used: Option<bool>,
+        }
+        impl RuleUsageBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn start_offset(mut self, start_offset: impl Into<f64>) -> Self {
+                self.start_offset = Some(start_offset.into());
+                self
+            }
+            pub fn end_offset(mut self, end_offset: impl Into<f64>) -> Self {
+                self.end_offset = Some(end_offset.into());
+                self
+            }
+            pub fn used(mut self, used: impl Into<bool>) -> Self {
+                self.used = Some(used.into());
+                self
+            }
+            pub fn build(self) -> Result<RuleUsage, String> {
+                Ok(RuleUsage {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    start_offset: self.start_offset.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start_offset))
+                    })?,
+                    end_offset: self.end_offset.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(end_offset))
+                    })?,
+                    used: self.used.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(used))
+                    })?,
+                })
+            }
+        }
+        impl RuleUsage {
+            pub const IDENTIFIER: &'static str = "CSS.RuleUsage";
+        }
+        #[doc = "Text range within a resource. All numbers are zero-based.\n[SourceRange](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-SourceRange)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SourceRange {
+            #[doc = "Start line of range."]
+            #[serde(rename = "startLine")]
+            pub start_line: i64,
+            #[doc = "Start column of range (inclusive)."]
+            #[serde(rename = "startColumn")]
+            pub start_column: i64,
+            #[doc = "End line of range"]
+            #[serde(rename = "endLine")]
+            pub end_line: i64,
+            #[doc = "End column of range (exclusive)."]
+            #[serde(rename = "endColumn")]
+            pub end_column: i64,
+        }
+        impl SourceRange {
+            pub fn new(
+                start_line: impl Into<i64>,
+                start_column: impl Into<i64>,
+                end_line: impl Into<i64>,
+                end_column: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    start_line: start_line.into(),
+                    start_column: start_column.into(),
+                    end_line: end_line.into(),
+                    end_column: end_column.into(),
+                }
+            }
+        }
+        impl SourceRange {
+            pub fn builder() -> SourceRangeBuilder {
+                SourceRangeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SourceRangeBuilder {
+            start_line: Option<i64>,
+            start_column: Option<i64>,
+            end_line: Option<i64>,
+            end_column: Option<i64>,
+        }
+        impl SourceRangeBuilder {
+            pub fn start_line(mut self, start_line: impl Into<i64>) -> Self {
+                self.start_line = Some(start_line.into());
+                self
+            }
+            pub fn start_column(mut self, start_column: impl Into<i64>) -> Self {
+                self.start_column = Some(start_column.into());
+                self
+            }
+            pub fn end_line(mut self, end_line: impl Into<i64>) -> Self {
+                self.end_line = Some(end_line.into());
+                self
+            }
+            pub fn end_column(mut self, end_column: impl Into<i64>) -> Self {
+                self.end_column = Some(end_column.into());
+                self
+            }
+            pub fn build(self) -> Result<SourceRange, String> {
+                Ok(SourceRange {
+                    start_line: self.start_line.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start_line))
+                    })?,
+                    start_column: self.start_column.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start_column))
+                    })?,
+                    end_line: self.end_line.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(end_line))
+                    })?,
+                    end_column: self.end_column.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(end_column))
+                    })?,
+                })
+            }
+        }
+        impl SourceRange {
+            pub const IDENTIFIER: &'static str = "CSS.SourceRange";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ShorthandEntry {
+            #[doc = "Shorthand name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Shorthand value."]
+            #[serde(rename = "value")]
+            pub value: String,
+            #[doc = "Whether the property has \"!important\" annotation (implies `false` if absent)."]
+            #[serde(rename = "important")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub important: Option<bool>,
+        }
+        impl ShorthandEntry {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                    important: None,
+                }
+            }
+        }
+        impl ShorthandEntry {
+            pub fn builder() -> ShorthandEntryBuilder {
+                ShorthandEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ShorthandEntryBuilder {
+            name: Option<String>,
+            value: Option<String>,
+            important: Option<bool>,
+        }
+        impl ShorthandEntryBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn important(mut self, important: impl Into<bool>) -> Self {
+                self.important = Some(important.into());
+                self
+            }
+            pub fn build(self) -> Result<ShorthandEntry, String> {
+                Ok(ShorthandEntry {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    important: self.important,
+                })
+            }
+        }
+        impl ShorthandEntry {
+            pub const IDENTIFIER: &'static str = "CSS.ShorthandEntry";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssComputedStyleProperty {
+            #[doc = "Computed style property name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Computed style property value."]
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl CssComputedStyleProperty {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl CssComputedStyleProperty {
+            pub fn builder() -> CssComputedStylePropertyBuilder {
+                CssComputedStylePropertyBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssComputedStylePropertyBuilder {
+            name: Option<String>,
+            value: Option<String>,
+        }
+        impl CssComputedStylePropertyBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<CssComputedStyleProperty, String> {
+                Ok(CssComputedStyleProperty {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl CssComputedStyleProperty {
+            pub const IDENTIFIER: &'static str = "CSS.CSSComputedStyleProperty";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ComputedStyleExtraFields {
+            #[doc = "Returns whether or not this node is being rendered with base appearance,\nwhich happens when it has its appearance property set to base/base-select\nor it is in the subtree of an element being rendered with base appearance."]
+            #[serde(rename = "isAppearanceBase")]
+            pub is_appearance_base: bool,
+        }
+        impl ComputedStyleExtraFields {
+            pub fn new(is_appearance_base: impl Into<bool>) -> Self {
+                Self {
+                    is_appearance_base: is_appearance_base.into(),
+                }
+            }
+        }
+        impl ComputedStyleExtraFields {
+            pub fn builder() -> ComputedStyleExtraFieldsBuilder {
+                ComputedStyleExtraFieldsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ComputedStyleExtraFieldsBuilder {
+            is_appearance_base: Option<bool>,
+        }
+        impl ComputedStyleExtraFieldsBuilder {
+            pub fn is_appearance_base(mut self, is_appearance_base: impl Into<bool>) -> Self {
+                self.is_appearance_base = Some(is_appearance_base.into());
+                self
+            }
+            pub fn build(self) -> Result<ComputedStyleExtraFields, String> {
+                Ok(ComputedStyleExtraFields {
+                    is_appearance_base: self.is_appearance_base.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(is_appearance_base)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl ComputedStyleExtraFields {
+            pub const IDENTIFIER: &'static str = "CSS.ComputedStyleExtraFields";
+        }
+        #[doc = "CSS style representation.\n[CSSStyle](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSStyle)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssStyle {
+            #[doc = "The css style sheet identifier (absent for user agent stylesheet and user-specified\nstylesheet rules) this rule came from."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+            #[doc = "CSS properties in the style."]
+            #[serde(rename = "cssProperties")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub css_properties: Vec<CssProperty>,
+            #[doc = "Computed values for all shorthands found in the style."]
+            #[serde(rename = "shorthandEntries")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub shorthand_entries: Vec<ShorthandEntry>,
+            #[doc = "Style declaration text (if available)."]
+            #[serde(rename = "cssText")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub css_text: Option<String>,
+            #[doc = "Style declaration range in the enclosing stylesheet (if available)."]
+            #[serde(rename = "range")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub range: Option<SourceRange>,
+        }
+        impl CssStyle {
+            pub fn new(
+                css_properties: Vec<CssProperty>,
+                shorthand_entries: Vec<ShorthandEntry>,
+            ) -> Self {
+                Self {
+                    css_properties,
+                    shorthand_entries,
+                    style_sheet_id: None,
+                    css_text: None,
+                    range: None,
+                }
+            }
+        }
+        impl CssStyle {
+            pub fn builder() -> CssStyleBuilder {
+                CssStyleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssStyleBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            css_properties: Option<Vec<CssProperty>>,
+            shorthand_entries: Option<Vec<ShorthandEntry>>,
+            css_text: Option<String>,
+            range: Option<SourceRange>,
+        }
+        impl CssStyleBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn css_propertie(mut self, css_propertie: impl Into<CssProperty>) -> Self {
+                let v = self.css_properties.get_or_insert(Vec::new());
+                v.push(css_propertie.into());
+                self
+            }
+            pub fn css_properties<I, S>(mut self, css_properties: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssProperty>,
+            {
+                let v = self.css_properties.get_or_insert(Vec::new());
+                for val in css_properties {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn shorthand_entrie(mut self, shorthand_entrie: impl Into<ShorthandEntry>) -> Self {
+                let v = self.shorthand_entries.get_or_insert(Vec::new());
+                v.push(shorthand_entrie.into());
+                self
+            }
+            pub fn shorthand_entries<I, S>(mut self, shorthand_entries: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ShorthandEntry>,
+            {
+                let v = self.shorthand_entries.get_or_insert(Vec::new());
+                for val in shorthand_entries {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn css_text(mut self, css_text: impl Into<String>) -> Self {
+                self.css_text = Some(css_text.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn build(self) -> Result<CssStyle, String> {
+                Ok(CssStyle {
+                    style_sheet_id: self.style_sheet_id,
+                    css_properties: self.css_properties.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(css_properties))
+                    })?,
+                    shorthand_entries: self.shorthand_entries.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(shorthand_entries)
+                        )
+                    })?,
+                    css_text: self.css_text,
+                    range: self.range,
+                })
+            }
+        }
+        impl CssStyle {
+            pub const IDENTIFIER: &'static str = "CSS.CSSStyle";
+        }
+        #[doc = "CSS property declaration data.\n[CSSProperty](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSProperty)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssProperty {
+            #[doc = "The property name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "The property value."]
+            #[serde(rename = "value")]
+            pub value: String,
+            #[doc = "Whether the property has \"!important\" annotation (implies `false` if absent)."]
+            #[serde(rename = "important")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub important: Option<bool>,
+            #[doc = "Whether the property is implicit (implies `false` if absent)."]
+            #[serde(rename = "implicit")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub implicit: Option<bool>,
+            #[doc = "The full property text as specified in the style."]
+            #[serde(rename = "text")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub text: Option<String>,
+            #[doc = "Whether the property is understood by the browser (implies `true` if absent)."]
+            #[serde(rename = "parsedOk")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parsed_ok: Option<bool>,
+            #[doc = "Whether the property is disabled by the user (present for source-based properties only)."]
+            #[serde(rename = "disabled")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub disabled: Option<bool>,
+            #[doc = "The entire property range in the enclosing style declaration (if available)."]
+            #[serde(rename = "range")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub range: Option<SourceRange>,
+            #[doc = "Parsed longhand components of this property if it is a shorthand.\nThis field will be empty if the given property is not a shorthand."]
+            #[serde(rename = "longhandProperties")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub longhand_properties: Option<Vec<CssProperty>>,
+        }
+        impl CssProperty {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                    important: None,
+                    implicit: None,
+                    text: None,
+                    parsed_ok: None,
+                    disabled: None,
+                    range: None,
+                    longhand_properties: None,
+                }
+            }
+        }
+        impl CssProperty {
+            pub fn builder() -> CssPropertyBuilder {
+                CssPropertyBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssPropertyBuilder {
+            name: Option<String>,
+            value: Option<String>,
+            important: Option<bool>,
+            implicit: Option<bool>,
+            text: Option<String>,
+            parsed_ok: Option<bool>,
+            disabled: Option<bool>,
+            range: Option<SourceRange>,
+            longhand_properties: Option<Vec<CssProperty>>,
+        }
+        impl CssPropertyBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn important(mut self, important: impl Into<bool>) -> Self {
+                self.important = Some(important.into());
+                self
+            }
+            pub fn implicit(mut self, implicit: impl Into<bool>) -> Self {
+                self.implicit = Some(implicit.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn parsed_ok(mut self, parsed_ok: impl Into<bool>) -> Self {
+                self.parsed_ok = Some(parsed_ok.into());
+                self
+            }
+            pub fn disabled(mut self, disabled: impl Into<bool>) -> Self {
+                self.disabled = Some(disabled.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn longhand_propertie(
+                mut self,
+                longhand_propertie: impl Into<CssProperty>,
+            ) -> Self {
+                let v = self.longhand_properties.get_or_insert(Vec::new());
+                v.push(longhand_propertie.into());
+                self
+            }
+            pub fn longhand_properties<I, S>(mut self, longhand_properties: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssProperty>,
+            {
+                let v = self.longhand_properties.get_or_insert(Vec::new());
+                for val in longhand_properties {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<CssProperty, String> {
+                Ok(CssProperty {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    important: self.important,
+                    implicit: self.implicit,
+                    text: self.text,
+                    parsed_ok: self.parsed_ok,
+                    disabled: self.disabled,
+                    range: self.range,
+                    longhand_properties: self.longhand_properties,
+                })
+            }
+        }
+        impl CssProperty {
+            pub const IDENTIFIER: &'static str = "CSS.CSSProperty";
+        }
+        #[doc = "CSS media rule descriptor.\n[CSSMedia](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSMedia)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssMedia {
+            #[doc = "Media query text."]
+            #[serde(rename = "text")]
+            pub text: String,
+            #[doc = "Source of the media query: \"mediaRule\" if specified by a @media rule, \"importRule\" if\nspecified by an @import rule, \"linkedSheet\" if specified by a \"media\" attribute in a linked\nstylesheet's LINK tag, \"inlineSheet\" if specified by a \"media\" attribute in an inline\nstylesheet's STYLE tag."]
+            #[serde(rename = "source")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub source: CssMediaSource,
+            #[doc = "URL of the document containing the media query description."]
+            #[serde(rename = "sourceURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_url: Option<String>,
+            #[doc = "The associated rule (@media or @import) header range in the enclosing stylesheet (if\navailable)."]
+            #[serde(rename = "range")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub range: Option<SourceRange>,
+            #[doc = "Identifier of the stylesheet containing this object (if exists)."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+            #[doc = "Array of media queries."]
+            #[serde(rename = "mediaList")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub media_list: Option<Vec<MediaQuery>>,
+        }
+        #[doc = "Source of the media query: \"mediaRule\" if specified by a @media rule, \"importRule\" if\nspecified by an @import rule, \"linkedSheet\" if specified by a \"media\" attribute in a linked\nstylesheet's LINK tag, \"inlineSheet\" if specified by a \"media\" attribute in an inline\nstylesheet's STYLE tag."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CssMediaSource {
+            #[serde(rename = "mediaRule")]
+            MediaRule,
+            #[serde(rename = "importRule")]
+            ImportRule,
+            #[serde(rename = "linkedSheet")]
+            LinkedSheet,
+            #[serde(rename = "inlineSheet")]
+            InlineSheet,
+        }
+        impl AsRef<str> for CssMediaSource {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CssMediaSource::MediaRule => "mediaRule",
+                    CssMediaSource::ImportRule => "importRule",
+                    CssMediaSource::LinkedSheet => "linkedSheet",
+                    CssMediaSource::InlineSheet => "inlineSheet",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CssMediaSource {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "mediaRule" | "MediaRule" | "mediarule" => Ok(CssMediaSource::MediaRule),
+                    "importRule" | "ImportRule" | "importrule" => Ok(CssMediaSource::ImportRule),
+                    "linkedSheet" | "LinkedSheet" | "linkedsheet" => {
+                        Ok(CssMediaSource::LinkedSheet)
+                    }
+                    "inlineSheet" | "InlineSheet" | "inlinesheet" => {
+                        Ok(CssMediaSource::InlineSheet)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl CssMedia {
+            pub fn new(text: impl Into<String>, source: impl Into<CssMediaSource>) -> Self {
+                Self {
+                    text: text.into(),
+                    source: source.into(),
+                    source_url: None,
+                    range: None,
+                    style_sheet_id: None,
+                    media_list: None,
+                }
+            }
+        }
+        impl CssMedia {
+            pub fn builder() -> CssMediaBuilder {
+                CssMediaBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssMediaBuilder {
+            text: Option<String>,
+            source: Option<CssMediaSource>,
+            source_url: Option<String>,
+            range: Option<SourceRange>,
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            media_list: Option<Vec<MediaQuery>>,
+        }
+        impl CssMediaBuilder {
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn source(mut self, source: impl Into<CssMediaSource>) -> Self {
+                self.source = Some(source.into());
+                self
+            }
+            pub fn source_url(mut self, source_url: impl Into<String>) -> Self {
+                self.source_url = Some(source_url.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn media_list(mut self, media_list: impl Into<MediaQuery>) -> Self {
+                let v = self.media_list.get_or_insert(Vec::new());
+                v.push(media_list.into());
+                self
+            }
+            pub fn media_lists<I, S>(mut self, media_lists: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<MediaQuery>,
+            {
+                let v = self.media_list.get_or_insert(Vec::new());
+                for val in media_lists {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<CssMedia, String> {
+                Ok(CssMedia {
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    source: self.source.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source))
+                    })?,
+                    source_url: self.source_url,
+                    range: self.range,
+                    style_sheet_id: self.style_sheet_id,
+                    media_list: self.media_list,
+                })
+            }
+        }
+        impl CssMedia {
+            pub const IDENTIFIER: &'static str = "CSS.CSSMedia";
+        }
+        #[doc = "Media query descriptor.\n[MediaQuery](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-MediaQuery)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct MediaQuery {
+            #[doc = "Array of media query expressions."]
+            #[serde(rename = "expressions")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub expressions: Vec<MediaQueryExpression>,
+            #[doc = "Whether the media query condition is satisfied."]
+            #[serde(rename = "active")]
+            pub active: bool,
+        }
+        impl MediaQuery {
+            pub fn new(expressions: Vec<MediaQueryExpression>, active: impl Into<bool>) -> Self {
+                Self {
+                    expressions,
+                    active: active.into(),
+                }
+            }
+        }
+        impl MediaQuery {
+            pub fn builder() -> MediaQueryBuilder {
+                MediaQueryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct MediaQueryBuilder {
+            expressions: Option<Vec<MediaQueryExpression>>,
+            active: Option<bool>,
+        }
+        impl MediaQueryBuilder {
+            pub fn expression(mut self, expression: impl Into<MediaQueryExpression>) -> Self {
+                let v = self.expressions.get_or_insert(Vec::new());
+                v.push(expression.into());
+                self
+            }
+            pub fn expressions<I, S>(mut self, expressions: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<MediaQueryExpression>,
+            {
+                let v = self.expressions.get_or_insert(Vec::new());
+                for val in expressions {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn active(mut self, active: impl Into<bool>) -> Self {
+                self.active = Some(active.into());
+                self
+            }
+            pub fn build(self) -> Result<MediaQuery, String> {
+                Ok(MediaQuery {
+                    expressions: self.expressions.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expressions))
+                    })?,
+                    active: self.active.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(active))
+                    })?,
+                })
+            }
+        }
+        impl MediaQuery {
+            pub const IDENTIFIER: &'static str = "CSS.MediaQuery";
+        }
+        #[doc = "Media query expression descriptor.\n[MediaQueryExpression](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-MediaQueryExpression)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct MediaQueryExpression {
+            #[doc = "Media query expression value."]
+            #[serde(rename = "value")]
+            pub value: f64,
+            #[doc = "Media query expression units."]
+            #[serde(rename = "unit")]
+            pub unit: String,
+            #[doc = "Media query expression feature."]
+            #[serde(rename = "feature")]
+            pub feature: String,
+            #[doc = "The associated range of the value text in the enclosing stylesheet (if available)."]
+            #[serde(rename = "valueRange")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value_range: Option<SourceRange>,
+            #[doc = "Computed length of media query expression (if applicable)."]
+            #[serde(rename = "computedLength")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub computed_length: Option<f64>,
+        }
+        impl MediaQueryExpression {
+            pub fn new(
+                value: impl Into<f64>,
+                unit: impl Into<String>,
+                feature: impl Into<String>,
+            ) -> Self {
+                Self {
+                    value: value.into(),
+                    unit: unit.into(),
+                    feature: feature.into(),
+                    value_range: None,
+                    computed_length: None,
+                }
+            }
+        }
+        impl MediaQueryExpression {
+            pub fn builder() -> MediaQueryExpressionBuilder {
+                MediaQueryExpressionBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct MediaQueryExpressionBuilder {
+            value: Option<f64>,
+            unit: Option<String>,
+            feature: Option<String>,
+            value_range: Option<SourceRange>,
+            computed_length: Option<f64>,
+        }
+        impl MediaQueryExpressionBuilder {
+            pub fn value(mut self, value: impl Into<f64>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn unit(mut self, unit: impl Into<String>) -> Self {
+                self.unit = Some(unit.into());
+                self
+            }
+            pub fn feature(mut self, feature: impl Into<String>) -> Self {
+                self.feature = Some(feature.into());
+                self
+            }
+            pub fn value_range(mut self, value_range: impl Into<SourceRange>) -> Self {
+                self.value_range = Some(value_range.into());
+                self
+            }
+            pub fn computed_length(mut self, computed_length: impl Into<f64>) -> Self {
+                self.computed_length = Some(computed_length.into());
+                self
+            }
+            pub fn build(self) -> Result<MediaQueryExpression, String> {
+                Ok(MediaQueryExpression {
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    unit: self.unit.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(unit))
+                    })?,
+                    feature: self.feature.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(feature))
+                    })?,
+                    value_range: self.value_range,
+                    computed_length: self.computed_length,
+                })
+            }
+        }
+        impl MediaQueryExpression {
+            pub const IDENTIFIER: &'static str = "CSS.MediaQueryExpression";
+        }
+        #[doc = "CSS container query rule descriptor.\n[CSSContainerQuery](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSContainerQuery)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssContainerQuery {
+            #[doc = "Container query text."]
+            #[serde(rename = "text")]
+            pub text: String,
+            #[doc = "The associated rule header range in the enclosing stylesheet (if\navailable)."]
+            #[serde(rename = "range")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub range: Option<SourceRange>,
+            #[doc = "Identifier of the stylesheet containing this object (if exists)."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+            #[doc = "Optional name for the container."]
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[doc = "Optional physical axes queried for the container."]
+            #[serde(rename = "physicalAxes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub physical_axes: Option<super::dom::PhysicalAxes>,
+            #[doc = "Optional logical axes queried for the container."]
+            #[serde(rename = "logicalAxes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub logical_axes: Option<super::dom::LogicalAxes>,
+            #[doc = "true if the query contains scroll-state() queries."]
+            #[serde(rename = "queriesScrollState")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub queries_scroll_state: Option<bool>,
+            #[doc = "true if the query contains anchored() queries."]
+            #[serde(rename = "queriesAnchored")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub queries_anchored: Option<bool>,
+        }
+        impl CssContainerQuery {
+            pub fn new(text: impl Into<String>) -> Self {
+                Self {
+                    text: text.into(),
+                    range: None,
+                    style_sheet_id: None,
+                    name: None,
+                    physical_axes: None,
+                    logical_axes: None,
+                    queries_scroll_state: None,
+                    queries_anchored: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for CssContainerQuery {
+            fn from(url: T) -> Self {
+                CssContainerQuery::new(url)
+            }
+        }
+        impl CssContainerQuery {
+            pub fn builder() -> CssContainerQueryBuilder {
+                CssContainerQueryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssContainerQueryBuilder {
+            text: Option<String>,
+            range: Option<SourceRange>,
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            name: Option<String>,
+            physical_axes: Option<super::dom::PhysicalAxes>,
+            logical_axes: Option<super::dom::LogicalAxes>,
+            queries_scroll_state: Option<bool>,
+            queries_anchored: Option<bool>,
+        }
+        impl CssContainerQueryBuilder {
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn physical_axes(
+                mut self,
+                physical_axes: impl Into<super::dom::PhysicalAxes>,
+            ) -> Self {
+                self.physical_axes = Some(physical_axes.into());
+                self
+            }
+            pub fn logical_axes(
+                mut self,
+                logical_axes: impl Into<super::dom::LogicalAxes>,
+            ) -> Self {
+                self.logical_axes = Some(logical_axes.into());
+                self
+            }
+            pub fn queries_scroll_state(mut self, queries_scroll_state: impl Into<bool>) -> Self {
+                self.queries_scroll_state = Some(queries_scroll_state.into());
+                self
+            }
+            pub fn queries_anchored(mut self, queries_anchored: impl Into<bool>) -> Self {
+                self.queries_anchored = Some(queries_anchored.into());
+                self
+            }
+            pub fn build(self) -> Result<CssContainerQuery, String> {
+                Ok(CssContainerQuery {
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    range: self.range,
+                    style_sheet_id: self.style_sheet_id,
+                    name: self.name,
+                    physical_axes: self.physical_axes,
+                    logical_axes: self.logical_axes,
+                    queries_scroll_state: self.queries_scroll_state,
+                    queries_anchored: self.queries_anchored,
+                })
+            }
+        }
+        impl CssContainerQuery {
+            pub const IDENTIFIER: &'static str = "CSS.CSSContainerQuery";
+        }
+        #[doc = "CSS Supports at-rule descriptor.\n[CSSSupports](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSSupports)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssSupports {
+            #[doc = "Supports rule text."]
+            #[serde(rename = "text")]
+            pub text: String,
+            #[doc = "Whether the supports condition is satisfied."]
+            #[serde(rename = "active")]
+            pub active: bool,
+            #[doc = "The associated rule header range in the enclosing stylesheet (if\navailable)."]
+            #[serde(rename = "range")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub range: Option<SourceRange>,
+            #[doc = "Identifier of the stylesheet containing this object (if exists)."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl CssSupports {
+            pub fn new(text: impl Into<String>, active: impl Into<bool>) -> Self {
+                Self {
+                    text: text.into(),
+                    active: active.into(),
+                    range: None,
+                    style_sheet_id: None,
+                }
+            }
+        }
+        impl CssSupports {
+            pub fn builder() -> CssSupportsBuilder {
+                CssSupportsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssSupportsBuilder {
+            text: Option<String>,
+            active: Option<bool>,
+            range: Option<SourceRange>,
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl CssSupportsBuilder {
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn active(mut self, active: impl Into<bool>) -> Self {
+                self.active = Some(active.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CssSupports, String> {
+                Ok(CssSupports {
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    active: self.active.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(active))
+                    })?,
+                    range: self.range,
+                    style_sheet_id: self.style_sheet_id,
+                })
+            }
+        }
+        impl CssSupports {
+            pub const IDENTIFIER: &'static str = "CSS.CSSSupports";
+        }
+        #[doc = "CSS Scope at-rule descriptor.\n[CSSScope](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSScope)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssScope {
+            #[doc = "Scope rule text."]
+            #[serde(rename = "text")]
+            pub text: String,
+            #[doc = "The associated rule header range in the enclosing stylesheet (if\navailable)."]
+            #[serde(rename = "range")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub range: Option<SourceRange>,
+            #[doc = "Identifier of the stylesheet containing this object (if exists)."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl CssScope {
+            pub fn new(text: impl Into<String>) -> Self {
+                Self {
+                    text: text.into(),
+                    range: None,
+                    style_sheet_id: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for CssScope {
+            fn from(url: T) -> Self {
+                CssScope::new(url)
+            }
+        }
+        impl CssScope {
+            pub fn builder() -> CssScopeBuilder {
+                CssScopeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssScopeBuilder {
+            text: Option<String>,
+            range: Option<SourceRange>,
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl CssScopeBuilder {
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CssScope, String> {
+                Ok(CssScope {
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    range: self.range,
+                    style_sheet_id: self.style_sheet_id,
+                })
+            }
+        }
+        impl CssScope {
+            pub const IDENTIFIER: &'static str = "CSS.CSSScope";
+        }
+        #[doc = "CSS Layer at-rule descriptor.\n[CSSLayer](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSLayer)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssLayer {
+            #[doc = "Layer name."]
+            #[serde(rename = "text")]
+            pub text: String,
+            #[doc = "The associated rule header range in the enclosing stylesheet (if\navailable)."]
+            #[serde(rename = "range")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub range: Option<SourceRange>,
+            #[doc = "Identifier of the stylesheet containing this object (if exists)."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl CssLayer {
+            pub fn new(text: impl Into<String>) -> Self {
+                Self {
+                    text: text.into(),
+                    range: None,
+                    style_sheet_id: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for CssLayer {
+            fn from(url: T) -> Self {
+                CssLayer::new(url)
+            }
+        }
+        impl CssLayer {
+            pub fn builder() -> CssLayerBuilder {
+                CssLayerBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssLayerBuilder {
+            text: Option<String>,
+            range: Option<SourceRange>,
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl CssLayerBuilder {
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CssLayer, String> {
+                Ok(CssLayer {
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    range: self.range,
+                    style_sheet_id: self.style_sheet_id,
+                })
+            }
+        }
+        impl CssLayer {
+            pub const IDENTIFIER: &'static str = "CSS.CSSLayer";
+        }
+        #[doc = "CSS Starting Style at-rule descriptor.\n[CSSStartingStyle](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSStartingStyle)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CssStartingStyle {
+            #[doc = "The associated rule header range in the enclosing stylesheet (if\navailable)."]
+            #[serde(rename = "range")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub range: Option<SourceRange>,
+            #[doc = "Identifier of the stylesheet containing this object (if exists)."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl CssStartingStyle {
+            pub fn builder() -> CssStartingStyleBuilder {
+                CssStartingStyleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssStartingStyleBuilder {
+            range: Option<SourceRange>,
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl CssStartingStyleBuilder {
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn build(self) -> CssStartingStyle {
+                CssStartingStyle {
+                    range: self.range,
+                    style_sheet_id: self.style_sheet_id,
+                }
+            }
+        }
+        impl CssStartingStyle {
+            pub const IDENTIFIER: &'static str = "CSS.CSSStartingStyle";
+        }
+        #[doc = "CSS Layer data.\n[CSSLayerData](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSLayerData)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssLayerData {
+            #[doc = "Layer name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Direct sub-layers"]
+            #[serde(rename = "subLayers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub sub_layers: Option<Vec<CssLayerData>>,
+            #[doc = "Layer order. The order determines the order of the layer in the cascade order.\nA higher number has higher priority in the cascade order."]
+            #[serde(rename = "order")]
+            pub order: f64,
+        }
+        impl CssLayerData {
+            pub fn new(name: impl Into<String>, order: impl Into<f64>) -> Self {
+                Self {
+                    name: name.into(),
+                    order: order.into(),
+                    sub_layers: None,
+                }
+            }
+        }
+        impl CssLayerData {
+            pub fn builder() -> CssLayerDataBuilder {
+                CssLayerDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssLayerDataBuilder {
+            name: Option<String>,
+            sub_layers: Option<Vec<CssLayerData>>,
+            order: Option<f64>,
+        }
+        impl CssLayerDataBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn sub_layer(mut self, sub_layer: impl Into<CssLayerData>) -> Self {
+                let v = self.sub_layers.get_or_insert(Vec::new());
+                v.push(sub_layer.into());
+                self
+            }
+            pub fn sub_layers<I, S>(mut self, sub_layers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssLayerData>,
+            {
+                let v = self.sub_layers.get_or_insert(Vec::new());
+                for val in sub_layers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn order(mut self, order: impl Into<f64>) -> Self {
+                self.order = Some(order.into());
+                self
+            }
+            pub fn build(self) -> Result<CssLayerData, String> {
+                Ok(CssLayerData {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    sub_layers: self.sub_layers,
+                    order: self.order.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(order))
+                    })?,
+                })
+            }
+        }
+        impl CssLayerData {
+            pub const IDENTIFIER: &'static str = "CSS.CSSLayerData";
+        }
+        #[doc = "Information about amount of glyphs that were rendered with given font.\n[PlatformFontUsage](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-PlatformFontUsage)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PlatformFontUsage {
+            #[doc = "Font's family name reported by platform."]
+            #[serde(rename = "familyName")]
+            pub family_name: String,
+            #[doc = "Font's PostScript name reported by platform."]
+            #[serde(rename = "postScriptName")]
+            pub post_script_name: String,
+            #[doc = "Indicates if the font was downloaded or resolved locally."]
+            #[serde(rename = "isCustomFont")]
+            pub is_custom_font: bool,
+            #[doc = "Amount of glyphs that were rendered with this font."]
+            #[serde(rename = "glyphCount")]
+            pub glyph_count: f64,
+        }
+        impl PlatformFontUsage {
+            pub fn new(
+                family_name: impl Into<String>,
+                post_script_name: impl Into<String>,
+                is_custom_font: impl Into<bool>,
+                glyph_count: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    family_name: family_name.into(),
+                    post_script_name: post_script_name.into(),
+                    is_custom_font: is_custom_font.into(),
+                    glyph_count: glyph_count.into(),
+                }
+            }
+        }
+        impl PlatformFontUsage {
+            pub fn builder() -> PlatformFontUsageBuilder {
+                PlatformFontUsageBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PlatformFontUsageBuilder {
+            family_name: Option<String>,
+            post_script_name: Option<String>,
+            is_custom_font: Option<bool>,
+            glyph_count: Option<f64>,
+        }
+        impl PlatformFontUsageBuilder {
+            pub fn family_name(mut self, family_name: impl Into<String>) -> Self {
+                self.family_name = Some(family_name.into());
+                self
+            }
+            pub fn post_script_name(mut self, post_script_name: impl Into<String>) -> Self {
+                self.post_script_name = Some(post_script_name.into());
+                self
+            }
+            pub fn is_custom_font(mut self, is_custom_font: impl Into<bool>) -> Self {
+                self.is_custom_font = Some(is_custom_font.into());
+                self
+            }
+            pub fn glyph_count(mut self, glyph_count: impl Into<f64>) -> Self {
+                self.glyph_count = Some(glyph_count.into());
+                self
+            }
+            pub fn build(self) -> Result<PlatformFontUsage, String> {
+                Ok(PlatformFontUsage {
+                    family_name: self.family_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(family_name))
+                    })?,
+                    post_script_name: self.post_script_name.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(post_script_name)
+                        )
+                    })?,
+                    is_custom_font: self.is_custom_font.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_custom_font))
+                    })?,
+                    glyph_count: self.glyph_count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(glyph_count))
+                    })?,
+                })
+            }
+        }
+        impl PlatformFontUsage {
+            pub const IDENTIFIER: &'static str = "CSS.PlatformFontUsage";
+        }
+        #[doc = "Information about font variation axes for variable fonts\n[FontVariationAxis](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-FontVariationAxis)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FontVariationAxis {
+            #[doc = "The font-variation-setting tag (a.k.a. \"axis tag\")."]
+            #[serde(rename = "tag")]
+            pub tag: String,
+            #[doc = "Human-readable variation name in the default language (normally, \"en\")."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "The minimum value (inclusive) the font supports for this tag."]
+            #[serde(rename = "minValue")]
+            pub min_value: f64,
+            #[doc = "The maximum value (inclusive) the font supports for this tag."]
+            #[serde(rename = "maxValue")]
+            pub max_value: f64,
+            #[doc = "The default value."]
+            #[serde(rename = "defaultValue")]
+            pub default_value: f64,
+        }
+        impl FontVariationAxis {
+            pub fn builder() -> FontVariationAxisBuilder {
+                FontVariationAxisBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FontVariationAxisBuilder {
+            tag: Option<String>,
+            name: Option<String>,
+            min_value: Option<f64>,
+            max_value: Option<f64>,
+            default_value: Option<f64>,
+        }
+        impl FontVariationAxisBuilder {
+            pub fn tag(mut self, tag: impl Into<String>) -> Self {
+                self.tag = Some(tag.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn min_value(mut self, min_value: impl Into<f64>) -> Self {
+                self.min_value = Some(min_value.into());
+                self
+            }
+            pub fn max_value(mut self, max_value: impl Into<f64>) -> Self {
+                self.max_value = Some(max_value.into());
+                self
+            }
+            pub fn default_value(mut self, default_value: impl Into<f64>) -> Self {
+                self.default_value = Some(default_value.into());
+                self
+            }
+            pub fn build(self) -> Result<FontVariationAxis, String> {
+                Ok(FontVariationAxis {
+                    tag: self
+                        .tag
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(tag)))?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    min_value: self.min_value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(min_value))
+                    })?,
+                    max_value: self.max_value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(max_value))
+                    })?,
+                    default_value: self.default_value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(default_value))
+                    })?,
+                })
+            }
+        }
+        impl FontVariationAxis {
+            pub const IDENTIFIER: &'static str = "CSS.FontVariationAxis";
+        }
+        #[doc = "Properties of a web font: https://www.w3.org/TR/2008/REC-CSS2-20080411/fonts.html#font-descriptions\nand additional information such as platformFontFamily and fontVariationAxes.\n[FontFace](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-FontFace)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FontFace {
+            #[doc = "The font-family."]
+            #[serde(rename = "fontFamily")]
+            pub font_family: String,
+            #[doc = "The font-style."]
+            #[serde(rename = "fontStyle")]
+            pub font_style: String,
+            #[doc = "The font-variant."]
+            #[serde(rename = "fontVariant")]
+            pub font_variant: String,
+            #[doc = "The font-weight."]
+            #[serde(rename = "fontWeight")]
+            pub font_weight: String,
+            #[doc = "The font-stretch."]
+            #[serde(rename = "fontStretch")]
+            pub font_stretch: String,
+            #[doc = "The font-display."]
+            #[serde(rename = "fontDisplay")]
+            pub font_display: String,
+            #[doc = "The unicode-range."]
+            #[serde(rename = "unicodeRange")]
+            pub unicode_range: String,
+            #[doc = "The src."]
+            #[serde(rename = "src")]
+            pub src: String,
+            #[doc = "The resolved platform font family"]
+            #[serde(rename = "platformFontFamily")]
+            pub platform_font_family: String,
+            #[doc = "Available variation settings (a.k.a. \"axes\")."]
+            #[serde(rename = "fontVariationAxes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub font_variation_axes: Option<Vec<FontVariationAxis>>,
+        }
+        impl FontFace {
+            pub fn builder() -> FontFaceBuilder {
+                FontFaceBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FontFaceBuilder {
+            font_family: Option<String>,
+            font_style: Option<String>,
+            font_variant: Option<String>,
+            font_weight: Option<String>,
+            font_stretch: Option<String>,
+            font_display: Option<String>,
+            unicode_range: Option<String>,
+            src: Option<String>,
+            platform_font_family: Option<String>,
+            font_variation_axes: Option<Vec<FontVariationAxis>>,
+        }
+        impl FontFaceBuilder {
+            pub fn font_family(mut self, font_family: impl Into<String>) -> Self {
+                self.font_family = Some(font_family.into());
+                self
+            }
+            pub fn font_style(mut self, font_style: impl Into<String>) -> Self {
+                self.font_style = Some(font_style.into());
+                self
+            }
+            pub fn font_variant(mut self, font_variant: impl Into<String>) -> Self {
+                self.font_variant = Some(font_variant.into());
+                self
+            }
+            pub fn font_weight(mut self, font_weight: impl Into<String>) -> Self {
+                self.font_weight = Some(font_weight.into());
+                self
+            }
+            pub fn font_stretch(mut self, font_stretch: impl Into<String>) -> Self {
+                self.font_stretch = Some(font_stretch.into());
+                self
+            }
+            pub fn font_display(mut self, font_display: impl Into<String>) -> Self {
+                self.font_display = Some(font_display.into());
+                self
+            }
+            pub fn unicode_range(mut self, unicode_range: impl Into<String>) -> Self {
+                self.unicode_range = Some(unicode_range.into());
+                self
+            }
+            pub fn src(mut self, src: impl Into<String>) -> Self {
+                self.src = Some(src.into());
+                self
+            }
+            pub fn platform_font_family(mut self, platform_font_family: impl Into<String>) -> Self {
+                self.platform_font_family = Some(platform_font_family.into());
+                self
+            }
+            pub fn font_variation_axe(
+                mut self,
+                font_variation_axe: impl Into<FontVariationAxis>,
+            ) -> Self {
+                let v = self.font_variation_axes.get_or_insert(Vec::new());
+                v.push(font_variation_axe.into());
+                self
+            }
+            pub fn font_variation_axes<I, S>(mut self, font_variation_axes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FontVariationAxis>,
+            {
+                let v = self.font_variation_axes.get_or_insert(Vec::new());
+                for val in font_variation_axes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<FontFace, String> {
+                Ok(FontFace {
+                    font_family: self.font_family.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_family))
+                    })?,
+                    font_style: self.font_style.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_style))
+                    })?,
+                    font_variant: self.font_variant.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_variant))
+                    })?,
+                    font_weight: self.font_weight.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_weight))
+                    })?,
+                    font_stretch: self.font_stretch.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_stretch))
+                    })?,
+                    font_display: self.font_display.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_display))
+                    })?,
+                    unicode_range: self.unicode_range.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(unicode_range))
+                    })?,
+                    src: self
+                        .src
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(src)))?,
+                    platform_font_family: self.platform_font_family.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(platform_font_family)
+                        )
+                    })?,
+                    font_variation_axes: self.font_variation_axes,
+                })
+            }
+        }
+        impl FontFace {
+            pub const IDENTIFIER: &'static str = "CSS.FontFace";
+        }
+        #[doc = "CSS try rule representation.\n[CSSTryRule](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSTryRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssTryRule {
+            #[doc = "The css style sheet identifier (absent for user agent stylesheet and user-specified\nstylesheet rules) this rule came from."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+            #[doc = "Parent stylesheet's origin."]
+            #[serde(rename = "origin")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub origin: StyleSheetOrigin,
+            #[doc = "Associated style declaration."]
+            #[serde(rename = "style")]
+            pub style: CssStyle,
+        }
+        impl CssTryRule {
+            pub fn new(origin: impl Into<StyleSheetOrigin>, style: impl Into<CssStyle>) -> Self {
+                Self {
+                    origin: origin.into(),
+                    style: style.into(),
+                    style_sheet_id: None,
+                }
+            }
+        }
+        impl CssTryRule {
+            pub fn builder() -> CssTryRuleBuilder {
+                CssTryRuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssTryRuleBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            origin: Option<StyleSheetOrigin>,
+            style: Option<CssStyle>,
+        }
+        impl CssTryRuleBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<StyleSheetOrigin>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn style(mut self, style: impl Into<CssStyle>) -> Self {
+                self.style = Some(style.into());
+                self
+            }
+            pub fn build(self) -> Result<CssTryRule, String> {
+                Ok(CssTryRule {
+                    style_sheet_id: self.style_sheet_id,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    style: self.style.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style))
+                    })?,
+                })
+            }
+        }
+        impl CssTryRule {
+            pub const IDENTIFIER: &'static str = "CSS.CSSTryRule";
+        }
+        #[doc = "CSS @position-try rule representation.\n[CSSPositionTryRule](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSPositionTryRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssPositionTryRule {
+            #[doc = "The prelude dashed-ident name"]
+            #[serde(rename = "name")]
+            pub name: Value,
+            #[doc = "The css style sheet identifier (absent for user agent stylesheet and user-specified\nstylesheet rules) this rule came from."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+            #[doc = "Parent stylesheet's origin."]
+            #[serde(rename = "origin")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub origin: StyleSheetOrigin,
+            #[doc = "Associated style declaration."]
+            #[serde(rename = "style")]
+            pub style: CssStyle,
+            #[serde(rename = "active")]
+            pub active: bool,
+        }
+        impl CssPositionTryRule {
+            pub fn new(
+                name: impl Into<Value>,
+                origin: impl Into<StyleSheetOrigin>,
+                style: impl Into<CssStyle>,
+                active: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    origin: origin.into(),
+                    style: style.into(),
+                    active: active.into(),
+                    style_sheet_id: None,
+                }
+            }
+        }
+        impl CssPositionTryRule {
+            pub fn builder() -> CssPositionTryRuleBuilder {
+                CssPositionTryRuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssPositionTryRuleBuilder {
+            name: Option<Value>,
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            origin: Option<StyleSheetOrigin>,
+            style: Option<CssStyle>,
+            active: Option<bool>,
+        }
+        impl CssPositionTryRuleBuilder {
+            pub fn name(mut self, name: impl Into<Value>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<StyleSheetOrigin>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn style(mut self, style: impl Into<CssStyle>) -> Self {
+                self.style = Some(style.into());
+                self
+            }
+            pub fn active(mut self, active: impl Into<bool>) -> Self {
+                self.active = Some(active.into());
+                self
+            }
+            pub fn build(self) -> Result<CssPositionTryRule, String> {
+                Ok(CssPositionTryRule {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    style_sheet_id: self.style_sheet_id,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    style: self.style.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style))
+                    })?,
+                    active: self.active.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(active))
+                    })?,
+                })
+            }
+        }
+        impl CssPositionTryRule {
+            pub const IDENTIFIER: &'static str = "CSS.CSSPositionTryRule";
+        }
+        #[doc = "CSS keyframes rule representation.\n[CSSKeyframesRule](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSKeyframesRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssKeyframesRule {
+            #[doc = "Animation name."]
+            #[serde(rename = "animationName")]
+            pub animation_name: Value,
+            #[doc = "List of keyframes."]
+            #[serde(rename = "keyframes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub keyframes: Vec<CssKeyframeRule>,
+        }
+        impl CssKeyframesRule {
+            pub fn new(animation_name: impl Into<Value>, keyframes: Vec<CssKeyframeRule>) -> Self {
+                Self {
+                    animation_name: animation_name.into(),
+                    keyframes,
+                }
+            }
+        }
+        impl CssKeyframesRule {
+            pub fn builder() -> CssKeyframesRuleBuilder {
+                CssKeyframesRuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssKeyframesRuleBuilder {
+            animation_name: Option<Value>,
+            keyframes: Option<Vec<CssKeyframeRule>>,
+        }
+        impl CssKeyframesRuleBuilder {
+            pub fn animation_name(mut self, animation_name: impl Into<Value>) -> Self {
+                self.animation_name = Some(animation_name.into());
+                self
+            }
+            pub fn keyframe(mut self, keyframe: impl Into<CssKeyframeRule>) -> Self {
+                let v = self.keyframes.get_or_insert(Vec::new());
+                v.push(keyframe.into());
+                self
+            }
+            pub fn keyframes<I, S>(mut self, keyframes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssKeyframeRule>,
+            {
+                let v = self.keyframes.get_or_insert(Vec::new());
+                for val in keyframes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<CssKeyframesRule, String> {
+                Ok(CssKeyframesRule {
+                    animation_name: self.animation_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(animation_name))
+                    })?,
+                    keyframes: self.keyframes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(keyframes))
+                    })?,
+                })
+            }
+        }
+        impl CssKeyframesRule {
+            pub const IDENTIFIER: &'static str = "CSS.CSSKeyframesRule";
+        }
+        #[doc = "Representation of a custom property registration through CSS.registerProperty\n[CSSPropertyRegistration](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSPropertyRegistration)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssPropertyRegistration {
+            #[serde(rename = "propertyName")]
+            pub property_name: String,
+            #[serde(rename = "initialValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub initial_value: Option<Value>,
+            #[serde(rename = "inherits")]
+            pub inherits: bool,
+            #[serde(rename = "syntax")]
+            pub syntax: String,
+        }
+        impl CssPropertyRegistration {
+            pub fn new(
+                property_name: impl Into<String>,
+                inherits: impl Into<bool>,
+                syntax: impl Into<String>,
+            ) -> Self {
+                Self {
+                    property_name: property_name.into(),
+                    inherits: inherits.into(),
+                    syntax: syntax.into(),
+                    initial_value: None,
+                }
+            }
+        }
+        impl CssPropertyRegistration {
+            pub fn builder() -> CssPropertyRegistrationBuilder {
+                CssPropertyRegistrationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssPropertyRegistrationBuilder {
+            property_name: Option<String>,
+            initial_value: Option<Value>,
+            inherits: Option<bool>,
+            syntax: Option<String>,
+        }
+        impl CssPropertyRegistrationBuilder {
+            pub fn property_name(mut self, property_name: impl Into<String>) -> Self {
+                self.property_name = Some(property_name.into());
+                self
+            }
+            pub fn initial_value(mut self, initial_value: impl Into<Value>) -> Self {
+                self.initial_value = Some(initial_value.into());
+                self
+            }
+            pub fn inherits(mut self, inherits: impl Into<bool>) -> Self {
+                self.inherits = Some(inherits.into());
+                self
+            }
+            pub fn syntax(mut self, syntax: impl Into<String>) -> Self {
+                self.syntax = Some(syntax.into());
+                self
+            }
+            pub fn build(self) -> Result<CssPropertyRegistration, String> {
+                Ok(CssPropertyRegistration {
+                    property_name: self.property_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(property_name))
+                    })?,
+                    initial_value: self.initial_value,
+                    inherits: self.inherits.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(inherits))
+                    })?,
+                    syntax: self.syntax.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(syntax))
+                    })?,
+                })
+            }
+        }
+        impl CssPropertyRegistration {
+            pub const IDENTIFIER: &'static str = "CSS.CSSPropertyRegistration";
+        }
+        #[doc = "CSS generic @rule representation.\n[CSSAtRule](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSAtRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssAtRule {
+            #[doc = "Type of at-rule."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: CssAtRuleType,
+            #[doc = "Subsection of font-feature-values, if this is a subsection."]
+            #[serde(rename = "subsection")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub subsection: Option<CssAtRuleSubsection>,
+            #[doc = "LINT.ThenChange(//third_party/blink/renderer/core/inspector/inspector_style_sheet.cc:FontVariantAlternatesFeatureType,//third_party/blink/renderer/core/inspector/inspector_css_agent.cc:FontVariantAlternatesFeatureType)\nAssociated name, if applicable."]
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<Value>,
+            #[doc = "The css style sheet identifier (absent for user agent stylesheet and user-specified\nstylesheet rules) this rule came from."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+            #[doc = "Parent stylesheet's origin."]
+            #[serde(rename = "origin")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub origin: StyleSheetOrigin,
+            #[doc = "Associated style declaration."]
+            #[serde(rename = "style")]
+            pub style: CssStyle,
+        }
+        #[doc = "Type of at-rule."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CssAtRuleType {
+            #[serde(rename = "font-face")]
+            FontFace,
+            #[serde(rename = "font-feature-values")]
+            FontFeatureValues,
+            #[serde(rename = "font-palette-values")]
+            FontPaletteValues,
+        }
+        impl AsRef<str> for CssAtRuleType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CssAtRuleType::FontFace => "font-face",
+                    CssAtRuleType::FontFeatureValues => "font-feature-values",
+                    CssAtRuleType::FontPaletteValues => "font-palette-values",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CssAtRuleType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "font-face" | "FontFace" => Ok(CssAtRuleType::FontFace),
+                    "font-feature-values" | "FontFeatureValues" => {
+                        Ok(CssAtRuleType::FontFeatureValues)
+                    }
+                    "font-palette-values" | "FontPaletteValues" => {
+                        Ok(CssAtRuleType::FontPaletteValues)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Subsection of font-feature-values, if this is a subsection."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CssAtRuleSubsection {
+            #[doc = "LINT.IfChange(FontVariantAlternatesFeatureType)"]
+            #[serde(rename = "swash")]
+            Swash,
+            #[serde(rename = "annotation")]
+            Annotation,
+            #[serde(rename = "ornaments")]
+            Ornaments,
+            #[serde(rename = "stylistic")]
+            Stylistic,
+            #[serde(rename = "styleset")]
+            Styleset,
+            #[serde(rename = "character-variant")]
+            CharacterVariant,
+        }
+        impl AsRef<str> for CssAtRuleSubsection {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CssAtRuleSubsection::Swash => "swash",
+                    CssAtRuleSubsection::Annotation => "annotation",
+                    CssAtRuleSubsection::Ornaments => "ornaments",
+                    CssAtRuleSubsection::Stylistic => "stylistic",
+                    CssAtRuleSubsection::Styleset => "styleset",
+                    CssAtRuleSubsection::CharacterVariant => "character-variant",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CssAtRuleSubsection {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "swash" | "Swash" => Ok(CssAtRuleSubsection::Swash),
+                    "annotation" | "Annotation" => Ok(CssAtRuleSubsection::Annotation),
+                    "ornaments" | "Ornaments" => Ok(CssAtRuleSubsection::Ornaments),
+                    "stylistic" | "Stylistic" => Ok(CssAtRuleSubsection::Stylistic),
+                    "styleset" | "Styleset" => Ok(CssAtRuleSubsection::Styleset),
+                    "character-variant" | "CharacterVariant" => {
+                        Ok(CssAtRuleSubsection::CharacterVariant)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl CssAtRule {
+            pub fn new(
+                r#type: impl Into<CssAtRuleType>,
+                origin: impl Into<StyleSheetOrigin>,
+                style: impl Into<CssStyle>,
+            ) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    origin: origin.into(),
+                    style: style.into(),
+                    subsection: None,
+                    name: None,
+                    style_sheet_id: None,
+                }
+            }
+        }
+        impl CssAtRule {
+            pub fn builder() -> CssAtRuleBuilder {
+                CssAtRuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssAtRuleBuilder {
+            r#type: Option<CssAtRuleType>,
+            subsection: Option<CssAtRuleSubsection>,
+            name: Option<Value>,
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            origin: Option<StyleSheetOrigin>,
+            style: Option<CssStyle>,
+        }
+        impl CssAtRuleBuilder {
+            pub fn r#type(mut self, r#type: impl Into<CssAtRuleType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn subsection(mut self, subsection: impl Into<CssAtRuleSubsection>) -> Self {
+                self.subsection = Some(subsection.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<Value>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<StyleSheetOrigin>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn style(mut self, style: impl Into<CssStyle>) -> Self {
+                self.style = Some(style.into());
+                self
+            }
+            pub fn build(self) -> Result<CssAtRule, String> {
+                Ok(CssAtRule {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    subsection: self.subsection,
+                    name: self.name,
+                    style_sheet_id: self.style_sheet_id,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    style: self.style.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style))
+                    })?,
+                })
+            }
+        }
+        impl CssAtRule {
+            pub const IDENTIFIER: &'static str = "CSS.CSSAtRule";
+        }
+        #[doc = "CSS property at-rule representation.\n[CSSPropertyRule](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSPropertyRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssPropertyRule {
+            #[doc = "The css style sheet identifier (absent for user agent stylesheet and user-specified\nstylesheet rules) this rule came from."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+            #[doc = "Parent stylesheet's origin."]
+            #[serde(rename = "origin")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub origin: StyleSheetOrigin,
+            #[doc = "Associated property name."]
+            #[serde(rename = "propertyName")]
+            pub property_name: Value,
+            #[doc = "Associated style declaration."]
+            #[serde(rename = "style")]
+            pub style: CssStyle,
+        }
+        impl CssPropertyRule {
+            pub fn new(
+                origin: impl Into<StyleSheetOrigin>,
+                property_name: impl Into<Value>,
+                style: impl Into<CssStyle>,
+            ) -> Self {
+                Self {
+                    origin: origin.into(),
+                    property_name: property_name.into(),
+                    style: style.into(),
+                    style_sheet_id: None,
+                }
+            }
+        }
+        impl CssPropertyRule {
+            pub fn builder() -> CssPropertyRuleBuilder {
+                CssPropertyRuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssPropertyRuleBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            origin: Option<StyleSheetOrigin>,
+            property_name: Option<Value>,
+            style: Option<CssStyle>,
+        }
+        impl CssPropertyRuleBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<StyleSheetOrigin>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn property_name(mut self, property_name: impl Into<Value>) -> Self {
+                self.property_name = Some(property_name.into());
+                self
+            }
+            pub fn style(mut self, style: impl Into<CssStyle>) -> Self {
+                self.style = Some(style.into());
+                self
+            }
+            pub fn build(self) -> Result<CssPropertyRule, String> {
+                Ok(CssPropertyRule {
+                    style_sheet_id: self.style_sheet_id,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    property_name: self.property_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(property_name))
+                    })?,
+                    style: self.style.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style))
+                    })?,
+                })
+            }
+        }
+        impl CssPropertyRule {
+            pub const IDENTIFIER: &'static str = "CSS.CSSPropertyRule";
+        }
+        #[doc = "CSS function argument representation.\n[CSSFunctionParameter](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSFunctionParameter)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssFunctionParameter {
+            #[doc = "The parameter name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "The parameter type."]
+            #[serde(rename = "type")]
+            pub r#type: String,
+        }
+        impl CssFunctionParameter {
+            pub fn new(name: impl Into<String>, r#type: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    r#type: r#type.into(),
+                }
+            }
+        }
+        impl CssFunctionParameter {
+            pub fn builder() -> CssFunctionParameterBuilder {
+                CssFunctionParameterBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssFunctionParameterBuilder {
+            name: Option<String>,
+            r#type: Option<String>,
+        }
+        impl CssFunctionParameterBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<CssFunctionParameter, String> {
+                Ok(CssFunctionParameter {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                })
+            }
+        }
+        impl CssFunctionParameter {
+            pub const IDENTIFIER: &'static str = "CSS.CSSFunctionParameter";
+        }
+        #[doc = "CSS function conditional block representation.\n[CSSFunctionConditionNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSFunctionConditionNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssFunctionConditionNode {
+            #[doc = "Media query for this conditional block. Only one type of condition should be set."]
+            #[serde(rename = "media")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub media: Option<CssMedia>,
+            #[doc = "Container query for this conditional block. Only one type of condition should be set."]
+            #[serde(rename = "containerQueries")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub container_queries: Option<CssContainerQuery>,
+            #[doc = "@supports CSS at-rule condition. Only one type of condition should be set."]
+            #[serde(rename = "supports")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub supports: Option<CssSupports>,
+            #[doc = "Block body."]
+            #[serde(rename = "children")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub children: Vec<CssFunctionNode>,
+            #[doc = "The condition text."]
+            #[serde(rename = "conditionText")]
+            pub condition_text: String,
+        }
+        impl CssFunctionConditionNode {
+            pub fn new(children: Vec<CssFunctionNode>, condition_text: impl Into<String>) -> Self {
+                Self {
+                    children,
+                    condition_text: condition_text.into(),
+                    media: None,
+                    container_queries: None,
+                    supports: None,
+                }
+            }
+        }
+        impl CssFunctionConditionNode {
+            pub fn builder() -> CssFunctionConditionNodeBuilder {
+                CssFunctionConditionNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssFunctionConditionNodeBuilder {
+            media: Option<CssMedia>,
+            container_queries: Option<CssContainerQuery>,
+            supports: Option<CssSupports>,
+            children: Option<Vec<CssFunctionNode>>,
+            condition_text: Option<String>,
+        }
+        impl CssFunctionConditionNodeBuilder {
+            pub fn media(mut self, media: impl Into<CssMedia>) -> Self {
+                self.media = Some(media.into());
+                self
+            }
+            pub fn container_queries(
+                mut self,
+                container_queries: impl Into<CssContainerQuery>,
+            ) -> Self {
+                self.container_queries = Some(container_queries.into());
+                self
+            }
+            pub fn supports(mut self, supports: impl Into<CssSupports>) -> Self {
+                self.supports = Some(supports.into());
+                self
+            }
+            pub fn children(mut self, children: impl Into<CssFunctionNode>) -> Self {
+                let v = self.children.get_or_insert(Vec::new());
+                v.push(children.into());
+                self
+            }
+            pub fn childrens<I, S>(mut self, childrens: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssFunctionNode>,
+            {
+                let v = self.children.get_or_insert(Vec::new());
+                for val in childrens {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn condition_text(mut self, condition_text: impl Into<String>) -> Self {
+                self.condition_text = Some(condition_text.into());
+                self
+            }
+            pub fn build(self) -> Result<CssFunctionConditionNode, String> {
+                Ok(CssFunctionConditionNode {
+                    media: self.media,
+                    container_queries: self.container_queries,
+                    supports: self.supports,
+                    children: self.children.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(children))
+                    })?,
+                    condition_text: self.condition_text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(condition_text))
+                    })?,
+                })
+            }
+        }
+        impl CssFunctionConditionNode {
+            pub const IDENTIFIER: &'static str = "CSS.CSSFunctionConditionNode";
+        }
+        #[doc = "Section of the body of a CSS function rule.\n[CSSFunctionNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSFunctionNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CssFunctionNode {
+            #[doc = "A conditional block. If set, style should not be set."]
+            #[serde(rename = "condition")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub condition: Option<CssFunctionConditionNode>,
+            #[doc = "Values set by this node. If set, condition should not be set."]
+            #[serde(rename = "style")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style: Option<CssStyle>,
+        }
+        impl CssFunctionNode {
+            pub fn builder() -> CssFunctionNodeBuilder {
+                CssFunctionNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssFunctionNodeBuilder {
+            condition: Option<CssFunctionConditionNode>,
+            style: Option<CssStyle>,
+        }
+        impl CssFunctionNodeBuilder {
+            pub fn condition(mut self, condition: impl Into<CssFunctionConditionNode>) -> Self {
+                self.condition = Some(condition.into());
+                self
+            }
+            pub fn style(mut self, style: impl Into<CssStyle>) -> Self {
+                self.style = Some(style.into());
+                self
+            }
+            pub fn build(self) -> CssFunctionNode {
+                CssFunctionNode {
+                    condition: self.condition,
+                    style: self.style,
+                }
+            }
+        }
+        impl CssFunctionNode {
+            pub const IDENTIFIER: &'static str = "CSS.CSSFunctionNode";
+        }
+        #[doc = "CSS function at-rule representation.\n[CSSFunctionRule](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSFunctionRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssFunctionRule {
+            #[doc = "Name of the function."]
+            #[serde(rename = "name")]
+            pub name: Value,
+            #[doc = "The css style sheet identifier (absent for user agent stylesheet and user-specified\nstylesheet rules) this rule came from."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+            #[doc = "Parent stylesheet's origin."]
+            #[serde(rename = "origin")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub origin: StyleSheetOrigin,
+            #[doc = "List of parameters."]
+            #[serde(rename = "parameters")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub parameters: Vec<CssFunctionParameter>,
+            #[doc = "Function body."]
+            #[serde(rename = "children")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub children: Vec<CssFunctionNode>,
+        }
+        impl CssFunctionRule {
+            pub fn new(
+                name: impl Into<Value>,
+                origin: impl Into<StyleSheetOrigin>,
+                parameters: Vec<CssFunctionParameter>,
+                children: Vec<CssFunctionNode>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    origin: origin.into(),
+                    parameters,
+                    children,
+                    style_sheet_id: None,
+                }
+            }
+        }
+        impl CssFunctionRule {
+            pub fn builder() -> CssFunctionRuleBuilder {
+                CssFunctionRuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssFunctionRuleBuilder {
+            name: Option<Value>,
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            origin: Option<StyleSheetOrigin>,
+            parameters: Option<Vec<CssFunctionParameter>>,
+            children: Option<Vec<CssFunctionNode>>,
+        }
+        impl CssFunctionRuleBuilder {
+            pub fn name(mut self, name: impl Into<Value>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<StyleSheetOrigin>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn parameter(mut self, parameter: impl Into<CssFunctionParameter>) -> Self {
+                let v = self.parameters.get_or_insert(Vec::new());
+                v.push(parameter.into());
+                self
+            }
+            pub fn parameters<I, S>(mut self, parameters: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssFunctionParameter>,
+            {
+                let v = self.parameters.get_or_insert(Vec::new());
+                for val in parameters {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn children(mut self, children: impl Into<CssFunctionNode>) -> Self {
+                let v = self.children.get_or_insert(Vec::new());
+                v.push(children.into());
+                self
+            }
+            pub fn childrens<I, S>(mut self, childrens: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssFunctionNode>,
+            {
+                let v = self.children.get_or_insert(Vec::new());
+                for val in childrens {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<CssFunctionRule, String> {
+                Ok(CssFunctionRule {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    style_sheet_id: self.style_sheet_id,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    parameters: self.parameters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(parameters))
+                    })?,
+                    children: self.children.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(children))
+                    })?,
+                })
+            }
+        }
+        impl CssFunctionRule {
+            pub const IDENTIFIER: &'static str = "CSS.CSSFunctionRule";
+        }
+        #[doc = "CSS keyframe rule representation.\n[CSSKeyframeRule](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-CSSKeyframeRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssKeyframeRule {
+            #[doc = "The css style sheet identifier (absent for user agent stylesheet and user-specified\nstylesheet rules) this rule came from."]
+            #[serde(rename = "styleSheetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_sheet_id: Option<super::dom::StyleSheetId>,
+            #[doc = "Parent stylesheet's origin."]
+            #[serde(rename = "origin")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub origin: StyleSheetOrigin,
+            #[doc = "Associated key text."]
+            #[serde(rename = "keyText")]
+            pub key_text: Value,
+            #[doc = "Associated style declaration."]
+            #[serde(rename = "style")]
+            pub style: CssStyle,
+        }
+        impl CssKeyframeRule {
+            pub fn new(
+                origin: impl Into<StyleSheetOrigin>,
+                key_text: impl Into<Value>,
+                style: impl Into<CssStyle>,
+            ) -> Self {
+                Self {
+                    origin: origin.into(),
+                    key_text: key_text.into(),
+                    style: style.into(),
+                    style_sheet_id: None,
+                }
+            }
+        }
+        impl CssKeyframeRule {
+            pub fn builder() -> CssKeyframeRuleBuilder {
+                CssKeyframeRuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssKeyframeRuleBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            origin: Option<StyleSheetOrigin>,
+            key_text: Option<Value>,
+            style: Option<CssStyle>,
+        }
+        impl CssKeyframeRuleBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<StyleSheetOrigin>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn key_text(mut self, key_text: impl Into<Value>) -> Self {
+                self.key_text = Some(key_text.into());
+                self
+            }
+            pub fn style(mut self, style: impl Into<CssStyle>) -> Self {
+                self.style = Some(style.into());
+                self
+            }
+            pub fn build(self) -> Result<CssKeyframeRule, String> {
+                Ok(CssKeyframeRule {
+                    style_sheet_id: self.style_sheet_id,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    key_text: self.key_text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_text))
+                    })?,
+                    style: self.style.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style))
+                    })?,
+                })
+            }
+        }
+        impl CssKeyframeRule {
+            pub const IDENTIFIER: &'static str = "CSS.CSSKeyframeRule";
+        }
+        #[doc = "A descriptor of operation to mutate style declaration text.\n[StyleDeclarationEdit](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#type-StyleDeclarationEdit)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StyleDeclarationEdit {
+            #[doc = "The css style sheet identifier."]
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[doc = "The range of the style text in the enclosing stylesheet."]
+            #[serde(rename = "range")]
+            pub range: SourceRange,
+            #[doc = "New style text."]
+            #[serde(rename = "text")]
+            pub text: String,
+        }
+        impl StyleDeclarationEdit {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                range: impl Into<SourceRange>,
+                text: impl Into<String>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    range: range.into(),
+                    text: text.into(),
+                }
+            }
+        }
+        impl StyleDeclarationEdit {
+            pub fn builder() -> StyleDeclarationEditBuilder {
+                StyleDeclarationEditBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StyleDeclarationEditBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            range: Option<SourceRange>,
+            text: Option<String>,
+        }
+        impl StyleDeclarationEditBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn build(self) -> Result<StyleDeclarationEdit, String> {
+                Ok(StyleDeclarationEdit {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    range: self.range.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(range))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                })
+            }
+        }
+        impl StyleDeclarationEdit {
+            pub const IDENTIFIER: &'static str = "CSS.StyleDeclarationEdit";
+        }
+        #[doc = "Inserts a new rule with the given `ruleText` in a stylesheet with given `styleSheetId`, at the\nposition specified by `location`.\n[addRule](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-addRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddRuleParams {
+            #[doc = "The css style sheet identifier where a new rule should be inserted."]
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[doc = "The text of a new rule."]
+            #[serde(rename = "ruleText")]
+            pub rule_text: String,
+            #[doc = "Text position of a new rule in the target style sheet."]
+            #[serde(rename = "location")]
+            pub location: SourceRange,
+            #[doc = "NodeId for the DOM node in whose context custom property declarations for registered properties should be\nvalidated. If omitted, declarations in the new rule text can only be validated statically, which may produce\nincorrect results if the declaration contains a var() for example."]
+            #[serde(rename = "nodeForPropertySyntaxValidation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_for_property_syntax_validation: Option<super::dom::NodeId>,
+        }
+        impl AddRuleParams {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                rule_text: impl Into<String>,
+                location: impl Into<SourceRange>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    rule_text: rule_text.into(),
+                    location: location.into(),
+                    node_for_property_syntax_validation: None,
+                }
+            }
+        }
+        impl AddRuleParams {
+            pub fn builder() -> AddRuleParamsBuilder {
+                AddRuleParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddRuleParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            rule_text: Option<String>,
+            location: Option<SourceRange>,
+            node_for_property_syntax_validation: Option<super::dom::NodeId>,
+        }
+        impl AddRuleParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn rule_text(mut self, rule_text: impl Into<String>) -> Self {
+                self.rule_text = Some(rule_text.into());
+                self
+            }
+            pub fn location(mut self, location: impl Into<SourceRange>) -> Self {
+                self.location = Some(location.into());
+                self
+            }
+            pub fn node_for_property_syntax_validation(
+                mut self,
+                node_for_property_syntax_validation: impl Into<super::dom::NodeId>,
+            ) -> Self {
+                self.node_for_property_syntax_validation =
+                    Some(node_for_property_syntax_validation.into());
+                self
+            }
+            pub fn build(self) -> Result<AddRuleParams, String> {
+                Ok(AddRuleParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    rule_text: self.rule_text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rule_text))
+                    })?,
+                    location: self.location.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(location))
+                    })?,
+                    node_for_property_syntax_validation: self.node_for_property_syntax_validation,
+                })
+            }
+        }
+        impl AddRuleParams {
+            pub const IDENTIFIER: &'static str = "CSS.addRule";
+        }
+        impl chromiumoxide_types::Method for AddRuleParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddRuleParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Inserts a new rule with the given `ruleText` in a stylesheet with given `styleSheetId`, at the\nposition specified by `location`.\n[addRule](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-addRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddRuleReturns {
+            #[doc = "The newly created rule."]
+            #[serde(rename = "rule")]
+            pub rule: CssRule,
+        }
+        impl AddRuleReturns {
+            pub fn new(rule: impl Into<CssRule>) -> Self {
+                Self { rule: rule.into() }
+            }
+        }
+        impl AddRuleReturns {
+            pub fn builder() -> AddRuleReturnsBuilder {
+                AddRuleReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddRuleReturnsBuilder {
+            rule: Option<CssRule>,
+        }
+        impl AddRuleReturnsBuilder {
+            pub fn rule(mut self, rule: impl Into<CssRule>) -> Self {
+                self.rule = Some(rule.into());
+                self
+            }
+            pub fn build(self) -> Result<AddRuleReturns, String> {
+                Ok(AddRuleReturns {
+                    rule: self.rule.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rule))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for AddRuleParams {
+            type Response = AddRuleReturns;
+        }
+        #[doc = "Returns all class names from specified stylesheet.\n[collectClassNames](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-collectClassNames)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CollectClassNamesParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+        }
+        impl CollectClassNamesParams {
+            pub fn new(style_sheet_id: impl Into<super::dom::StyleSheetId>) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                }
+            }
+        }
+        impl CollectClassNamesParams {
+            pub fn builder() -> CollectClassNamesParamsBuilder {
+                CollectClassNamesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CollectClassNamesParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl CollectClassNamesParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CollectClassNamesParams, String> {
+                Ok(CollectClassNamesParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                })
+            }
+        }
+        impl CollectClassNamesParams {
+            pub const IDENTIFIER: &'static str = "CSS.collectClassNames";
+        }
+        impl chromiumoxide_types::Method for CollectClassNamesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CollectClassNamesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns all class names from specified stylesheet.\n[collectClassNames](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-collectClassNames)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CollectClassNamesReturns {
+            #[doc = "Class name list."]
+            #[serde(rename = "classNames")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub class_names: Vec<String>,
+        }
+        impl CollectClassNamesReturns {
+            pub fn new(class_names: Vec<String>) -> Self {
+                Self { class_names }
+            }
+        }
+        impl CollectClassNamesReturns {
+            pub fn builder() -> CollectClassNamesReturnsBuilder {
+                CollectClassNamesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CollectClassNamesReturnsBuilder {
+            class_names: Option<Vec<String>>,
+        }
+        impl CollectClassNamesReturnsBuilder {
+            pub fn class_name(mut self, class_name: impl Into<String>) -> Self {
+                let v = self.class_names.get_or_insert(Vec::new());
+                v.push(class_name.into());
+                self
+            }
+            pub fn class_names<I, S>(mut self, class_names: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.class_names.get_or_insert(Vec::new());
+                for val in class_names {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<CollectClassNamesReturns, String> {
+                Ok(CollectClassNamesReturns {
+                    class_names: self.class_names.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(class_names))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CollectClassNamesParams {
+            type Response = CollectClassNamesReturns;
+        }
+        #[doc = "Creates a new special \"via-inspector\" stylesheet in the frame with given `frameId`.\n[createStyleSheet](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-createStyleSheet)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CreateStyleSheetParams {
+            #[doc = "Identifier of the frame where \"via-inspector\" stylesheet should be created."]
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+            #[doc = "If true, creates a new stylesheet for every call. If false,\nreturns a stylesheet previously created by a call with force=false\nfor the frame's document if it exists or creates a new stylesheet\n(default: false)."]
+            #[serde(rename = "force")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub force: Option<bool>,
+        }
+        impl CreateStyleSheetParams {
+            pub fn new(frame_id: impl Into<super::page::FrameId>) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                    force: None,
+                }
+            }
+        }
+        impl CreateStyleSheetParams {
+            pub fn builder() -> CreateStyleSheetParamsBuilder {
+                CreateStyleSheetParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CreateStyleSheetParamsBuilder {
+            frame_id: Option<super::page::FrameId>,
+            force: Option<bool>,
+        }
+        impl CreateStyleSheetParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn force(mut self, force: impl Into<bool>) -> Self {
+                self.force = Some(force.into());
+                self
+            }
+            pub fn build(self) -> Result<CreateStyleSheetParams, String> {
+                Ok(CreateStyleSheetParams {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    force: self.force,
+                })
+            }
+        }
+        impl CreateStyleSheetParams {
+            pub const IDENTIFIER: &'static str = "CSS.createStyleSheet";
+        }
+        impl chromiumoxide_types::Method for CreateStyleSheetParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CreateStyleSheetParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Creates a new special \"via-inspector\" stylesheet in the frame with given `frameId`.\n[createStyleSheet](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-createStyleSheet)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CreateStyleSheetReturns {
+            #[doc = "Identifier of the created \"via-inspector\" stylesheet."]
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+        }
+        impl CreateStyleSheetReturns {
+            pub fn new(style_sheet_id: impl Into<super::dom::StyleSheetId>) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                }
+            }
+        }
+        impl CreateStyleSheetReturns {
+            pub fn builder() -> CreateStyleSheetReturnsBuilder {
+                CreateStyleSheetReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CreateStyleSheetReturnsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl CreateStyleSheetReturnsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CreateStyleSheetReturns, String> {
+                Ok(CreateStyleSheetReturns {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CreateStyleSheetParams {
+            type Response = CreateStyleSheetReturns;
+        }
+        #[doc = "Disables the CSS agent for the given page.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "CSS.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables the CSS agent for the given page.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables the CSS agent for the given page. Clients should not assume that the CSS agent has been\nenabled until the result of this command is received.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "CSS.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables the CSS agent for the given page. Clients should not assume that the CSS agent has been\nenabled until the result of this command is received.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Ensures that the given node will have specified pseudo-classes whenever its style is computed by\nthe browser.\n[forcePseudoState](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-forcePseudoState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ForcePseudoStateParams {
+            #[doc = "The element id for which to force the pseudo state."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+            #[doc = "Element pseudo classes to force when computing the element's style."]
+            #[serde(rename = "forcedPseudoClasses")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub forced_pseudo_classes: Vec<String>,
+        }
+        impl ForcePseudoStateParams {
+            pub fn new(
+                node_id: impl Into<super::dom::NodeId>,
+                forced_pseudo_classes: Vec<String>,
+            ) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    forced_pseudo_classes,
+                }
+            }
+        }
+        impl ForcePseudoStateParams {
+            pub fn builder() -> ForcePseudoStateParamsBuilder {
+                ForcePseudoStateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ForcePseudoStateParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+            forced_pseudo_classes: Option<Vec<String>>,
+        }
+        impl ForcePseudoStateParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn forced_pseudo_classe(mut self, forced_pseudo_classe: impl Into<String>) -> Self {
+                let v = self.forced_pseudo_classes.get_or_insert(Vec::new());
+                v.push(forced_pseudo_classe.into());
+                self
+            }
+            pub fn forced_pseudo_classes<I, S>(mut self, forced_pseudo_classes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.forced_pseudo_classes.get_or_insert(Vec::new());
+                for val in forced_pseudo_classes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ForcePseudoStateParams, String> {
+                Ok(ForcePseudoStateParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    forced_pseudo_classes: self.forced_pseudo_classes.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(forced_pseudo_classes)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl ForcePseudoStateParams {
+            pub const IDENTIFIER: &'static str = "CSS.forcePseudoState";
+        }
+        impl chromiumoxide_types::Method for ForcePseudoStateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ForcePseudoStateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Ensures that the given node will have specified pseudo-classes whenever its style is computed by\nthe browser.\n[forcePseudoState](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-forcePseudoState)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ForcePseudoStateReturns {}
+        impl chromiumoxide_types::Command for ForcePseudoStateParams {
+            type Response = ForcePseudoStateReturns;
+        }
+        #[doc = "Ensures that the given node is in its starting-style state.\n[forceStartingStyle](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-forceStartingStyle)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ForceStartingStyleParams {
+            #[doc = "The element id for which to force the starting-style state."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+            #[doc = "Boolean indicating if this is on or off."]
+            #[serde(rename = "forced")]
+            pub forced: bool,
+        }
+        impl ForceStartingStyleParams {
+            pub fn new(node_id: impl Into<super::dom::NodeId>, forced: impl Into<bool>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    forced: forced.into(),
+                }
+            }
+        }
+        impl ForceStartingStyleParams {
+            pub fn builder() -> ForceStartingStyleParamsBuilder {
+                ForceStartingStyleParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ForceStartingStyleParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+            forced: Option<bool>,
+        }
+        impl ForceStartingStyleParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn forced(mut self, forced: impl Into<bool>) -> Self {
+                self.forced = Some(forced.into());
+                self
+            }
+            pub fn build(self) -> Result<ForceStartingStyleParams, String> {
+                Ok(ForceStartingStyleParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    forced: self.forced.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(forced))
+                    })?,
+                })
+            }
+        }
+        impl ForceStartingStyleParams {
+            pub const IDENTIFIER: &'static str = "CSS.forceStartingStyle";
+        }
+        impl chromiumoxide_types::Method for ForceStartingStyleParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ForceStartingStyleParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Ensures that the given node is in its starting-style state.\n[forceStartingStyle](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-forceStartingStyle)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ForceStartingStyleReturns {}
+        impl chromiumoxide_types::Command for ForceStartingStyleParams {
+            type Response = ForceStartingStyleReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetBackgroundColorsParams {
+            #[doc = "Id of the node to get background colors for."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl GetBackgroundColorsParams {
+            pub fn new(node_id: impl Into<super::dom::NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetBackgroundColorsParams {
+            pub fn builder() -> GetBackgroundColorsParamsBuilder {
+                GetBackgroundColorsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetBackgroundColorsParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl GetBackgroundColorsParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetBackgroundColorsParams, String> {
+                Ok(GetBackgroundColorsParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetBackgroundColorsParams {
+            pub const IDENTIFIER: &'static str = "CSS.getBackgroundColors";
+        }
+        impl chromiumoxide_types::Method for GetBackgroundColorsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetBackgroundColorsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetBackgroundColorsReturns {
+            #[doc = "The range of background colors behind this element, if it contains any visible text. If no\nvisible text is present, this will be undefined. In the case of a flat background color,\nthis will consist of simply that color. In the case of a gradient, this will consist of each\nof the color stops. For anything more complicated, this will be an empty array. Images will\nbe ignored (as if the image had failed to load)."]
+            #[serde(rename = "backgroundColors")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub background_colors: Option<Vec<String>>,
+            #[doc = "The computed font size for this node, as a CSS computed value string (e.g. '12px')."]
+            #[serde(rename = "computedFontSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub computed_font_size: Option<String>,
+            #[doc = "The computed font weight for this node, as a CSS computed value string (e.g. 'normal' or\n'100')."]
+            #[serde(rename = "computedFontWeight")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub computed_font_weight: Option<String>,
+        }
+        impl GetBackgroundColorsReturns {
+            pub fn builder() -> GetBackgroundColorsReturnsBuilder {
+                GetBackgroundColorsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetBackgroundColorsReturnsBuilder {
+            background_colors: Option<Vec<String>>,
+            computed_font_size: Option<String>,
+            computed_font_weight: Option<String>,
+        }
+        impl GetBackgroundColorsReturnsBuilder {
+            pub fn background_color(mut self, background_color: impl Into<String>) -> Self {
+                let v = self.background_colors.get_or_insert(Vec::new());
+                v.push(background_color.into());
+                self
+            }
+            pub fn background_colors<I, S>(mut self, background_colors: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.background_colors.get_or_insert(Vec::new());
+                for val in background_colors {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn computed_font_size(mut self, computed_font_size: impl Into<String>) -> Self {
+                self.computed_font_size = Some(computed_font_size.into());
+                self
+            }
+            pub fn computed_font_weight(mut self, computed_font_weight: impl Into<String>) -> Self {
+                self.computed_font_weight = Some(computed_font_weight.into());
+                self
+            }
+            pub fn build(self) -> GetBackgroundColorsReturns {
+                GetBackgroundColorsReturns {
+                    background_colors: self.background_colors,
+                    computed_font_size: self.computed_font_size,
+                    computed_font_weight: self.computed_font_weight,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for GetBackgroundColorsParams {
+            type Response = GetBackgroundColorsReturns;
+        }
+        #[doc = "Returns the computed style for a DOM node identified by `nodeId`.\n[getComputedStyleForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getComputedStyleForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetComputedStyleForNodeParams {
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl GetComputedStyleForNodeParams {
+            pub fn new(node_id: impl Into<super::dom::NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetComputedStyleForNodeParams {
+            pub fn builder() -> GetComputedStyleForNodeParamsBuilder {
+                GetComputedStyleForNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetComputedStyleForNodeParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl GetComputedStyleForNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetComputedStyleForNodeParams, String> {
+                Ok(GetComputedStyleForNodeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetComputedStyleForNodeParams {
+            pub const IDENTIFIER: &'static str = "CSS.getComputedStyleForNode";
+        }
+        impl chromiumoxide_types::Method for GetComputedStyleForNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetComputedStyleForNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the computed style for a DOM node identified by `nodeId`.\n[getComputedStyleForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getComputedStyleForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetComputedStyleForNodeReturns {
+            #[doc = "Computed style for the specified DOM node."]
+            #[serde(rename = "computedStyle")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub computed_style: Vec<CssComputedStyleProperty>,
+            #[doc = "A list of non-standard \"extra fields\" which blink stores alongside each\ncomputed style."]
+            #[serde(rename = "extraFields")]
+            pub extra_fields: ComputedStyleExtraFields,
+        }
+        impl GetComputedStyleForNodeReturns {
+            pub fn new(
+                computed_style: Vec<CssComputedStyleProperty>,
+                extra_fields: impl Into<ComputedStyleExtraFields>,
+            ) -> Self {
+                Self {
+                    computed_style,
+                    extra_fields: extra_fields.into(),
+                }
+            }
+        }
+        impl GetComputedStyleForNodeReturns {
+            pub fn builder() -> GetComputedStyleForNodeReturnsBuilder {
+                GetComputedStyleForNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetComputedStyleForNodeReturnsBuilder {
+            computed_style: Option<Vec<CssComputedStyleProperty>>,
+            extra_fields: Option<ComputedStyleExtraFields>,
+        }
+        impl GetComputedStyleForNodeReturnsBuilder {
+            pub fn computed_style(
+                mut self,
+                computed_style: impl Into<CssComputedStyleProperty>,
+            ) -> Self {
+                let v = self.computed_style.get_or_insert(Vec::new());
+                v.push(computed_style.into());
+                self
+            }
+            pub fn computed_styles<I, S>(mut self, computed_styles: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssComputedStyleProperty>,
+            {
+                let v = self.computed_style.get_or_insert(Vec::new());
+                for val in computed_styles {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn extra_fields(
+                mut self,
+                extra_fields: impl Into<ComputedStyleExtraFields>,
+            ) -> Self {
+                self.extra_fields = Some(extra_fields.into());
+                self
+            }
+            pub fn build(self) -> Result<GetComputedStyleForNodeReturns, String> {
+                Ok(GetComputedStyleForNodeReturns {
+                    computed_style: self.computed_style.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(computed_style))
+                    })?,
+                    extra_fields: self.extra_fields.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(extra_fields))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetComputedStyleForNodeParams {
+            type Response = GetComputedStyleForNodeReturns;
+        }
+        #[doc = "Resolve the specified values in the context of the provided element.\nFor example, a value of '1em' is evaluated according to the computed\n'font-size' of the element and a value 'calc(1px + 2px)' will be\nresolved to '3px'.\nIf the `propertyName` was specified the `values` are resolved as if\nthey were property's declaration. If a value cannot be parsed according\nto the provided property syntax, the value is parsed using combined\nsyntax as if null `propertyName` was provided. If the value cannot be\nresolved even then, return the provided value without any changes.\n[resolveValues](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-resolveValues)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ResolveValuesParams {
+            #[doc = "Cascade-dependent keywords (revert/revert-layer) do not work."]
+            #[serde(rename = "values")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub values: Vec<String>,
+            #[doc = "Id of the node in whose context the expression is evaluated"]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+            #[doc = "Only longhands and custom property names are accepted."]
+            #[serde(rename = "propertyName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub property_name: Option<String>,
+            #[doc = "Pseudo element type, only works for pseudo elements that generate\nelements in the tree, such as ::before and ::after."]
+            #[serde(rename = "pseudoType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub pseudo_type: Option<super::dom::PseudoType>,
+            #[doc = "Pseudo element custom ident."]
+            #[serde(rename = "pseudoIdentifier")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pseudo_identifier: Option<String>,
+        }
+        impl ResolveValuesParams {
+            pub fn new(values: Vec<String>, node_id: impl Into<super::dom::NodeId>) -> Self {
+                Self {
+                    values,
+                    node_id: node_id.into(),
+                    property_name: None,
+                    pseudo_type: None,
+                    pseudo_identifier: None,
+                }
+            }
+        }
+        impl ResolveValuesParams {
+            pub fn builder() -> ResolveValuesParamsBuilder {
+                ResolveValuesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResolveValuesParamsBuilder {
+            values: Option<Vec<String>>,
+            node_id: Option<super::dom::NodeId>,
+            property_name: Option<String>,
+            pseudo_type: Option<super::dom::PseudoType>,
+            pseudo_identifier: Option<String>,
+        }
+        impl ResolveValuesParamsBuilder {
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                let v = self.values.get_or_insert(Vec::new());
+                v.push(value.into());
+                self
+            }
+            pub fn values<I, S>(mut self, values: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.values.get_or_insert(Vec::new());
+                for val in values {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn property_name(mut self, property_name: impl Into<String>) -> Self {
+                self.property_name = Some(property_name.into());
+                self
+            }
+            pub fn pseudo_type(mut self, pseudo_type: impl Into<super::dom::PseudoType>) -> Self {
+                self.pseudo_type = Some(pseudo_type.into());
+                self
+            }
+            pub fn pseudo_identifier(mut self, pseudo_identifier: impl Into<String>) -> Self {
+                self.pseudo_identifier = Some(pseudo_identifier.into());
+                self
+            }
+            pub fn build(self) -> Result<ResolveValuesParams, String> {
+                Ok(ResolveValuesParams {
+                    values: self.values.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(values))
+                    })?,
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    property_name: self.property_name,
+                    pseudo_type: self.pseudo_type,
+                    pseudo_identifier: self.pseudo_identifier,
+                })
+            }
+        }
+        impl ResolveValuesParams {
+            pub const IDENTIFIER: &'static str = "CSS.resolveValues";
+        }
+        impl chromiumoxide_types::Method for ResolveValuesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ResolveValuesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Resolve the specified values in the context of the provided element.\nFor example, a value of '1em' is evaluated according to the computed\n'font-size' of the element and a value 'calc(1px + 2px)' will be\nresolved to '3px'.\nIf the `propertyName` was specified the `values` are resolved as if\nthey were property's declaration. If a value cannot be parsed according\nto the provided property syntax, the value is parsed using combined\nsyntax as if null `propertyName` was provided. If the value cannot be\nresolved even then, return the provided value without any changes.\n[resolveValues](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-resolveValues)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ResolveValuesReturns {
+            #[serde(rename = "results")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub results: Vec<String>,
+        }
+        impl ResolveValuesReturns {
+            pub fn new(results: Vec<String>) -> Self {
+                Self { results }
+            }
+        }
+        impl ResolveValuesReturns {
+            pub fn builder() -> ResolveValuesReturnsBuilder {
+                ResolveValuesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResolveValuesReturnsBuilder {
+            results: Option<Vec<String>>,
+        }
+        impl ResolveValuesReturnsBuilder {
+            pub fn result(mut self, result: impl Into<String>) -> Self {
+                let v = self.results.get_or_insert(Vec::new());
+                v.push(result.into());
+                self
+            }
+            pub fn results<I, S>(mut self, results: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.results.get_or_insert(Vec::new());
+                for val in results {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ResolveValuesReturns, String> {
+                Ok(ResolveValuesReturns {
+                    results: self.results.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(results))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for ResolveValuesParams {
+            type Response = ResolveValuesReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetLonghandPropertiesParams {
+            #[serde(rename = "shorthandName")]
+            pub shorthand_name: String,
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl GetLonghandPropertiesParams {
+            pub fn new(shorthand_name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    shorthand_name: shorthand_name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl GetLonghandPropertiesParams {
+            pub fn builder() -> GetLonghandPropertiesParamsBuilder {
+                GetLonghandPropertiesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetLonghandPropertiesParamsBuilder {
+            shorthand_name: Option<String>,
+            value: Option<String>,
+        }
+        impl GetLonghandPropertiesParamsBuilder {
+            pub fn shorthand_name(mut self, shorthand_name: impl Into<String>) -> Self {
+                self.shorthand_name = Some(shorthand_name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<GetLonghandPropertiesParams, String> {
+                Ok(GetLonghandPropertiesParams {
+                    shorthand_name: self.shorthand_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(shorthand_name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl GetLonghandPropertiesParams {
+            pub const IDENTIFIER: &'static str = "CSS.getLonghandProperties";
+        }
+        impl chromiumoxide_types::Method for GetLonghandPropertiesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetLonghandPropertiesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetLonghandPropertiesReturns {
+            #[serde(rename = "longhandProperties")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub longhand_properties: Vec<CssProperty>,
+        }
+        impl GetLonghandPropertiesReturns {
+            pub fn new(longhand_properties: Vec<CssProperty>) -> Self {
+                Self {
+                    longhand_properties,
+                }
+            }
+        }
+        impl GetLonghandPropertiesReturns {
+            pub fn builder() -> GetLonghandPropertiesReturnsBuilder {
+                GetLonghandPropertiesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetLonghandPropertiesReturnsBuilder {
+            longhand_properties: Option<Vec<CssProperty>>,
+        }
+        impl GetLonghandPropertiesReturnsBuilder {
+            pub fn longhand_propertie(
+                mut self,
+                longhand_propertie: impl Into<CssProperty>,
+            ) -> Self {
+                let v = self.longhand_properties.get_or_insert(Vec::new());
+                v.push(longhand_propertie.into());
+                self
+            }
+            pub fn longhand_properties<I, S>(mut self, longhand_properties: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssProperty>,
+            {
+                let v = self.longhand_properties.get_or_insert(Vec::new());
+                for val in longhand_properties {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetLonghandPropertiesReturns, String> {
+                Ok(GetLonghandPropertiesReturns {
+                    longhand_properties: self.longhand_properties.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(longhand_properties)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetLonghandPropertiesParams {
+            type Response = GetLonghandPropertiesReturns;
+        }
+        #[doc = "Returns the styles defined inline (explicitly in the \"style\" attribute and implicitly, using DOM\nattributes) for a DOM node identified by `nodeId`.\n[getInlineStylesForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getInlineStylesForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetInlineStylesForNodeParams {
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl GetInlineStylesForNodeParams {
+            pub fn new(node_id: impl Into<super::dom::NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetInlineStylesForNodeParams {
+            pub fn builder() -> GetInlineStylesForNodeParamsBuilder {
+                GetInlineStylesForNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetInlineStylesForNodeParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl GetInlineStylesForNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetInlineStylesForNodeParams, String> {
+                Ok(GetInlineStylesForNodeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetInlineStylesForNodeParams {
+            pub const IDENTIFIER: &'static str = "CSS.getInlineStylesForNode";
+        }
+        impl chromiumoxide_types::Method for GetInlineStylesForNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetInlineStylesForNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the styles defined inline (explicitly in the \"style\" attribute and implicitly, using DOM\nattributes) for a DOM node identified by `nodeId`.\n[getInlineStylesForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getInlineStylesForNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetInlineStylesForNodeReturns {
+            #[doc = "Inline style for the specified DOM node."]
+            #[serde(rename = "inlineStyle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub inline_style: Option<CssStyle>,
+            #[doc = "Attribute-defined element style (e.g. resulting from \"width=20 height=100%\")."]
+            #[serde(rename = "attributesStyle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub attributes_style: Option<CssStyle>,
+        }
+        impl GetInlineStylesForNodeReturns {
+            pub fn builder() -> GetInlineStylesForNodeReturnsBuilder {
+                GetInlineStylesForNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetInlineStylesForNodeReturnsBuilder {
+            inline_style: Option<CssStyle>,
+            attributes_style: Option<CssStyle>,
+        }
+        impl GetInlineStylesForNodeReturnsBuilder {
+            pub fn inline_style(mut self, inline_style: impl Into<CssStyle>) -> Self {
+                self.inline_style = Some(inline_style.into());
+                self
+            }
+            pub fn attributes_style(mut self, attributes_style: impl Into<CssStyle>) -> Self {
+                self.attributes_style = Some(attributes_style.into());
+                self
+            }
+            pub fn build(self) -> GetInlineStylesForNodeReturns {
+                GetInlineStylesForNodeReturns {
+                    inline_style: self.inline_style,
+                    attributes_style: self.attributes_style,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for GetInlineStylesForNodeParams {
+            type Response = GetInlineStylesForNodeReturns;
+        }
+        #[doc = "Returns the styles coming from animations & transitions\nincluding the animation & transition styles coming from inheritance chain.\n[getAnimatedStylesForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getAnimatedStylesForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAnimatedStylesForNodeParams {
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl GetAnimatedStylesForNodeParams {
+            pub fn new(node_id: impl Into<super::dom::NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetAnimatedStylesForNodeParams {
+            pub fn builder() -> GetAnimatedStylesForNodeParamsBuilder {
+                GetAnimatedStylesForNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAnimatedStylesForNodeParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl GetAnimatedStylesForNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetAnimatedStylesForNodeParams, String> {
+                Ok(GetAnimatedStylesForNodeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetAnimatedStylesForNodeParams {
+            pub const IDENTIFIER: &'static str = "CSS.getAnimatedStylesForNode";
+        }
+        impl chromiumoxide_types::Method for GetAnimatedStylesForNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetAnimatedStylesForNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the styles coming from animations & transitions\nincluding the animation & transition styles coming from inheritance chain.\n[getAnimatedStylesForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getAnimatedStylesForNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetAnimatedStylesForNodeReturns {
+            #[doc = "Styles coming from animations."]
+            #[serde(rename = "animationStyles")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub animation_styles: Option<Vec<CssAnimationStyle>>,
+            #[doc = "Style coming from transitions."]
+            #[serde(rename = "transitionsStyle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub transitions_style: Option<CssStyle>,
+            #[doc = "Inherited style entries for animationsStyle and transitionsStyle from\nthe inheritance chain of the element."]
+            #[serde(rename = "inherited")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub inherited: Option<Vec<InheritedAnimatedStyleEntry>>,
+        }
+        impl GetAnimatedStylesForNodeReturns {
+            pub fn builder() -> GetAnimatedStylesForNodeReturnsBuilder {
+                GetAnimatedStylesForNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAnimatedStylesForNodeReturnsBuilder {
+            animation_styles: Option<Vec<CssAnimationStyle>>,
+            transitions_style: Option<CssStyle>,
+            inherited: Option<Vec<InheritedAnimatedStyleEntry>>,
+        }
+        impl GetAnimatedStylesForNodeReturnsBuilder {
+            pub fn animation_style(
+                mut self,
+                animation_style: impl Into<CssAnimationStyle>,
+            ) -> Self {
+                let v = self.animation_styles.get_or_insert(Vec::new());
+                v.push(animation_style.into());
+                self
+            }
+            pub fn animation_styles<I, S>(mut self, animation_styles: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssAnimationStyle>,
+            {
+                let v = self.animation_styles.get_or_insert(Vec::new());
+                for val in animation_styles {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn transitions_style(mut self, transitions_style: impl Into<CssStyle>) -> Self {
+                self.transitions_style = Some(transitions_style.into());
+                self
+            }
+            pub fn inherited(mut self, inherited: impl Into<InheritedAnimatedStyleEntry>) -> Self {
+                let v = self.inherited.get_or_insert(Vec::new());
+                v.push(inherited.into());
+                self
+            }
+            pub fn inheriteds<I, S>(mut self, inheriteds: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<InheritedAnimatedStyleEntry>,
+            {
+                let v = self.inherited.get_or_insert(Vec::new());
+                for val in inheriteds {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> GetAnimatedStylesForNodeReturns {
+                GetAnimatedStylesForNodeReturns {
+                    animation_styles: self.animation_styles,
+                    transitions_style: self.transitions_style,
+                    inherited: self.inherited,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for GetAnimatedStylesForNodeParams {
+            type Response = GetAnimatedStylesForNodeReturns;
+        }
+        #[doc = "Returns requested styles for a DOM node identified by `nodeId`.\n[getMatchedStylesForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getMatchedStylesForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetMatchedStylesForNodeParams {
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl GetMatchedStylesForNodeParams {
+            pub fn new(node_id: impl Into<super::dom::NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetMatchedStylesForNodeParams {
+            pub fn builder() -> GetMatchedStylesForNodeParamsBuilder {
+                GetMatchedStylesForNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetMatchedStylesForNodeParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl GetMatchedStylesForNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetMatchedStylesForNodeParams, String> {
+                Ok(GetMatchedStylesForNodeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetMatchedStylesForNodeParams {
+            pub const IDENTIFIER: &'static str = "CSS.getMatchedStylesForNode";
+        }
+        impl chromiumoxide_types::Method for GetMatchedStylesForNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetMatchedStylesForNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns requested styles for a DOM node identified by `nodeId`.\n[getMatchedStylesForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getMatchedStylesForNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetMatchedStylesForNodeReturns {
+            #[doc = "Inline style for the specified DOM node."]
+            #[serde(rename = "inlineStyle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub inline_style: Option<CssStyle>,
+            #[doc = "Attribute-defined element style (e.g. resulting from \"width=20 height=100%\")."]
+            #[serde(rename = "attributesStyle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub attributes_style: Option<CssStyle>,
+            #[doc = "CSS rules matching this node, from all applicable stylesheets."]
+            #[serde(rename = "matchedCSSRules")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub matched_css_rules: Option<Vec<RuleMatch>>,
+            #[doc = "Pseudo style matches for this node."]
+            #[serde(rename = "pseudoElements")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pseudo_elements: Option<Vec<PseudoElementMatches>>,
+            #[doc = "A chain of inherited styles (from the immediate node parent up to the DOM tree root)."]
+            #[serde(rename = "inherited")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub inherited: Option<Vec<InheritedStyleEntry>>,
+            #[doc = "A chain of inherited pseudo element styles (from the immediate node parent up to the DOM tree root)."]
+            #[serde(rename = "inheritedPseudoElements")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub inherited_pseudo_elements: Option<Vec<InheritedPseudoElementMatches>>,
+            #[doc = "A list of CSS keyframed animations matching this node."]
+            #[serde(rename = "cssKeyframesRules")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub css_keyframes_rules: Option<Vec<CssKeyframesRule>>,
+            #[doc = "A list of CSS @position-try rules matching this node, based on the position-try-fallbacks property."]
+            #[serde(rename = "cssPositionTryRules")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub css_position_try_rules: Option<Vec<CssPositionTryRule>>,
+            #[doc = "Index of the active fallback in the applied position-try-fallback property,\nwill not be set if there is no active position-try fallback."]
+            #[serde(rename = "activePositionFallbackIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub active_position_fallback_index: Option<i64>,
+            #[doc = "A list of CSS at-property rules matching this node."]
+            #[serde(rename = "cssPropertyRules")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub css_property_rules: Option<Vec<CssPropertyRule>>,
+            #[doc = "A list of CSS property registrations matching this node."]
+            #[serde(rename = "cssPropertyRegistrations")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub css_property_registrations: Option<Vec<CssPropertyRegistration>>,
+            #[doc = "A list of simple @rules matching this node or its pseudo-elements."]
+            #[serde(rename = "cssAtRules")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub css_at_rules: Option<Vec<CssAtRule>>,
+            #[doc = "Id of the first parent element that does not have display: contents."]
+            #[serde(rename = "parentLayoutNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent_layout_node_id: Option<super::dom::NodeId>,
+            #[doc = "A list of CSS at-function rules referenced by styles of this node."]
+            #[serde(rename = "cssFunctionRules")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub css_function_rules: Option<Vec<CssFunctionRule>>,
+        }
+        impl GetMatchedStylesForNodeReturns {
+            pub fn builder() -> GetMatchedStylesForNodeReturnsBuilder {
+                GetMatchedStylesForNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetMatchedStylesForNodeReturnsBuilder {
+            inline_style: Option<CssStyle>,
+            attributes_style: Option<CssStyle>,
+            matched_css_rules: Option<Vec<RuleMatch>>,
+            pseudo_elements: Option<Vec<PseudoElementMatches>>,
+            inherited: Option<Vec<InheritedStyleEntry>>,
+            inherited_pseudo_elements: Option<Vec<InheritedPseudoElementMatches>>,
+            css_keyframes_rules: Option<Vec<CssKeyframesRule>>,
+            css_position_try_rules: Option<Vec<CssPositionTryRule>>,
+            active_position_fallback_index: Option<i64>,
+            css_property_rules: Option<Vec<CssPropertyRule>>,
+            css_property_registrations: Option<Vec<CssPropertyRegistration>>,
+            css_at_rules: Option<Vec<CssAtRule>>,
+            parent_layout_node_id: Option<super::dom::NodeId>,
+            css_function_rules: Option<Vec<CssFunctionRule>>,
+        }
+        impl GetMatchedStylesForNodeReturnsBuilder {
+            pub fn inline_style(mut self, inline_style: impl Into<CssStyle>) -> Self {
+                self.inline_style = Some(inline_style.into());
+                self
+            }
+            pub fn attributes_style(mut self, attributes_style: impl Into<CssStyle>) -> Self {
+                self.attributes_style = Some(attributes_style.into());
+                self
+            }
+            pub fn matched_css_rule(mut self, matched_css_rule: impl Into<RuleMatch>) -> Self {
+                let v = self.matched_css_rules.get_or_insert(Vec::new());
+                v.push(matched_css_rule.into());
+                self
+            }
+            pub fn matched_css_rules<I, S>(mut self, matched_css_rules: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<RuleMatch>,
+            {
+                let v = self.matched_css_rules.get_or_insert(Vec::new());
+                for val in matched_css_rules {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn pseudo_element(
+                mut self,
+                pseudo_element: impl Into<PseudoElementMatches>,
+            ) -> Self {
+                let v = self.pseudo_elements.get_or_insert(Vec::new());
+                v.push(pseudo_element.into());
+                self
+            }
+            pub fn pseudo_elements<I, S>(mut self, pseudo_elements: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PseudoElementMatches>,
+            {
+                let v = self.pseudo_elements.get_or_insert(Vec::new());
+                for val in pseudo_elements {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn inherited(mut self, inherited: impl Into<InheritedStyleEntry>) -> Self {
+                let v = self.inherited.get_or_insert(Vec::new());
+                v.push(inherited.into());
+                self
+            }
+            pub fn inheriteds<I, S>(mut self, inheriteds: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<InheritedStyleEntry>,
+            {
+                let v = self.inherited.get_or_insert(Vec::new());
+                for val in inheriteds {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn inherited_pseudo_element(
+                mut self,
+                inherited_pseudo_element: impl Into<InheritedPseudoElementMatches>,
+            ) -> Self {
+                let v = self.inherited_pseudo_elements.get_or_insert(Vec::new());
+                v.push(inherited_pseudo_element.into());
+                self
+            }
+            pub fn inherited_pseudo_elements<I, S>(mut self, inherited_pseudo_elements: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<InheritedPseudoElementMatches>,
+            {
+                let v = self.inherited_pseudo_elements.get_or_insert(Vec::new());
+                for val in inherited_pseudo_elements {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn css_keyframes_rule(
+                mut self,
+                css_keyframes_rule: impl Into<CssKeyframesRule>,
+            ) -> Self {
+                let v = self.css_keyframes_rules.get_or_insert(Vec::new());
+                v.push(css_keyframes_rule.into());
+                self
+            }
+            pub fn css_keyframes_rules<I, S>(mut self, css_keyframes_rules: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssKeyframesRule>,
+            {
+                let v = self.css_keyframes_rules.get_or_insert(Vec::new());
+                for val in css_keyframes_rules {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn css_position_try_rule(
+                mut self,
+                css_position_try_rule: impl Into<CssPositionTryRule>,
+            ) -> Self {
+                let v = self.css_position_try_rules.get_or_insert(Vec::new());
+                v.push(css_position_try_rule.into());
+                self
+            }
+            pub fn css_position_try_rules<I, S>(mut self, css_position_try_rules: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssPositionTryRule>,
+            {
+                let v = self.css_position_try_rules.get_or_insert(Vec::new());
+                for val in css_position_try_rules {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn active_position_fallback_index(
+                mut self,
+                active_position_fallback_index: impl Into<i64>,
+            ) -> Self {
+                self.active_position_fallback_index = Some(active_position_fallback_index.into());
+                self
+            }
+            pub fn css_property_rule(
+                mut self,
+                css_property_rule: impl Into<CssPropertyRule>,
+            ) -> Self {
+                let v = self.css_property_rules.get_or_insert(Vec::new());
+                v.push(css_property_rule.into());
+                self
+            }
+            pub fn css_property_rules<I, S>(mut self, css_property_rules: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssPropertyRule>,
+            {
+                let v = self.css_property_rules.get_or_insert(Vec::new());
+                for val in css_property_rules {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn css_property_registration(
+                mut self,
+                css_property_registration: impl Into<CssPropertyRegistration>,
+            ) -> Self {
+                let v = self.css_property_registrations.get_or_insert(Vec::new());
+                v.push(css_property_registration.into());
+                self
+            }
+            pub fn css_property_registrations<I, S>(mut self, css_property_registrations: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssPropertyRegistration>,
+            {
+                let v = self.css_property_registrations.get_or_insert(Vec::new());
+                for val in css_property_registrations {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn css_at_rule(mut self, css_at_rule: impl Into<CssAtRule>) -> Self {
+                let v = self.css_at_rules.get_or_insert(Vec::new());
+                v.push(css_at_rule.into());
+                self
+            }
+            pub fn css_at_rules<I, S>(mut self, css_at_rules: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssAtRule>,
+            {
+                let v = self.css_at_rules.get_or_insert(Vec::new());
+                for val in css_at_rules {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn parent_layout_node_id(
+                mut self,
+                parent_layout_node_id: impl Into<super::dom::NodeId>,
+            ) -> Self {
+                self.parent_layout_node_id = Some(parent_layout_node_id.into());
+                self
+            }
+            pub fn css_function_rule(
+                mut self,
+                css_function_rule: impl Into<CssFunctionRule>,
+            ) -> Self {
+                let v = self.css_function_rules.get_or_insert(Vec::new());
+                v.push(css_function_rule.into());
+                self
+            }
+            pub fn css_function_rules<I, S>(mut self, css_function_rules: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssFunctionRule>,
+            {
+                let v = self.css_function_rules.get_or_insert(Vec::new());
+                for val in css_function_rules {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> GetMatchedStylesForNodeReturns {
+                GetMatchedStylesForNodeReturns {
+                    inline_style: self.inline_style,
+                    attributes_style: self.attributes_style,
+                    matched_css_rules: self.matched_css_rules,
+                    pseudo_elements: self.pseudo_elements,
+                    inherited: self.inherited,
+                    inherited_pseudo_elements: self.inherited_pseudo_elements,
+                    css_keyframes_rules: self.css_keyframes_rules,
+                    css_position_try_rules: self.css_position_try_rules,
+                    active_position_fallback_index: self.active_position_fallback_index,
+                    css_property_rules: self.css_property_rules,
+                    css_property_registrations: self.css_property_registrations,
+                    css_at_rules: self.css_at_rules,
+                    parent_layout_node_id: self.parent_layout_node_id,
+                    css_function_rules: self.css_function_rules,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for GetMatchedStylesForNodeParams {
+            type Response = GetMatchedStylesForNodeReturns;
+        }
+        #[doc = "Returns the values of the default UA-defined environment variables used in env()\n[getEnvironmentVariables](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getEnvironmentVariables)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetEnvironmentVariablesParams {}
+        impl GetEnvironmentVariablesParams {
+            pub const IDENTIFIER: &'static str = "CSS.getEnvironmentVariables";
+        }
+        impl chromiumoxide_types::Method for GetEnvironmentVariablesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetEnvironmentVariablesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the values of the default UA-defined environment variables used in env()\n[getEnvironmentVariables](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getEnvironmentVariables)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetEnvironmentVariablesReturns {
+            #[serde(rename = "environmentVariables")]
+            pub environment_variables: serde_json::Value,
+        }
+        impl GetEnvironmentVariablesReturns {
+            pub fn new(environment_variables: impl Into<serde_json::Value>) -> Self {
+                Self {
+                    environment_variables: environment_variables.into(),
+                }
+            }
+        }
+        impl GetEnvironmentVariablesReturns {
+            pub fn builder() -> GetEnvironmentVariablesReturnsBuilder {
+                GetEnvironmentVariablesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetEnvironmentVariablesReturnsBuilder {
+            environment_variables: Option<serde_json::Value>,
+        }
+        impl GetEnvironmentVariablesReturnsBuilder {
+            pub fn environment_variables(
+                mut self,
+                environment_variables: impl Into<serde_json::Value>,
+            ) -> Self {
+                self.environment_variables = Some(environment_variables.into());
+                self
+            }
+            pub fn build(self) -> Result<GetEnvironmentVariablesReturns, String> {
+                Ok(GetEnvironmentVariablesReturns {
+                    environment_variables: self.environment_variables.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(environment_variables)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetEnvironmentVariablesParams {
+            type Response = GetEnvironmentVariablesReturns;
+        }
+        #[doc = "Returns all media queries parsed by the rendering engine.\n[getMediaQueries](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getMediaQueries)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetMediaQueriesParams {}
+        impl GetMediaQueriesParams {
+            pub const IDENTIFIER: &'static str = "CSS.getMediaQueries";
+        }
+        impl chromiumoxide_types::Method for GetMediaQueriesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetMediaQueriesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns all media queries parsed by the rendering engine.\n[getMediaQueries](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getMediaQueries)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetMediaQueriesReturns {
+            #[serde(rename = "medias")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub medias: Vec<CssMedia>,
+        }
+        impl GetMediaQueriesReturns {
+            pub fn new(medias: Vec<CssMedia>) -> Self {
+                Self { medias }
+            }
+        }
+        impl GetMediaQueriesReturns {
+            pub fn builder() -> GetMediaQueriesReturnsBuilder {
+                GetMediaQueriesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetMediaQueriesReturnsBuilder {
+            medias: Option<Vec<CssMedia>>,
+        }
+        impl GetMediaQueriesReturnsBuilder {
+            pub fn media(mut self, media: impl Into<CssMedia>) -> Self {
+                let v = self.medias.get_or_insert(Vec::new());
+                v.push(media.into());
+                self
+            }
+            pub fn medias<I, S>(mut self, medias: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssMedia>,
+            {
+                let v = self.medias.get_or_insert(Vec::new());
+                for val in medias {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetMediaQueriesReturns, String> {
+                Ok(GetMediaQueriesReturns {
+                    medias: self.medias.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(medias))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetMediaQueriesParams {
+            type Response = GetMediaQueriesReturns;
+        }
+        #[doc = "Requests information about platform fonts which we used to render child TextNodes in the given\nnode.\n[getPlatformFontsForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getPlatformFontsForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetPlatformFontsForNodeParams {
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl GetPlatformFontsForNodeParams {
+            pub fn new(node_id: impl Into<super::dom::NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetPlatformFontsForNodeParams {
+            pub fn builder() -> GetPlatformFontsForNodeParamsBuilder {
+                GetPlatformFontsForNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPlatformFontsForNodeParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl GetPlatformFontsForNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetPlatformFontsForNodeParams, String> {
+                Ok(GetPlatformFontsForNodeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetPlatformFontsForNodeParams {
+            pub const IDENTIFIER: &'static str = "CSS.getPlatformFontsForNode";
+        }
+        impl chromiumoxide_types::Method for GetPlatformFontsForNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetPlatformFontsForNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests information about platform fonts which we used to render child TextNodes in the given\nnode.\n[getPlatformFontsForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getPlatformFontsForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetPlatformFontsForNodeReturns {
+            #[doc = "Usage statistics for every employed platform font."]
+            #[serde(rename = "fonts")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub fonts: Vec<PlatformFontUsage>,
+        }
+        impl GetPlatformFontsForNodeReturns {
+            pub fn new(fonts: Vec<PlatformFontUsage>) -> Self {
+                Self { fonts }
+            }
+        }
+        impl GetPlatformFontsForNodeReturns {
+            pub fn builder() -> GetPlatformFontsForNodeReturnsBuilder {
+                GetPlatformFontsForNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPlatformFontsForNodeReturnsBuilder {
+            fonts: Option<Vec<PlatformFontUsage>>,
+        }
+        impl GetPlatformFontsForNodeReturnsBuilder {
+            pub fn font(mut self, font: impl Into<PlatformFontUsage>) -> Self {
+                let v = self.fonts.get_or_insert(Vec::new());
+                v.push(font.into());
+                self
+            }
+            pub fn fonts<I, S>(mut self, fonts: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PlatformFontUsage>,
+            {
+                let v = self.fonts.get_or_insert(Vec::new());
+                for val in fonts {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetPlatformFontsForNodeReturns, String> {
+                Ok(GetPlatformFontsForNodeReturns {
+                    fonts: self.fonts.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(fonts))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetPlatformFontsForNodeParams {
+            type Response = GetPlatformFontsForNodeReturns;
+        }
+        #[doc = "Returns the current textual content for a stylesheet.\n[getStyleSheetText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getStyleSheetText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetStyleSheetTextParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+        }
+        impl GetStyleSheetTextParams {
+            pub fn new(style_sheet_id: impl Into<super::dom::StyleSheetId>) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                }
+            }
+        }
+        impl GetStyleSheetTextParams {
+            pub fn builder() -> GetStyleSheetTextParamsBuilder {
+                GetStyleSheetTextParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetStyleSheetTextParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+        }
+        impl GetStyleSheetTextParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetStyleSheetTextParams, String> {
+                Ok(GetStyleSheetTextParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                })
+            }
+        }
+        impl GetStyleSheetTextParams {
+            pub const IDENTIFIER: &'static str = "CSS.getStyleSheetText";
+        }
+        impl chromiumoxide_types::Method for GetStyleSheetTextParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetStyleSheetTextParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the current textual content for a stylesheet.\n[getStyleSheetText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getStyleSheetText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetStyleSheetTextReturns {
+            #[doc = "The stylesheet text."]
+            #[serde(rename = "text")]
+            pub text: String,
+        }
+        impl GetStyleSheetTextReturns {
+            pub fn new(text: impl Into<String>) -> Self {
+                Self { text: text.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetStyleSheetTextReturns {
+            fn from(url: T) -> Self {
+                GetStyleSheetTextReturns::new(url)
+            }
+        }
+        impl GetStyleSheetTextReturns {
+            pub fn builder() -> GetStyleSheetTextReturnsBuilder {
+                GetStyleSheetTextReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetStyleSheetTextReturnsBuilder {
+            text: Option<String>,
+        }
+        impl GetStyleSheetTextReturnsBuilder {
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn build(self) -> Result<GetStyleSheetTextReturns, String> {
+                Ok(GetStyleSheetTextReturns {
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetStyleSheetTextParams {
+            type Response = GetStyleSheetTextReturns;
+        }
+        #[doc = "Returns all layers parsed by the rendering engine for the tree scope of a node.\nGiven a DOM element identified by nodeId, getLayersForNode returns the root\nlayer for the nearest ancestor document or shadow root. The layer root contains\nthe full layer tree for the tree scope and their ordering.\n[getLayersForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getLayersForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetLayersForNodeParams {
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl GetLayersForNodeParams {
+            pub fn new(node_id: impl Into<super::dom::NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetLayersForNodeParams {
+            pub fn builder() -> GetLayersForNodeParamsBuilder {
+                GetLayersForNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetLayersForNodeParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl GetLayersForNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetLayersForNodeParams, String> {
+                Ok(GetLayersForNodeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetLayersForNodeParams {
+            pub const IDENTIFIER: &'static str = "CSS.getLayersForNode";
+        }
+        impl chromiumoxide_types::Method for GetLayersForNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetLayersForNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns all layers parsed by the rendering engine for the tree scope of a node.\nGiven a DOM element identified by nodeId, getLayersForNode returns the root\nlayer for the nearest ancestor document or shadow root. The layer root contains\nthe full layer tree for the tree scope and their ordering.\n[getLayersForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getLayersForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetLayersForNodeReturns {
+            #[serde(rename = "rootLayer")]
+            pub root_layer: CssLayerData,
+        }
+        impl GetLayersForNodeReturns {
+            pub fn new(root_layer: impl Into<CssLayerData>) -> Self {
+                Self {
+                    root_layer: root_layer.into(),
+                }
+            }
+        }
+        impl GetLayersForNodeReturns {
+            pub fn builder() -> GetLayersForNodeReturnsBuilder {
+                GetLayersForNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetLayersForNodeReturnsBuilder {
+            root_layer: Option<CssLayerData>,
+        }
+        impl GetLayersForNodeReturnsBuilder {
+            pub fn root_layer(mut self, root_layer: impl Into<CssLayerData>) -> Self {
+                self.root_layer = Some(root_layer.into());
+                self
+            }
+            pub fn build(self) -> Result<GetLayersForNodeReturns, String> {
+                Ok(GetLayersForNodeReturns {
+                    root_layer: self.root_layer.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(root_layer))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetLayersForNodeParams {
+            type Response = GetLayersForNodeReturns;
+        }
+        #[doc = "Given a CSS selector text and a style sheet ID, getLocationForSelector\nreturns an array of locations of the CSS selector in the style sheet.\n[getLocationForSelector](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getLocationForSelector)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetLocationForSelectorParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[serde(rename = "selectorText")]
+            pub selector_text: String,
+        }
+        impl GetLocationForSelectorParams {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                selector_text: impl Into<String>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    selector_text: selector_text.into(),
+                }
+            }
+        }
+        impl GetLocationForSelectorParams {
+            pub fn builder() -> GetLocationForSelectorParamsBuilder {
+                GetLocationForSelectorParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetLocationForSelectorParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            selector_text: Option<String>,
+        }
+        impl GetLocationForSelectorParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn selector_text(mut self, selector_text: impl Into<String>) -> Self {
+                self.selector_text = Some(selector_text.into());
+                self
+            }
+            pub fn build(self) -> Result<GetLocationForSelectorParams, String> {
+                Ok(GetLocationForSelectorParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    selector_text: self.selector_text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(selector_text))
+                    })?,
+                })
+            }
+        }
+        impl GetLocationForSelectorParams {
+            pub const IDENTIFIER: &'static str = "CSS.getLocationForSelector";
+        }
+        impl chromiumoxide_types::Method for GetLocationForSelectorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetLocationForSelectorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Given a CSS selector text and a style sheet ID, getLocationForSelector\nreturns an array of locations of the CSS selector in the style sheet.\n[getLocationForSelector](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-getLocationForSelector)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetLocationForSelectorReturns {
+            #[serde(rename = "ranges")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub ranges: Vec<SourceRange>,
+        }
+        impl GetLocationForSelectorReturns {
+            pub fn new(ranges: Vec<SourceRange>) -> Self {
+                Self { ranges }
+            }
+        }
+        impl GetLocationForSelectorReturns {
+            pub fn builder() -> GetLocationForSelectorReturnsBuilder {
+                GetLocationForSelectorReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetLocationForSelectorReturnsBuilder {
+            ranges: Option<Vec<SourceRange>>,
+        }
+        impl GetLocationForSelectorReturnsBuilder {
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                let v = self.ranges.get_or_insert(Vec::new());
+                v.push(range.into());
+                self
+            }
+            pub fn ranges<I, S>(mut self, ranges: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SourceRange>,
+            {
+                let v = self.ranges.get_or_insert(Vec::new());
+                for val in ranges {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetLocationForSelectorReturns, String> {
+                Ok(GetLocationForSelectorReturns {
+                    ranges: self.ranges.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ranges))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetLocationForSelectorParams {
+            type Response = GetLocationForSelectorReturns;
+        }
+        #[doc = "Starts tracking the given node for the computed style updates\nand whenever the computed style is updated for node, it queues\na `computedStyleUpdated` event with throttling.\nThere can only be 1 node tracked for computed style updates\nso passing a new node id removes tracking from the previous node.\nPass `undefined` to disable tracking.\n[trackComputedStyleUpdatesForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-trackComputedStyleUpdatesForNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TrackComputedStyleUpdatesForNodeParams {
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<super::dom::NodeId>,
+        }
+        impl TrackComputedStyleUpdatesForNodeParams {
+            pub fn builder() -> TrackComputedStyleUpdatesForNodeParamsBuilder {
+                TrackComputedStyleUpdatesForNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TrackComputedStyleUpdatesForNodeParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl TrackComputedStyleUpdatesForNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> TrackComputedStyleUpdatesForNodeParams {
+                TrackComputedStyleUpdatesForNodeParams {
+                    node_id: self.node_id,
+                }
+            }
+        }
+        impl TrackComputedStyleUpdatesForNodeParams {
+            pub const IDENTIFIER: &'static str = "CSS.trackComputedStyleUpdatesForNode";
+        }
+        impl chromiumoxide_types::Method for TrackComputedStyleUpdatesForNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TrackComputedStyleUpdatesForNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Starts tracking the given node for the computed style updates\nand whenever the computed style is updated for node, it queues\na `computedStyleUpdated` event with throttling.\nThere can only be 1 node tracked for computed style updates\nso passing a new node id removes tracking from the previous node.\nPass `undefined` to disable tracking.\n[trackComputedStyleUpdatesForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-trackComputedStyleUpdatesForNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TrackComputedStyleUpdatesForNodeReturns {}
+        impl chromiumoxide_types::Command for TrackComputedStyleUpdatesForNodeParams {
+            type Response = TrackComputedStyleUpdatesForNodeReturns;
+        }
+        #[doc = "Starts tracking the given computed styles for updates. The specified array of properties\nreplaces the one previously specified. Pass empty array to disable tracking.\nUse takeComputedStyleUpdates to retrieve the list of nodes that had properties modified.\nThe changes to computed style properties are only tracked for nodes pushed to the front-end\nby the DOM agent. If no changes to the tracked properties occur after the node has been pushed\nto the front-end, no updates will be issued for the node.\n[trackComputedStyleUpdates](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-trackComputedStyleUpdates)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TrackComputedStyleUpdatesParams {
+            #[serde(rename = "propertiesToTrack")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub properties_to_track: Vec<CssComputedStyleProperty>,
+        }
+        impl TrackComputedStyleUpdatesParams {
+            pub fn new(properties_to_track: Vec<CssComputedStyleProperty>) -> Self {
+                Self {
+                    properties_to_track,
+                }
+            }
+        }
+        impl TrackComputedStyleUpdatesParams {
+            pub fn builder() -> TrackComputedStyleUpdatesParamsBuilder {
+                TrackComputedStyleUpdatesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TrackComputedStyleUpdatesParamsBuilder {
+            properties_to_track: Option<Vec<CssComputedStyleProperty>>,
+        }
+        impl TrackComputedStyleUpdatesParamsBuilder {
+            pub fn properties_to_track(
+                mut self,
+                properties_to_track: impl Into<CssComputedStyleProperty>,
+            ) -> Self {
+                let v = self.properties_to_track.get_or_insert(Vec::new());
+                v.push(properties_to_track.into());
+                self
+            }
+            pub fn properties_to_tracks<I, S>(mut self, properties_to_tracks: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssComputedStyleProperty>,
+            {
+                let v = self.properties_to_track.get_or_insert(Vec::new());
+                for val in properties_to_tracks {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<TrackComputedStyleUpdatesParams, String> {
+                Ok(TrackComputedStyleUpdatesParams {
+                    properties_to_track: self.properties_to_track.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(properties_to_track)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl TrackComputedStyleUpdatesParams {
+            pub const IDENTIFIER: &'static str = "CSS.trackComputedStyleUpdates";
+        }
+        impl chromiumoxide_types::Method for TrackComputedStyleUpdatesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TrackComputedStyleUpdatesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Starts tracking the given computed styles for updates. The specified array of properties\nreplaces the one previously specified. Pass empty array to disable tracking.\nUse takeComputedStyleUpdates to retrieve the list of nodes that had properties modified.\nThe changes to computed style properties are only tracked for nodes pushed to the front-end\nby the DOM agent. If no changes to the tracked properties occur after the node has been pushed\nto the front-end, no updates will be issued for the node.\n[trackComputedStyleUpdates](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-trackComputedStyleUpdates)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TrackComputedStyleUpdatesReturns {}
+        impl chromiumoxide_types::Command for TrackComputedStyleUpdatesParams {
+            type Response = TrackComputedStyleUpdatesReturns;
+        }
+        #[doc = "Polls the next batch of computed style updates.\n[takeComputedStyleUpdates](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-takeComputedStyleUpdates)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TakeComputedStyleUpdatesParams {}
+        impl TakeComputedStyleUpdatesParams {
+            pub const IDENTIFIER: &'static str = "CSS.takeComputedStyleUpdates";
+        }
+        impl chromiumoxide_types::Method for TakeComputedStyleUpdatesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TakeComputedStyleUpdatesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Polls the next batch of computed style updates.\n[takeComputedStyleUpdates](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-takeComputedStyleUpdates)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TakeComputedStyleUpdatesReturns {
+            #[doc = "The list of node Ids that have their tracked computed styles updated."]
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<super::dom::NodeId>,
+        }
+        impl TakeComputedStyleUpdatesReturns {
+            pub fn new(node_ids: Vec<super::dom::NodeId>) -> Self {
+                Self { node_ids }
+            }
+        }
+        impl TakeComputedStyleUpdatesReturns {
+            pub fn builder() -> TakeComputedStyleUpdatesReturnsBuilder {
+                TakeComputedStyleUpdatesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TakeComputedStyleUpdatesReturnsBuilder {
+            node_ids: Option<Vec<super::dom::NodeId>>,
+        }
+        impl TakeComputedStyleUpdatesReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                v.push(node_id.into());
+                self
+            }
+            pub fn node_ids<I, S>(mut self, node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::dom::NodeId>,
+            {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                for val in node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<TakeComputedStyleUpdatesReturns, String> {
+                Ok(TakeComputedStyleUpdatesReturns {
+                    node_ids: self.node_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_ids))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for TakeComputedStyleUpdatesParams {
+            type Response = TakeComputedStyleUpdatesReturns;
+        }
+        #[doc = "Find a rule with the given active property for the given node and set the new value for this\nproperty\n[setEffectivePropertyValueForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setEffectivePropertyValueForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetEffectivePropertyValueForNodeParams {
+            #[doc = "The element id for which to set property."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+            #[serde(rename = "propertyName")]
+            pub property_name: String,
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl SetEffectivePropertyValueForNodeParams {
+            pub fn new(
+                node_id: impl Into<super::dom::NodeId>,
+                property_name: impl Into<String>,
+                value: impl Into<String>,
+            ) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    property_name: property_name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl SetEffectivePropertyValueForNodeParams {
+            pub fn builder() -> SetEffectivePropertyValueForNodeParamsBuilder {
+                SetEffectivePropertyValueForNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetEffectivePropertyValueForNodeParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+            property_name: Option<String>,
+            value: Option<String>,
+        }
+        impl SetEffectivePropertyValueForNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn property_name(mut self, property_name: impl Into<String>) -> Self {
+                self.property_name = Some(property_name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<SetEffectivePropertyValueForNodeParams, String> {
+                Ok(SetEffectivePropertyValueForNodeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    property_name: self.property_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(property_name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl SetEffectivePropertyValueForNodeParams {
+            pub const IDENTIFIER: &'static str = "CSS.setEffectivePropertyValueForNode";
+        }
+        impl chromiumoxide_types::Method for SetEffectivePropertyValueForNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetEffectivePropertyValueForNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Find a rule with the given active property for the given node and set the new value for this\nproperty\n[setEffectivePropertyValueForNode](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setEffectivePropertyValueForNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetEffectivePropertyValueForNodeReturns {}
+        impl chromiumoxide_types::Command for SetEffectivePropertyValueForNodeParams {
+            type Response = SetEffectivePropertyValueForNodeReturns;
+        }
+        #[doc = "Modifies the property rule property name.\n[setPropertyRulePropertyName](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setPropertyRulePropertyName)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPropertyRulePropertyNameParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[serde(rename = "range")]
+            pub range: SourceRange,
+            #[serde(rename = "propertyName")]
+            pub property_name: String,
+        }
+        impl SetPropertyRulePropertyNameParams {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                range: impl Into<SourceRange>,
+                property_name: impl Into<String>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    range: range.into(),
+                    property_name: property_name.into(),
+                }
+            }
+        }
+        impl SetPropertyRulePropertyNameParams {
+            pub fn builder() -> SetPropertyRulePropertyNameParamsBuilder {
+                SetPropertyRulePropertyNameParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPropertyRulePropertyNameParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            range: Option<SourceRange>,
+            property_name: Option<String>,
+        }
+        impl SetPropertyRulePropertyNameParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn property_name(mut self, property_name: impl Into<String>) -> Self {
+                self.property_name = Some(property_name.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPropertyRulePropertyNameParams, String> {
+                Ok(SetPropertyRulePropertyNameParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    range: self.range.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(range))
+                    })?,
+                    property_name: self.property_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(property_name))
+                    })?,
+                })
+            }
+        }
+        impl SetPropertyRulePropertyNameParams {
+            pub const IDENTIFIER: &'static str = "CSS.setPropertyRulePropertyName";
+        }
+        impl chromiumoxide_types::Method for SetPropertyRulePropertyNameParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPropertyRulePropertyNameParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Modifies the property rule property name.\n[setPropertyRulePropertyName](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setPropertyRulePropertyName)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPropertyRulePropertyNameReturns {
+            #[doc = "The resulting key text after modification."]
+            #[serde(rename = "propertyName")]
+            pub property_name: Value,
+        }
+        impl SetPropertyRulePropertyNameReturns {
+            pub fn new(property_name: impl Into<Value>) -> Self {
+                Self {
+                    property_name: property_name.into(),
+                }
+            }
+        }
+        impl SetPropertyRulePropertyNameReturns {
+            pub fn builder() -> SetPropertyRulePropertyNameReturnsBuilder {
+                SetPropertyRulePropertyNameReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPropertyRulePropertyNameReturnsBuilder {
+            property_name: Option<Value>,
+        }
+        impl SetPropertyRulePropertyNameReturnsBuilder {
+            pub fn property_name(mut self, property_name: impl Into<Value>) -> Self {
+                self.property_name = Some(property_name.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPropertyRulePropertyNameReturns, String> {
+                Ok(SetPropertyRulePropertyNameReturns {
+                    property_name: self.property_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(property_name))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetPropertyRulePropertyNameParams {
+            type Response = SetPropertyRulePropertyNameReturns;
+        }
+        #[doc = "Modifies the keyframe rule key text.\n[setKeyframeKey](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setKeyframeKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetKeyframeKeyParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[serde(rename = "range")]
+            pub range: SourceRange,
+            #[serde(rename = "keyText")]
+            pub key_text: String,
+        }
+        impl SetKeyframeKeyParams {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                range: impl Into<SourceRange>,
+                key_text: impl Into<String>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    range: range.into(),
+                    key_text: key_text.into(),
+                }
+            }
+        }
+        impl SetKeyframeKeyParams {
+            pub fn builder() -> SetKeyframeKeyParamsBuilder {
+                SetKeyframeKeyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetKeyframeKeyParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            range: Option<SourceRange>,
+            key_text: Option<String>,
+        }
+        impl SetKeyframeKeyParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn key_text(mut self, key_text: impl Into<String>) -> Self {
+                self.key_text = Some(key_text.into());
+                self
+            }
+            pub fn build(self) -> Result<SetKeyframeKeyParams, String> {
+                Ok(SetKeyframeKeyParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    range: self.range.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(range))
+                    })?,
+                    key_text: self.key_text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_text))
+                    })?,
+                })
+            }
+        }
+        impl SetKeyframeKeyParams {
+            pub const IDENTIFIER: &'static str = "CSS.setKeyframeKey";
+        }
+        impl chromiumoxide_types::Method for SetKeyframeKeyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetKeyframeKeyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Modifies the keyframe rule key text.\n[setKeyframeKey](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setKeyframeKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetKeyframeKeyReturns {
+            #[doc = "The resulting key text after modification."]
+            #[serde(rename = "keyText")]
+            pub key_text: Value,
+        }
+        impl SetKeyframeKeyReturns {
+            pub fn new(key_text: impl Into<Value>) -> Self {
+                Self {
+                    key_text: key_text.into(),
+                }
+            }
+        }
+        impl SetKeyframeKeyReturns {
+            pub fn builder() -> SetKeyframeKeyReturnsBuilder {
+                SetKeyframeKeyReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetKeyframeKeyReturnsBuilder {
+            key_text: Option<Value>,
+        }
+        impl SetKeyframeKeyReturnsBuilder {
+            pub fn key_text(mut self, key_text: impl Into<Value>) -> Self {
+                self.key_text = Some(key_text.into());
+                self
+            }
+            pub fn build(self) -> Result<SetKeyframeKeyReturns, String> {
+                Ok(SetKeyframeKeyReturns {
+                    key_text: self.key_text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_text))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetKeyframeKeyParams {
+            type Response = SetKeyframeKeyReturns;
+        }
+        #[doc = "Modifies the rule selector.\n[setMediaText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setMediaText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetMediaTextParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[serde(rename = "range")]
+            pub range: SourceRange,
+            #[serde(rename = "text")]
+            pub text: String,
+        }
+        impl SetMediaTextParams {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                range: impl Into<SourceRange>,
+                text: impl Into<String>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    range: range.into(),
+                    text: text.into(),
+                }
+            }
+        }
+        impl SetMediaTextParams {
+            pub fn builder() -> SetMediaTextParamsBuilder {
+                SetMediaTextParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetMediaTextParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            range: Option<SourceRange>,
+            text: Option<String>,
+        }
+        impl SetMediaTextParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn build(self) -> Result<SetMediaTextParams, String> {
+                Ok(SetMediaTextParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    range: self.range.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(range))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                })
+            }
+        }
+        impl SetMediaTextParams {
+            pub const IDENTIFIER: &'static str = "CSS.setMediaText";
+        }
+        impl chromiumoxide_types::Method for SetMediaTextParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetMediaTextParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Modifies the rule selector.\n[setMediaText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setMediaText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetMediaTextReturns {
+            #[doc = "The resulting CSS media rule after modification."]
+            #[serde(rename = "media")]
+            pub media: CssMedia,
+        }
+        impl SetMediaTextReturns {
+            pub fn new(media: impl Into<CssMedia>) -> Self {
+                Self {
+                    media: media.into(),
+                }
+            }
+        }
+        impl SetMediaTextReturns {
+            pub fn builder() -> SetMediaTextReturnsBuilder {
+                SetMediaTextReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetMediaTextReturnsBuilder {
+            media: Option<CssMedia>,
+        }
+        impl SetMediaTextReturnsBuilder {
+            pub fn media(mut self, media: impl Into<CssMedia>) -> Self {
+                self.media = Some(media.into());
+                self
+            }
+            pub fn build(self) -> Result<SetMediaTextReturns, String> {
+                Ok(SetMediaTextReturns {
+                    media: self.media.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(media))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetMediaTextParams {
+            type Response = SetMediaTextReturns;
+        }
+        #[doc = "Modifies the expression of a container query.\n[setContainerQueryText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setContainerQueryText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetContainerQueryTextParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[serde(rename = "range")]
+            pub range: SourceRange,
+            #[serde(rename = "text")]
+            pub text: String,
+        }
+        impl SetContainerQueryTextParams {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                range: impl Into<SourceRange>,
+                text: impl Into<String>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    range: range.into(),
+                    text: text.into(),
+                }
+            }
+        }
+        impl SetContainerQueryTextParams {
+            pub fn builder() -> SetContainerQueryTextParamsBuilder {
+                SetContainerQueryTextParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetContainerQueryTextParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            range: Option<SourceRange>,
+            text: Option<String>,
+        }
+        impl SetContainerQueryTextParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn build(self) -> Result<SetContainerQueryTextParams, String> {
+                Ok(SetContainerQueryTextParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    range: self.range.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(range))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                })
+            }
+        }
+        impl SetContainerQueryTextParams {
+            pub const IDENTIFIER: &'static str = "CSS.setContainerQueryText";
+        }
+        impl chromiumoxide_types::Method for SetContainerQueryTextParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetContainerQueryTextParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Modifies the expression of a container query.\n[setContainerQueryText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setContainerQueryText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetContainerQueryTextReturns {
+            #[doc = "The resulting CSS container query rule after modification."]
+            #[serde(rename = "containerQuery")]
+            pub container_query: CssContainerQuery,
+        }
+        impl SetContainerQueryTextReturns {
+            pub fn new(container_query: impl Into<CssContainerQuery>) -> Self {
+                Self {
+                    container_query: container_query.into(),
+                }
+            }
+        }
+        impl SetContainerQueryTextReturns {
+            pub fn builder() -> SetContainerQueryTextReturnsBuilder {
+                SetContainerQueryTextReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetContainerQueryTextReturnsBuilder {
+            container_query: Option<CssContainerQuery>,
+        }
+        impl SetContainerQueryTextReturnsBuilder {
+            pub fn container_query(
+                mut self,
+                container_query: impl Into<CssContainerQuery>,
+            ) -> Self {
+                self.container_query = Some(container_query.into());
+                self
+            }
+            pub fn build(self) -> Result<SetContainerQueryTextReturns, String> {
+                Ok(SetContainerQueryTextReturns {
+                    container_query: self.container_query.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(container_query))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetContainerQueryTextParams {
+            type Response = SetContainerQueryTextReturns;
+        }
+        #[doc = "Modifies the expression of a supports at-rule.\n[setSupportsText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setSupportsText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSupportsTextParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[serde(rename = "range")]
+            pub range: SourceRange,
+            #[serde(rename = "text")]
+            pub text: String,
+        }
+        impl SetSupportsTextParams {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                range: impl Into<SourceRange>,
+                text: impl Into<String>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    range: range.into(),
+                    text: text.into(),
+                }
+            }
+        }
+        impl SetSupportsTextParams {
+            pub fn builder() -> SetSupportsTextParamsBuilder {
+                SetSupportsTextParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSupportsTextParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            range: Option<SourceRange>,
+            text: Option<String>,
+        }
+        impl SetSupportsTextParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSupportsTextParams, String> {
+                Ok(SetSupportsTextParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    range: self.range.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(range))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                })
+            }
+        }
+        impl SetSupportsTextParams {
+            pub const IDENTIFIER: &'static str = "CSS.setSupportsText";
+        }
+        impl chromiumoxide_types::Method for SetSupportsTextParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSupportsTextParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Modifies the expression of a supports at-rule.\n[setSupportsText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setSupportsText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSupportsTextReturns {
+            #[doc = "The resulting CSS Supports rule after modification."]
+            #[serde(rename = "supports")]
+            pub supports: CssSupports,
+        }
+        impl SetSupportsTextReturns {
+            pub fn new(supports: impl Into<CssSupports>) -> Self {
+                Self {
+                    supports: supports.into(),
+                }
+            }
+        }
+        impl SetSupportsTextReturns {
+            pub fn builder() -> SetSupportsTextReturnsBuilder {
+                SetSupportsTextReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSupportsTextReturnsBuilder {
+            supports: Option<CssSupports>,
+        }
+        impl SetSupportsTextReturnsBuilder {
+            pub fn supports(mut self, supports: impl Into<CssSupports>) -> Self {
+                self.supports = Some(supports.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSupportsTextReturns, String> {
+                Ok(SetSupportsTextReturns {
+                    supports: self.supports.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(supports))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetSupportsTextParams {
+            type Response = SetSupportsTextReturns;
+        }
+        #[doc = "Modifies the expression of a scope at-rule.\n[setScopeText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setScopeText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetScopeTextParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[serde(rename = "range")]
+            pub range: SourceRange,
+            #[serde(rename = "text")]
+            pub text: String,
+        }
+        impl SetScopeTextParams {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                range: impl Into<SourceRange>,
+                text: impl Into<String>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    range: range.into(),
+                    text: text.into(),
+                }
+            }
+        }
+        impl SetScopeTextParams {
+            pub fn builder() -> SetScopeTextParamsBuilder {
+                SetScopeTextParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetScopeTextParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            range: Option<SourceRange>,
+            text: Option<String>,
+        }
+        impl SetScopeTextParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn build(self) -> Result<SetScopeTextParams, String> {
+                Ok(SetScopeTextParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    range: self.range.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(range))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                })
+            }
+        }
+        impl SetScopeTextParams {
+            pub const IDENTIFIER: &'static str = "CSS.setScopeText";
+        }
+        impl chromiumoxide_types::Method for SetScopeTextParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetScopeTextParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Modifies the expression of a scope at-rule.\n[setScopeText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setScopeText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetScopeTextReturns {
+            #[doc = "The resulting CSS Scope rule after modification."]
+            #[serde(rename = "scope")]
+            pub scope: CssScope,
+        }
+        impl SetScopeTextReturns {
+            pub fn new(scope: impl Into<CssScope>) -> Self {
+                Self {
+                    scope: scope.into(),
+                }
+            }
+        }
+        impl SetScopeTextReturns {
+            pub fn builder() -> SetScopeTextReturnsBuilder {
+                SetScopeTextReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetScopeTextReturnsBuilder {
+            scope: Option<CssScope>,
+        }
+        impl SetScopeTextReturnsBuilder {
+            pub fn scope(mut self, scope: impl Into<CssScope>) -> Self {
+                self.scope = Some(scope.into());
+                self
+            }
+            pub fn build(self) -> Result<SetScopeTextReturns, String> {
+                Ok(SetScopeTextReturns {
+                    scope: self.scope.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scope))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetScopeTextParams {
+            type Response = SetScopeTextReturns;
+        }
+        #[doc = "Modifies the rule selector.\n[setRuleSelector](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setRuleSelector)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetRuleSelectorParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[serde(rename = "range")]
+            pub range: SourceRange,
+            #[serde(rename = "selector")]
+            pub selector: String,
+        }
+        impl SetRuleSelectorParams {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                range: impl Into<SourceRange>,
+                selector: impl Into<String>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    range: range.into(),
+                    selector: selector.into(),
+                }
+            }
+        }
+        impl SetRuleSelectorParams {
+            pub fn builder() -> SetRuleSelectorParamsBuilder {
+                SetRuleSelectorParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetRuleSelectorParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            range: Option<SourceRange>,
+            selector: Option<String>,
+        }
+        impl SetRuleSelectorParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn range(mut self, range: impl Into<SourceRange>) -> Self {
+                self.range = Some(range.into());
+                self
+            }
+            pub fn selector(mut self, selector: impl Into<String>) -> Self {
+                self.selector = Some(selector.into());
+                self
+            }
+            pub fn build(self) -> Result<SetRuleSelectorParams, String> {
+                Ok(SetRuleSelectorParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    range: self.range.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(range))
+                    })?,
+                    selector: self.selector.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(selector))
+                    })?,
+                })
+            }
+        }
+        impl SetRuleSelectorParams {
+            pub const IDENTIFIER: &'static str = "CSS.setRuleSelector";
+        }
+        impl chromiumoxide_types::Method for SetRuleSelectorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetRuleSelectorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Modifies the rule selector.\n[setRuleSelector](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setRuleSelector)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetRuleSelectorReturns {
+            #[doc = "The resulting selector list after modification."]
+            #[serde(rename = "selectorList")]
+            pub selector_list: SelectorList,
+        }
+        impl SetRuleSelectorReturns {
+            pub fn new(selector_list: impl Into<SelectorList>) -> Self {
+                Self {
+                    selector_list: selector_list.into(),
+                }
+            }
+        }
+        impl SetRuleSelectorReturns {
+            pub fn builder() -> SetRuleSelectorReturnsBuilder {
+                SetRuleSelectorReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetRuleSelectorReturnsBuilder {
+            selector_list: Option<SelectorList>,
+        }
+        impl SetRuleSelectorReturnsBuilder {
+            pub fn selector_list(mut self, selector_list: impl Into<SelectorList>) -> Self {
+                self.selector_list = Some(selector_list.into());
+                self
+            }
+            pub fn build(self) -> Result<SetRuleSelectorReturns, String> {
+                Ok(SetRuleSelectorReturns {
+                    selector_list: self.selector_list.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(selector_list))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetRuleSelectorParams {
+            type Response = SetRuleSelectorReturns;
+        }
+        #[doc = "Sets the new stylesheet text.\n[setStyleSheetText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setStyleSheetText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetStyleSheetTextParams {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+            #[serde(rename = "text")]
+            pub text: String,
+        }
+        impl SetStyleSheetTextParams {
+            pub fn new(
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+                text: impl Into<String>,
+            ) -> Self {
+                Self {
+                    style_sheet_id: style_sheet_id.into(),
+                    text: text.into(),
+                }
+            }
+        }
+        impl SetStyleSheetTextParams {
+            pub fn builder() -> SetStyleSheetTextParamsBuilder {
+                SetStyleSheetTextParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetStyleSheetTextParamsBuilder {
+            style_sheet_id: Option<super::dom::StyleSheetId>,
+            text: Option<String>,
+        }
+        impl SetStyleSheetTextParamsBuilder {
+            pub fn style_sheet_id(
+                mut self,
+                style_sheet_id: impl Into<super::dom::StyleSheetId>,
+            ) -> Self {
+                self.style_sheet_id = Some(style_sheet_id.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn build(self) -> Result<SetStyleSheetTextParams, String> {
+                Ok(SetStyleSheetTextParams {
+                    style_sheet_id: self.style_sheet_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(style_sheet_id))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                })
+            }
+        }
+        impl SetStyleSheetTextParams {
+            pub const IDENTIFIER: &'static str = "CSS.setStyleSheetText";
+        }
+        impl chromiumoxide_types::Method for SetStyleSheetTextParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetStyleSheetTextParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets the new stylesheet text.\n[setStyleSheetText](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setStyleSheetText)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetStyleSheetTextReturns {
+            #[doc = "URL of source map associated with script (if any)."]
+            #[serde(rename = "sourceMapURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_map_url: Option<String>,
+        }
+        impl SetStyleSheetTextReturns {
+            pub fn builder() -> SetStyleSheetTextReturnsBuilder {
+                SetStyleSheetTextReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetStyleSheetTextReturnsBuilder {
+            source_map_url: Option<String>,
+        }
+        impl SetStyleSheetTextReturnsBuilder {
+            pub fn source_map_url(mut self, source_map_url: impl Into<String>) -> Self {
+                self.source_map_url = Some(source_map_url.into());
+                self
+            }
+            pub fn build(self) -> SetStyleSheetTextReturns {
+                SetStyleSheetTextReturns {
+                    source_map_url: self.source_map_url,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for SetStyleSheetTextParams {
+            type Response = SetStyleSheetTextReturns;
+        }
+        #[doc = "Applies specified style edits one after another in the given order.\n[setStyleTexts](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setStyleTexts)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetStyleTextsParams {
+            #[serde(rename = "edits")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub edits: Vec<StyleDeclarationEdit>,
+            #[doc = "NodeId for the DOM node in whose context custom property declarations for registered properties should be\nvalidated. If omitted, declarations in the new rule text can only be validated statically, which may produce\nincorrect results if the declaration contains a var() for example."]
+            #[serde(rename = "nodeForPropertySyntaxValidation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_for_property_syntax_validation: Option<super::dom::NodeId>,
+        }
+        impl SetStyleTextsParams {
+            pub fn new(edits: Vec<StyleDeclarationEdit>) -> Self {
+                Self {
+                    edits,
+                    node_for_property_syntax_validation: None,
+                }
+            }
+        }
+        impl SetStyleTextsParams {
+            pub fn builder() -> SetStyleTextsParamsBuilder {
+                SetStyleTextsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetStyleTextsParamsBuilder {
+            edits: Option<Vec<StyleDeclarationEdit>>,
+            node_for_property_syntax_validation: Option<super::dom::NodeId>,
+        }
+        impl SetStyleTextsParamsBuilder {
+            pub fn edit(mut self, edit: impl Into<StyleDeclarationEdit>) -> Self {
+                let v = self.edits.get_or_insert(Vec::new());
+                v.push(edit.into());
+                self
+            }
+            pub fn edits<I, S>(mut self, edits: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<StyleDeclarationEdit>,
+            {
+                let v = self.edits.get_or_insert(Vec::new());
+                for val in edits {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn node_for_property_syntax_validation(
+                mut self,
+                node_for_property_syntax_validation: impl Into<super::dom::NodeId>,
+            ) -> Self {
+                self.node_for_property_syntax_validation =
+                    Some(node_for_property_syntax_validation.into());
+                self
+            }
+            pub fn build(self) -> Result<SetStyleTextsParams, String> {
+                Ok(SetStyleTextsParams {
+                    edits: self.edits.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(edits))
+                    })?,
+                    node_for_property_syntax_validation: self.node_for_property_syntax_validation,
+                })
+            }
+        }
+        impl SetStyleTextsParams {
+            pub const IDENTIFIER: &'static str = "CSS.setStyleTexts";
+        }
+        impl chromiumoxide_types::Method for SetStyleTextsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetStyleTextsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Applies specified style edits one after another in the given order.\n[setStyleTexts](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setStyleTexts)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetStyleTextsReturns {
+            #[doc = "The resulting styles after modification."]
+            #[serde(rename = "styles")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub styles: Vec<CssStyle>,
+        }
+        impl SetStyleTextsReturns {
+            pub fn new(styles: Vec<CssStyle>) -> Self {
+                Self { styles }
+            }
+        }
+        impl SetStyleTextsReturns {
+            pub fn builder() -> SetStyleTextsReturnsBuilder {
+                SetStyleTextsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetStyleTextsReturnsBuilder {
+            styles: Option<Vec<CssStyle>>,
+        }
+        impl SetStyleTextsReturnsBuilder {
+            pub fn style(mut self, style: impl Into<CssStyle>) -> Self {
+                let v = self.styles.get_or_insert(Vec::new());
+                v.push(style.into());
+                self
+            }
+            pub fn styles<I, S>(mut self, styles: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssStyle>,
+            {
+                let v = self.styles.get_or_insert(Vec::new());
+                for val in styles {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetStyleTextsReturns, String> {
+                Ok(SetStyleTextsReturns {
+                    styles: self.styles.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(styles))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetStyleTextsParams {
+            type Response = SetStyleTextsReturns;
+        }
+        #[doc = "Enables the selector recording.\n[startRuleUsageTracking](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-startRuleUsageTracking)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartRuleUsageTrackingParams {}
+        impl StartRuleUsageTrackingParams {
+            pub const IDENTIFIER: &'static str = "CSS.startRuleUsageTracking";
+        }
+        impl chromiumoxide_types::Method for StartRuleUsageTrackingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartRuleUsageTrackingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables the selector recording.\n[startRuleUsageTracking](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-startRuleUsageTracking)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartRuleUsageTrackingReturns {}
+        impl chromiumoxide_types::Command for StartRuleUsageTrackingParams {
+            type Response = StartRuleUsageTrackingReturns;
+        }
+        #[doc = "Stop tracking rule usage and return the list of rules that were used since last call to\n`takeCoverageDelta` (or since start of coverage instrumentation).\n[stopRuleUsageTracking](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-stopRuleUsageTracking)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopRuleUsageTrackingParams {}
+        impl StopRuleUsageTrackingParams {
+            pub const IDENTIFIER: &'static str = "CSS.stopRuleUsageTracking";
+        }
+        impl chromiumoxide_types::Method for StopRuleUsageTrackingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopRuleUsageTrackingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Stop tracking rule usage and return the list of rules that were used since last call to\n`takeCoverageDelta` (or since start of coverage instrumentation).\n[stopRuleUsageTracking](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-stopRuleUsageTracking)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StopRuleUsageTrackingReturns {
+            #[serde(rename = "ruleUsage")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub rule_usage: Vec<RuleUsage>,
+        }
+        impl StopRuleUsageTrackingReturns {
+            pub fn new(rule_usage: Vec<RuleUsage>) -> Self {
+                Self { rule_usage }
+            }
+        }
+        impl StopRuleUsageTrackingReturns {
+            pub fn builder() -> StopRuleUsageTrackingReturnsBuilder {
+                StopRuleUsageTrackingReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StopRuleUsageTrackingReturnsBuilder {
+            rule_usage: Option<Vec<RuleUsage>>,
+        }
+        impl StopRuleUsageTrackingReturnsBuilder {
+            pub fn rule_usage(mut self, rule_usage: impl Into<RuleUsage>) -> Self {
+                let v = self.rule_usage.get_or_insert(Vec::new());
+                v.push(rule_usage.into());
+                self
+            }
+            pub fn rule_usages<I, S>(mut self, rule_usages: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<RuleUsage>,
+            {
+                let v = self.rule_usage.get_or_insert(Vec::new());
+                for val in rule_usages {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<StopRuleUsageTrackingReturns, String> {
+                Ok(StopRuleUsageTrackingReturns {
+                    rule_usage: self.rule_usage.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rule_usage))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for StopRuleUsageTrackingParams {
+            type Response = StopRuleUsageTrackingReturns;
+        }
+        #[doc = "Obtain list of rules that became used since last call to this method (or since start of coverage\ninstrumentation).\n[takeCoverageDelta](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-takeCoverageDelta)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TakeCoverageDeltaParams {}
+        impl TakeCoverageDeltaParams {
+            pub const IDENTIFIER: &'static str = "CSS.takeCoverageDelta";
+        }
+        impl chromiumoxide_types::Method for TakeCoverageDeltaParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TakeCoverageDeltaParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Obtain list of rules that became used since last call to this method (or since start of coverage\ninstrumentation).\n[takeCoverageDelta](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-takeCoverageDelta)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TakeCoverageDeltaReturns {
+            #[serde(rename = "coverage")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub coverage: Vec<RuleUsage>,
+            #[doc = "Monotonically increasing time, in seconds."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: f64,
+        }
+        impl TakeCoverageDeltaReturns {
+            pub fn new(coverage: Vec<RuleUsage>, timestamp: impl Into<f64>) -> Self {
+                Self {
+                    coverage,
+                    timestamp: timestamp.into(),
+                }
+            }
+        }
+        impl TakeCoverageDeltaReturns {
+            pub fn builder() -> TakeCoverageDeltaReturnsBuilder {
+                TakeCoverageDeltaReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TakeCoverageDeltaReturnsBuilder {
+            coverage: Option<Vec<RuleUsage>>,
+            timestamp: Option<f64>,
+        }
+        impl TakeCoverageDeltaReturnsBuilder {
+            pub fn coverage(mut self, coverage: impl Into<RuleUsage>) -> Self {
+                let v = self.coverage.get_or_insert(Vec::new());
+                v.push(coverage.into());
+                self
+            }
+            pub fn coverages<I, S>(mut self, coverages: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<RuleUsage>,
+            {
+                let v = self.coverage.get_or_insert(Vec::new());
+                for val in coverages {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn timestamp(mut self, timestamp: impl Into<f64>) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn build(self) -> Result<TakeCoverageDeltaReturns, String> {
+                Ok(TakeCoverageDeltaReturns {
+                    coverage: self.coverage.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(coverage))
+                    })?,
+                    timestamp: self.timestamp.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(timestamp))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for TakeCoverageDeltaParams {
+            type Response = TakeCoverageDeltaReturns;
+        }
+        #[doc = "Enables/disables rendering of local CSS fonts (enabled by default).\n[setLocalFontsEnabled](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setLocalFontsEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetLocalFontsEnabledParams {
+            #[doc = "Whether rendering of local fonts is enabled."]
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetLocalFontsEnabledParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetLocalFontsEnabledParams {
+            pub fn builder() -> SetLocalFontsEnabledParamsBuilder {
+                SetLocalFontsEnabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetLocalFontsEnabledParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetLocalFontsEnabledParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetLocalFontsEnabledParams, String> {
+                Ok(SetLocalFontsEnabledParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetLocalFontsEnabledParams {
+            pub const IDENTIFIER: &'static str = "CSS.setLocalFontsEnabled";
+        }
+        impl chromiumoxide_types::Method for SetLocalFontsEnabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetLocalFontsEnabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables/disables rendering of local CSS fonts (enabled by default).\n[setLocalFontsEnabled](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#method-setLocalFontsEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetLocalFontsEnabledReturns {}
+        impl chromiumoxide_types::Command for SetLocalFontsEnabledParams {
+            type Response = SetLocalFontsEnabledReturns;
+        }
+        #[doc = "Fires whenever a web font is updated.  A non-empty font parameter indicates a successfully loaded\nweb font.\n[fontsUpdated](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#event-fontsUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventFontsUpdated {
+            #[doc = "The web font that has loaded."]
+            #[serde(rename = "font")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub font: Option<FontFace>,
+        }
+        impl EventFontsUpdated {
+            pub const IDENTIFIER: &'static str = "CSS.fontsUpdated";
+        }
+        impl chromiumoxide_types::Method for EventFontsUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFontsUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fires whenever a MediaQuery result changes (for example, after a browser window has been\nresized.) The current implementation considers only viewport-dependent media features.\n[mediaQueryResultChanged](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#event-mediaQueryResultChanged)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventMediaQueryResultChanged {}
+        impl EventMediaQueryResultChanged {
+            pub const IDENTIFIER: &'static str = "CSS.mediaQueryResultChanged";
+        }
+        impl chromiumoxide_types::Method for EventMediaQueryResultChanged {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventMediaQueryResultChanged {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired whenever an active document stylesheet is added.\n[styleSheetAdded](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#event-styleSheetAdded)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventStyleSheetAdded {
+            #[doc = "Added stylesheet metainfo."]
+            #[serde(rename = "header")]
+            pub header: CssStyleSheetHeader,
+        }
+        impl EventStyleSheetAdded {
+            pub const IDENTIFIER: &'static str = "CSS.styleSheetAdded";
+        }
+        impl chromiumoxide_types::Method for EventStyleSheetAdded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventStyleSheetAdded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired whenever a stylesheet is changed as a result of the client operation.\n[styleSheetChanged](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#event-styleSheetChanged)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventStyleSheetChanged {
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+        }
+        impl EventStyleSheetChanged {
+            pub const IDENTIFIER: &'static str = "CSS.styleSheetChanged";
+        }
+        impl chromiumoxide_types::Method for EventStyleSheetChanged {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventStyleSheetChanged {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired whenever an active document stylesheet is removed.\n[styleSheetRemoved](https://chromedevtools.github.io/devtools-protocol/tot/CSS/#event-styleSheetRemoved)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventStyleSheetRemoved {
+            #[doc = "Identifier of the removed stylesheet."]
+            #[serde(rename = "styleSheetId")]
+            pub style_sheet_id: super::dom::StyleSheetId,
+        }
+        impl EventStyleSheetRemoved {
+            pub const IDENTIFIER: &'static str = "CSS.styleSheetRemoved";
+        }
+        impl chromiumoxide_types::Method for EventStyleSheetRemoved {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventStyleSheetRemoved {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventComputedStyleUpdated {
+            #[doc = "The node id that has updated computed styles."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl EventComputedStyleUpdated {
+            pub const IDENTIFIER: &'static str = "CSS.computedStyleUpdated";
+        }
+        impl chromiumoxide_types::Method for EventComputedStyleUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventComputedStyleUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod cache_storage {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Unique identifier of the Cache object.\n[CacheId](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#type-CacheId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct CacheId(String);
+        impl CacheId {
+            pub fn new(val: impl Into<String>) -> Self {
+                CacheId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for CacheId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<CacheId> for String {
+            fn from(el: CacheId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for CacheId {
+            fn from(expr: String) -> Self {
+                CacheId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for CacheId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl CacheId {
+            pub const IDENTIFIER: &'static str = "CacheStorage.CacheId";
+        }
+        #[doc = "type of HTTP response cached"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CachedResponseType {
+            #[serde(rename = "basic")]
+            Basic,
+            #[serde(rename = "cors")]
+            Cors,
+            #[serde(rename = "default")]
+            Default,
+            #[serde(rename = "error")]
+            Error,
+            #[serde(rename = "opaqueResponse")]
+            OpaqueResponse,
+            #[serde(rename = "opaqueRedirect")]
+            OpaqueRedirect,
+        }
+        impl AsRef<str> for CachedResponseType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CachedResponseType::Basic => "basic",
+                    CachedResponseType::Cors => "cors",
+                    CachedResponseType::Default => "default",
+                    CachedResponseType::Error => "error",
+                    CachedResponseType::OpaqueResponse => "opaqueResponse",
+                    CachedResponseType::OpaqueRedirect => "opaqueRedirect",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CachedResponseType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "basic" | "Basic" => Ok(CachedResponseType::Basic),
+                    "cors" | "Cors" => Ok(CachedResponseType::Cors),
+                    "default" | "Default" => Ok(CachedResponseType::Default),
+                    "error" | "Error" => Ok(CachedResponseType::Error),
+                    "opaqueResponse" | "OpaqueResponse" | "opaqueresponse" => {
+                        Ok(CachedResponseType::OpaqueResponse)
+                    }
+                    "opaqueRedirect" | "OpaqueRedirect" | "opaqueredirect" => {
+                        Ok(CachedResponseType::OpaqueRedirect)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Data entry.\n[DataEntry](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#type-DataEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DataEntry {
+            #[doc = "Request URL."]
+            #[serde(rename = "requestURL")]
+            pub request_url: String,
+            #[doc = "Request method."]
+            #[serde(rename = "requestMethod")]
+            pub request_method: String,
+            #[doc = "Request headers"]
+            #[serde(rename = "requestHeaders")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub request_headers: Vec<Header>,
+            #[doc = "Number of seconds since epoch."]
+            #[serde(rename = "responseTime")]
+            pub response_time: f64,
+            #[doc = "HTTP response status code."]
+            #[serde(rename = "responseStatus")]
+            pub response_status: i64,
+            #[doc = "HTTP response status text."]
+            #[serde(rename = "responseStatusText")]
+            pub response_status_text: String,
+            #[doc = "HTTP response type"]
+            #[serde(rename = "responseType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub response_type: CachedResponseType,
+            #[doc = "Response headers"]
+            #[serde(rename = "responseHeaders")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub response_headers: Vec<Header>,
+        }
+        impl DataEntry {
+            pub fn builder() -> DataEntryBuilder {
+                DataEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DataEntryBuilder {
+            request_url: Option<String>,
+            request_method: Option<String>,
+            request_headers: Option<Vec<Header>>,
+            response_time: Option<f64>,
+            response_status: Option<i64>,
+            response_status_text: Option<String>,
+            response_type: Option<CachedResponseType>,
+            response_headers: Option<Vec<Header>>,
+        }
+        impl DataEntryBuilder {
+            pub fn request_url(mut self, request_url: impl Into<String>) -> Self {
+                self.request_url = Some(request_url.into());
+                self
+            }
+            pub fn request_method(mut self, request_method: impl Into<String>) -> Self {
+                self.request_method = Some(request_method.into());
+                self
+            }
+            pub fn request_header(mut self, request_header: impl Into<Header>) -> Self {
+                let v = self.request_headers.get_or_insert(Vec::new());
+                v.push(request_header.into());
+                self
+            }
+            pub fn request_headers<I, S>(mut self, request_headers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Header>,
+            {
+                let v = self.request_headers.get_or_insert(Vec::new());
+                for val in request_headers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn response_time(mut self, response_time: impl Into<f64>) -> Self {
+                self.response_time = Some(response_time.into());
+                self
+            }
+            pub fn response_status(mut self, response_status: impl Into<i64>) -> Self {
+                self.response_status = Some(response_status.into());
+                self
+            }
+            pub fn response_status_text(mut self, response_status_text: impl Into<String>) -> Self {
+                self.response_status_text = Some(response_status_text.into());
+                self
+            }
+            pub fn response_type(mut self, response_type: impl Into<CachedResponseType>) -> Self {
+                self.response_type = Some(response_type.into());
+                self
+            }
+            pub fn response_header(mut self, response_header: impl Into<Header>) -> Self {
+                let v = self.response_headers.get_or_insert(Vec::new());
+                v.push(response_header.into());
+                self
+            }
+            pub fn response_headers<I, S>(mut self, response_headers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Header>,
+            {
+                let v = self.response_headers.get_or_insert(Vec::new());
+                for val in response_headers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<DataEntry, String> {
+                Ok(DataEntry {
+                    request_url: self.request_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_url))
+                    })?,
+                    request_method: self.request_method.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_method))
+                    })?,
+                    request_headers: self.request_headers.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_headers))
+                    })?,
+                    response_time: self.response_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(response_time))
+                    })?,
+                    response_status: self.response_status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(response_status))
+                    })?,
+                    response_status_text: self.response_status_text.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(response_status_text)
+                        )
+                    })?,
+                    response_type: self.response_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(response_type))
+                    })?,
+                    response_headers: self.response_headers.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(response_headers)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl DataEntry {
+            pub const IDENTIFIER: &'static str = "CacheStorage.DataEntry";
+        }
+        #[doc = "Cache identifier.\n[Cache](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#type-Cache)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Cache {
+            #[doc = "An opaque unique id of the cache."]
+            #[serde(rename = "cacheId")]
+            pub cache_id: CacheId,
+            #[doc = "Security origin of the cache."]
+            #[serde(rename = "securityOrigin")]
+            pub security_origin: String,
+            #[doc = "Storage key of the cache."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+            #[doc = "Storage bucket of the cache."]
+            #[serde(rename = "storageBucket")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_bucket: Option<super::storage::StorageBucket>,
+            #[doc = "The name of the cache."]
+            #[serde(rename = "cacheName")]
+            pub cache_name: String,
+        }
+        impl Cache {
+            pub fn new(
+                cache_id: impl Into<CacheId>,
+                security_origin: impl Into<String>,
+                storage_key: impl Into<String>,
+                cache_name: impl Into<String>,
+            ) -> Self {
+                Self {
+                    cache_id: cache_id.into(),
+                    security_origin: security_origin.into(),
+                    storage_key: storage_key.into(),
+                    cache_name: cache_name.into(),
+                    storage_bucket: None,
+                }
+            }
+        }
+        impl Cache {
+            pub fn builder() -> CacheBuilder {
+                CacheBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CacheBuilder {
+            cache_id: Option<CacheId>,
+            security_origin: Option<String>,
+            storage_key: Option<String>,
+            storage_bucket: Option<super::storage::StorageBucket>,
+            cache_name: Option<String>,
+        }
+        impl CacheBuilder {
+            pub fn cache_id(mut self, cache_id: impl Into<CacheId>) -> Self {
+                self.cache_id = Some(cache_id.into());
+                self
+            }
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn storage_bucket(
+                mut self,
+                storage_bucket: impl Into<super::storage::StorageBucket>,
+            ) -> Self {
+                self.storage_bucket = Some(storage_bucket.into());
+                self
+            }
+            pub fn cache_name(mut self, cache_name: impl Into<String>) -> Self {
+                self.cache_name = Some(cache_name.into());
+                self
+            }
+            pub fn build(self) -> Result<Cache, String> {
+                Ok(Cache {
+                    cache_id: self.cache_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cache_id))
+                    })?,
+                    security_origin: self.security_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(security_origin))
+                    })?,
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                    storage_bucket: self.storage_bucket,
+                    cache_name: self.cache_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cache_name))
+                    })?,
+                })
+            }
+        }
+        impl Cache {
+            pub const IDENTIFIER: &'static str = "CacheStorage.Cache";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Header {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl Header {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl Header {
+            pub fn builder() -> HeaderBuilder {
+                HeaderBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HeaderBuilder {
+            name: Option<String>,
+            value: Option<String>,
+        }
+        impl HeaderBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<Header, String> {
+                Ok(Header {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl Header {
+            pub const IDENTIFIER: &'static str = "CacheStorage.Header";
+        }
+        #[doc = "Cached response\n[CachedResponse](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#type-CachedResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CachedResponse {
+            #[doc = "Entry content, base64-encoded."]
+            #[serde(rename = "body")]
+            pub body: chromiumoxide_types::Binary,
+        }
+        impl CachedResponse {
+            pub fn new(body: impl Into<chromiumoxide_types::Binary>) -> Self {
+                Self { body: body.into() }
+            }
+        }
+        impl CachedResponse {
+            pub fn builder() -> CachedResponseBuilder {
+                CachedResponseBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CachedResponseBuilder {
+            body: Option<chromiumoxide_types::Binary>,
+        }
+        impl CachedResponseBuilder {
+            pub fn body(mut self, body: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.body = Some(body.into());
+                self
+            }
+            pub fn build(self) -> Result<CachedResponse, String> {
+                Ok(CachedResponse {
+                    body: self.body.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(body))
+                    })?,
+                })
+            }
+        }
+        impl CachedResponse {
+            pub const IDENTIFIER: &'static str = "CacheStorage.CachedResponse";
+        }
+        #[doc = "Deletes a cache.\n[deleteCache](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#method-deleteCache)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeleteCacheParams {
+            #[doc = "Id of cache for deletion."]
+            #[serde(rename = "cacheId")]
+            pub cache_id: CacheId,
+        }
+        impl DeleteCacheParams {
+            pub fn new(cache_id: impl Into<CacheId>) -> Self {
+                Self {
+                    cache_id: cache_id.into(),
+                }
+            }
+        }
+        impl DeleteCacheParams {
+            pub fn builder() -> DeleteCacheParamsBuilder {
+                DeleteCacheParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeleteCacheParamsBuilder {
+            cache_id: Option<CacheId>,
+        }
+        impl DeleteCacheParamsBuilder {
+            pub fn cache_id(mut self, cache_id: impl Into<CacheId>) -> Self {
+                self.cache_id = Some(cache_id.into());
+                self
+            }
+            pub fn build(self) -> Result<DeleteCacheParams, String> {
+                Ok(DeleteCacheParams {
+                    cache_id: self.cache_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cache_id))
+                    })?,
+                })
+            }
+        }
+        impl DeleteCacheParams {
+            pub const IDENTIFIER: &'static str = "CacheStorage.deleteCache";
+        }
+        impl chromiumoxide_types::Method for DeleteCacheParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DeleteCacheParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Deletes a cache.\n[deleteCache](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#method-deleteCache)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DeleteCacheReturns {}
+        impl chromiumoxide_types::Command for DeleteCacheParams {
+            type Response = DeleteCacheReturns;
+        }
+        #[doc = "Deletes a cache entry.\n[deleteEntry](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#method-deleteEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeleteEntryParams {
+            #[doc = "Id of cache where the entry will be deleted."]
+            #[serde(rename = "cacheId")]
+            pub cache_id: CacheId,
+            #[doc = "URL spec of the request."]
+            #[serde(rename = "request")]
+            pub request: String,
+        }
+        impl DeleteEntryParams {
+            pub fn new(cache_id: impl Into<CacheId>, request: impl Into<String>) -> Self {
+                Self {
+                    cache_id: cache_id.into(),
+                    request: request.into(),
+                }
+            }
+        }
+        impl DeleteEntryParams {
+            pub fn builder() -> DeleteEntryParamsBuilder {
+                DeleteEntryParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeleteEntryParamsBuilder {
+            cache_id: Option<CacheId>,
+            request: Option<String>,
+        }
+        impl DeleteEntryParamsBuilder {
+            pub fn cache_id(mut self, cache_id: impl Into<CacheId>) -> Self {
+                self.cache_id = Some(cache_id.into());
+                self
+            }
+            pub fn request(mut self, request: impl Into<String>) -> Self {
+                self.request = Some(request.into());
+                self
+            }
+            pub fn build(self) -> Result<DeleteEntryParams, String> {
+                Ok(DeleteEntryParams {
+                    cache_id: self.cache_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cache_id))
+                    })?,
+                    request: self.request.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request))
+                    })?,
+                })
+            }
+        }
+        impl DeleteEntryParams {
+            pub const IDENTIFIER: &'static str = "CacheStorage.deleteEntry";
+        }
+        impl chromiumoxide_types::Method for DeleteEntryParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DeleteEntryParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Deletes a cache entry.\n[deleteEntry](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#method-deleteEntry)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DeleteEntryReturns {}
+        impl chromiumoxide_types::Command for DeleteEntryParams {
+            type Response = DeleteEntryReturns;
+        }
+        #[doc = "Requests cache names.\n[requestCacheNames](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#method-requestCacheNames)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RequestCacheNamesParams {
+            #[doc = "At least and at most one of securityOrigin, storageKey, storageBucket must be specified.\nSecurity origin."]
+            #[serde(rename = "securityOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_origin: Option<String>,
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_key: Option<String>,
+            #[doc = "Storage bucket. If not specified, it uses the default bucket."]
+            #[serde(rename = "storageBucket")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_bucket: Option<super::storage::StorageBucket>,
+        }
+        impl RequestCacheNamesParams {
+            pub fn builder() -> RequestCacheNamesParamsBuilder {
+                RequestCacheNamesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestCacheNamesParamsBuilder {
+            security_origin: Option<String>,
+            storage_key: Option<String>,
+            storage_bucket: Option<super::storage::StorageBucket>,
+        }
+        impl RequestCacheNamesParamsBuilder {
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn storage_bucket(
+                mut self,
+                storage_bucket: impl Into<super::storage::StorageBucket>,
+            ) -> Self {
+                self.storage_bucket = Some(storage_bucket.into());
+                self
+            }
+            pub fn build(self) -> RequestCacheNamesParams {
+                RequestCacheNamesParams {
+                    security_origin: self.security_origin,
+                    storage_key: self.storage_key,
+                    storage_bucket: self.storage_bucket,
+                }
+            }
+        }
+        impl RequestCacheNamesParams {
+            pub const IDENTIFIER: &'static str = "CacheStorage.requestCacheNames";
+        }
+        impl chromiumoxide_types::Method for RequestCacheNamesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RequestCacheNamesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests cache names.\n[requestCacheNames](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#method-requestCacheNames)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestCacheNamesReturns {
+            #[doc = "Caches for the security origin."]
+            #[serde(rename = "caches")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub caches: Vec<Cache>,
+        }
+        impl RequestCacheNamesReturns {
+            pub fn new(caches: Vec<Cache>) -> Self {
+                Self { caches }
+            }
+        }
+        impl RequestCacheNamesReturns {
+            pub fn builder() -> RequestCacheNamesReturnsBuilder {
+                RequestCacheNamesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestCacheNamesReturnsBuilder {
+            caches: Option<Vec<Cache>>,
+        }
+        impl RequestCacheNamesReturnsBuilder {
+            pub fn cache(mut self, cache: impl Into<Cache>) -> Self {
+                let v = self.caches.get_or_insert(Vec::new());
+                v.push(cache.into());
+                self
+            }
+            pub fn caches<I, S>(mut self, caches: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Cache>,
+            {
+                let v = self.caches.get_or_insert(Vec::new());
+                for val in caches {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<RequestCacheNamesReturns, String> {
+                Ok(RequestCacheNamesReturns {
+                    caches: self.caches.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(caches))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for RequestCacheNamesParams {
+            type Response = RequestCacheNamesReturns;
+        }
+        #[doc = "Fetches cache entry.\n[requestCachedResponse](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#method-requestCachedResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestCachedResponseParams {
+            #[doc = "Id of cache that contains the entry."]
+            #[serde(rename = "cacheId")]
+            pub cache_id: CacheId,
+            #[doc = "URL spec of the request."]
+            #[serde(rename = "requestURL")]
+            pub request_url: String,
+            #[doc = "headers of the request."]
+            #[serde(rename = "requestHeaders")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub request_headers: Vec<Header>,
+        }
+        impl RequestCachedResponseParams {
+            pub fn new(
+                cache_id: impl Into<CacheId>,
+                request_url: impl Into<String>,
+                request_headers: Vec<Header>,
+            ) -> Self {
+                Self {
+                    cache_id: cache_id.into(),
+                    request_url: request_url.into(),
+                    request_headers,
+                }
+            }
+        }
+        impl RequestCachedResponseParams {
+            pub fn builder() -> RequestCachedResponseParamsBuilder {
+                RequestCachedResponseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestCachedResponseParamsBuilder {
+            cache_id: Option<CacheId>,
+            request_url: Option<String>,
+            request_headers: Option<Vec<Header>>,
+        }
+        impl RequestCachedResponseParamsBuilder {
+            pub fn cache_id(mut self, cache_id: impl Into<CacheId>) -> Self {
+                self.cache_id = Some(cache_id.into());
+                self
+            }
+            pub fn request_url(mut self, request_url: impl Into<String>) -> Self {
+                self.request_url = Some(request_url.into());
+                self
+            }
+            pub fn request_header(mut self, request_header: impl Into<Header>) -> Self {
+                let v = self.request_headers.get_or_insert(Vec::new());
+                v.push(request_header.into());
+                self
+            }
+            pub fn request_headers<I, S>(mut self, request_headers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Header>,
+            {
+                let v = self.request_headers.get_or_insert(Vec::new());
+                for val in request_headers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<RequestCachedResponseParams, String> {
+                Ok(RequestCachedResponseParams {
+                    cache_id: self.cache_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cache_id))
+                    })?,
+                    request_url: self.request_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_url))
+                    })?,
+                    request_headers: self.request_headers.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_headers))
+                    })?,
+                })
+            }
+        }
+        impl RequestCachedResponseParams {
+            pub const IDENTIFIER: &'static str = "CacheStorage.requestCachedResponse";
+        }
+        impl chromiumoxide_types::Method for RequestCachedResponseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RequestCachedResponseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fetches cache entry.\n[requestCachedResponse](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#method-requestCachedResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestCachedResponseReturns {
+            #[doc = "Response read from the cache."]
+            #[serde(rename = "response")]
+            pub response: CachedResponse,
+        }
+        impl RequestCachedResponseReturns {
+            pub fn new(response: impl Into<CachedResponse>) -> Self {
+                Self {
+                    response: response.into(),
+                }
+            }
+        }
+        impl RequestCachedResponseReturns {
+            pub fn builder() -> RequestCachedResponseReturnsBuilder {
+                RequestCachedResponseReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestCachedResponseReturnsBuilder {
+            response: Option<CachedResponse>,
+        }
+        impl RequestCachedResponseReturnsBuilder {
+            pub fn response(mut self, response: impl Into<CachedResponse>) -> Self {
+                self.response = Some(response.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestCachedResponseReturns, String> {
+                Ok(RequestCachedResponseReturns {
+                    response: self.response.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(response))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for RequestCachedResponseParams {
+            type Response = RequestCachedResponseReturns;
+        }
+        #[doc = "Requests data from cache.\n[requestEntries](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#method-requestEntries)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestEntriesParams {
+            #[doc = "ID of cache to get entries from."]
+            #[serde(rename = "cacheId")]
+            pub cache_id: CacheId,
+            #[doc = "Number of records to skip."]
+            #[serde(rename = "skipCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub skip_count: Option<i64>,
+            #[doc = "Number of records to fetch."]
+            #[serde(rename = "pageSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub page_size: Option<i64>,
+            #[doc = "If present, only return the entries containing this substring in the path"]
+            #[serde(rename = "pathFilter")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub path_filter: Option<String>,
+        }
+        impl RequestEntriesParams {
+            pub fn new(cache_id: impl Into<CacheId>) -> Self {
+                Self {
+                    cache_id: cache_id.into(),
+                    skip_count: None,
+                    page_size: None,
+                    path_filter: None,
+                }
+            }
+        }
+        impl RequestEntriesParams {
+            pub fn builder() -> RequestEntriesParamsBuilder {
+                RequestEntriesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestEntriesParamsBuilder {
+            cache_id: Option<CacheId>,
+            skip_count: Option<i64>,
+            page_size: Option<i64>,
+            path_filter: Option<String>,
+        }
+        impl RequestEntriesParamsBuilder {
+            pub fn cache_id(mut self, cache_id: impl Into<CacheId>) -> Self {
+                self.cache_id = Some(cache_id.into());
+                self
+            }
+            pub fn skip_count(mut self, skip_count: impl Into<i64>) -> Self {
+                self.skip_count = Some(skip_count.into());
+                self
+            }
+            pub fn page_size(mut self, page_size: impl Into<i64>) -> Self {
+                self.page_size = Some(page_size.into());
+                self
+            }
+            pub fn path_filter(mut self, path_filter: impl Into<String>) -> Self {
+                self.path_filter = Some(path_filter.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestEntriesParams, String> {
+                Ok(RequestEntriesParams {
+                    cache_id: self.cache_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cache_id))
+                    })?,
+                    skip_count: self.skip_count,
+                    page_size: self.page_size,
+                    path_filter: self.path_filter,
+                })
+            }
+        }
+        impl RequestEntriesParams {
+            pub const IDENTIFIER: &'static str = "CacheStorage.requestEntries";
+        }
+        impl chromiumoxide_types::Method for RequestEntriesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RequestEntriesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests data from cache.\n[requestEntries](https://chromedevtools.github.io/devtools-protocol/tot/CacheStorage/#method-requestEntries)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestEntriesReturns {
+            #[doc = "Array of object store data entries."]
+            #[serde(rename = "cacheDataEntries")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub cache_data_entries: Vec<DataEntry>,
+            #[doc = "Count of returned entries from this storage. If pathFilter is empty, it\nis the count of all entries from this storage."]
+            #[serde(rename = "returnCount")]
+            pub return_count: f64,
+        }
+        impl RequestEntriesReturns {
+            pub fn new(cache_data_entries: Vec<DataEntry>, return_count: impl Into<f64>) -> Self {
+                Self {
+                    cache_data_entries,
+                    return_count: return_count.into(),
+                }
+            }
+        }
+        impl RequestEntriesReturns {
+            pub fn builder() -> RequestEntriesReturnsBuilder {
+                RequestEntriesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestEntriesReturnsBuilder {
+            cache_data_entries: Option<Vec<DataEntry>>,
+            return_count: Option<f64>,
+        }
+        impl RequestEntriesReturnsBuilder {
+            pub fn cache_data_entrie(mut self, cache_data_entrie: impl Into<DataEntry>) -> Self {
+                let v = self.cache_data_entries.get_or_insert(Vec::new());
+                v.push(cache_data_entrie.into());
+                self
+            }
+            pub fn cache_data_entries<I, S>(mut self, cache_data_entries: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<DataEntry>,
+            {
+                let v = self.cache_data_entries.get_or_insert(Vec::new());
+                for val in cache_data_entries {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn return_count(mut self, return_count: impl Into<f64>) -> Self {
+                self.return_count = Some(return_count.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestEntriesReturns, String> {
+                Ok(RequestEntriesReturns {
+                    cache_data_entries: self.cache_data_entries.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(cache_data_entries)
+                        )
+                    })?,
+                    return_count: self.return_count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(return_count))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for RequestEntriesParams {
+            type Response = RequestEntriesReturns;
+        }
+    }
+    #[doc = "A domain for interacting with Cast, Presentation API, and Remote Playback API\nfunctionalities."]
+    pub mod cast {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Sink {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "id")]
+            pub id: String,
+            #[doc = "Text describing the current session. Present only if there is an active\nsession on the sink."]
+            #[serde(rename = "session")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub session: Option<String>,
+        }
+        impl Sink {
+            pub fn new(name: impl Into<String>, id: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    id: id.into(),
+                    session: None,
+                }
+            }
+        }
+        impl Sink {
+            pub fn builder() -> SinkBuilder {
+                SinkBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SinkBuilder {
+            name: Option<String>,
+            id: Option<String>,
+            session: Option<String>,
+        }
+        impl SinkBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn session(mut self, session: impl Into<String>) -> Self {
+                self.session = Some(session.into());
+                self
+            }
+            pub fn build(self) -> Result<Sink, String> {
+                Ok(Sink {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    session: self.session,
+                })
+            }
+        }
+        impl Sink {
+            pub const IDENTIFIER: &'static str = "Cast.Sink";
+        }
+        #[doc = "Starts observing for sinks that can be used for tab mirroring, and if set,\nsinks compatible with |presentationUrl| as well. When sinks are found, a\n|sinksUpdated| event is fired.\nAlso starts observing for issue messages. When an issue is added or removed,\nan |issueUpdated| event is fired.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[serde(rename = "presentationUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub presentation_url: Option<String>,
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            presentation_url: Option<String>,
+        }
+        impl EnableParamsBuilder {
+            pub fn presentation_url(mut self, presentation_url: impl Into<String>) -> Self {
+                self.presentation_url = Some(presentation_url.into());
+                self
+            }
+            pub fn build(self) -> EnableParams {
+                EnableParams {
+                    presentation_url: self.presentation_url,
+                }
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Cast.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Starts observing for sinks that can be used for tab mirroring, and if set,\nsinks compatible with |presentationUrl| as well. When sinks are found, a\n|sinksUpdated| event is fired.\nAlso starts observing for issue messages. When an issue is added or removed,\nan |issueUpdated| event is fired.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Stops observing for sinks and issues.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Cast.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Stops observing for sinks and issues.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Sets a sink to be used when the web page requests the browser to choose a\nsink via Presentation API, Remote Playback API, or Cast SDK.\n[setSinkToUse](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-setSinkToUse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSinkToUseParams {
+            #[serde(rename = "sinkName")]
+            pub sink_name: String,
+        }
+        impl SetSinkToUseParams {
+            pub fn new(sink_name: impl Into<String>) -> Self {
+                Self {
+                    sink_name: sink_name.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for SetSinkToUseParams {
+            fn from(url: T) -> Self {
+                SetSinkToUseParams::new(url)
+            }
+        }
+        impl SetSinkToUseParams {
+            pub fn builder() -> SetSinkToUseParamsBuilder {
+                SetSinkToUseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSinkToUseParamsBuilder {
+            sink_name: Option<String>,
+        }
+        impl SetSinkToUseParamsBuilder {
+            pub fn sink_name(mut self, sink_name: impl Into<String>) -> Self {
+                self.sink_name = Some(sink_name.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSinkToUseParams, String> {
+                Ok(SetSinkToUseParams {
+                    sink_name: self.sink_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(sink_name))
+                    })?,
+                })
+            }
+        }
+        impl SetSinkToUseParams {
+            pub const IDENTIFIER: &'static str = "Cast.setSinkToUse";
+        }
+        impl chromiumoxide_types::Method for SetSinkToUseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSinkToUseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets a sink to be used when the web page requests the browser to choose a\nsink via Presentation API, Remote Playback API, or Cast SDK.\n[setSinkToUse](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-setSinkToUse)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSinkToUseReturns {}
+        impl chromiumoxide_types::Command for SetSinkToUseParams {
+            type Response = SetSinkToUseReturns;
+        }
+        #[doc = "Starts mirroring the desktop to the sink.\n[startDesktopMirroring](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-startDesktopMirroring)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StartDesktopMirroringParams {
+            #[serde(rename = "sinkName")]
+            pub sink_name: String,
+        }
+        impl StartDesktopMirroringParams {
+            pub fn new(sink_name: impl Into<String>) -> Self {
+                Self {
+                    sink_name: sink_name.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for StartDesktopMirroringParams {
+            fn from(url: T) -> Self {
+                StartDesktopMirroringParams::new(url)
+            }
+        }
+        impl StartDesktopMirroringParams {
+            pub fn builder() -> StartDesktopMirroringParamsBuilder {
+                StartDesktopMirroringParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartDesktopMirroringParamsBuilder {
+            sink_name: Option<String>,
+        }
+        impl StartDesktopMirroringParamsBuilder {
+            pub fn sink_name(mut self, sink_name: impl Into<String>) -> Self {
+                self.sink_name = Some(sink_name.into());
+                self
+            }
+            pub fn build(self) -> Result<StartDesktopMirroringParams, String> {
+                Ok(StartDesktopMirroringParams {
+                    sink_name: self.sink_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(sink_name))
+                    })?,
+                })
+            }
+        }
+        impl StartDesktopMirroringParams {
+            pub const IDENTIFIER: &'static str = "Cast.startDesktopMirroring";
+        }
+        impl chromiumoxide_types::Method for StartDesktopMirroringParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartDesktopMirroringParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Starts mirroring the desktop to the sink.\n[startDesktopMirroring](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-startDesktopMirroring)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartDesktopMirroringReturns {}
+        impl chromiumoxide_types::Command for StartDesktopMirroringParams {
+            type Response = StartDesktopMirroringReturns;
+        }
+        #[doc = "Starts mirroring the tab to the sink.\n[startTabMirroring](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-startTabMirroring)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StartTabMirroringParams {
+            #[serde(rename = "sinkName")]
+            pub sink_name: String,
+        }
+        impl StartTabMirroringParams {
+            pub fn new(sink_name: impl Into<String>) -> Self {
+                Self {
+                    sink_name: sink_name.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for StartTabMirroringParams {
+            fn from(url: T) -> Self {
+                StartTabMirroringParams::new(url)
+            }
+        }
+        impl StartTabMirroringParams {
+            pub fn builder() -> StartTabMirroringParamsBuilder {
+                StartTabMirroringParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartTabMirroringParamsBuilder {
+            sink_name: Option<String>,
+        }
+        impl StartTabMirroringParamsBuilder {
+            pub fn sink_name(mut self, sink_name: impl Into<String>) -> Self {
+                self.sink_name = Some(sink_name.into());
+                self
+            }
+            pub fn build(self) -> Result<StartTabMirroringParams, String> {
+                Ok(StartTabMirroringParams {
+                    sink_name: self.sink_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(sink_name))
+                    })?,
+                })
+            }
+        }
+        impl StartTabMirroringParams {
+            pub const IDENTIFIER: &'static str = "Cast.startTabMirroring";
+        }
+        impl chromiumoxide_types::Method for StartTabMirroringParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartTabMirroringParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Starts mirroring the tab to the sink.\n[startTabMirroring](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-startTabMirroring)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartTabMirroringReturns {}
+        impl chromiumoxide_types::Command for StartTabMirroringParams {
+            type Response = StartTabMirroringReturns;
+        }
+        #[doc = "Stops the active Cast session on the sink.\n[stopCasting](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-stopCasting)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StopCastingParams {
+            #[serde(rename = "sinkName")]
+            pub sink_name: String,
+        }
+        impl StopCastingParams {
+            pub fn new(sink_name: impl Into<String>) -> Self {
+                Self {
+                    sink_name: sink_name.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for StopCastingParams {
+            fn from(url: T) -> Self {
+                StopCastingParams::new(url)
+            }
+        }
+        impl StopCastingParams {
+            pub fn builder() -> StopCastingParamsBuilder {
+                StopCastingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StopCastingParamsBuilder {
+            sink_name: Option<String>,
+        }
+        impl StopCastingParamsBuilder {
+            pub fn sink_name(mut self, sink_name: impl Into<String>) -> Self {
+                self.sink_name = Some(sink_name.into());
+                self
+            }
+            pub fn build(self) -> Result<StopCastingParams, String> {
+                Ok(StopCastingParams {
+                    sink_name: self.sink_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(sink_name))
+                    })?,
+                })
+            }
+        }
+        impl StopCastingParams {
+            pub const IDENTIFIER: &'static str = "Cast.stopCasting";
+        }
+        impl chromiumoxide_types::Method for StopCastingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopCastingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Stops the active Cast session on the sink.\n[stopCasting](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#method-stopCasting)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopCastingReturns {}
+        impl chromiumoxide_types::Command for StopCastingParams {
+            type Response = StopCastingReturns;
+        }
+        #[doc = "This is fired whenever the list of available sinks changes. A sink is a\ndevice or a software surface that you can cast to.\n[sinksUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#event-sinksUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventSinksUpdated {
+            #[serde(rename = "sinks")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub sinks: Vec<Sink>,
+        }
+        impl EventSinksUpdated {
+            pub const IDENTIFIER: &'static str = "Cast.sinksUpdated";
+        }
+        impl chromiumoxide_types::Method for EventSinksUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventSinksUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "This is fired whenever the outstanding issue/error message changes.\n|issueMessage| is empty if there is no issue.\n[issueUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Cast/#event-issueUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventIssueUpdated {
+            #[serde(rename = "issueMessage")]
+            pub issue_message: String,
+        }
+        impl EventIssueUpdated {
+            pub const IDENTIFIER: &'static str = "Cast.issueUpdated";
+        }
+        impl chromiumoxide_types::Method for EventIssueUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventIssueUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "This domain exposes DOM read/write operations. Each DOM Node is represented with its mirror object\nthat has an `id`. This `id` can be used to get additional information on the Node, resolve it into\nthe JavaScript object wrapper, etc. It is important that client receives DOM events only for the\nnodes that are known to the client. Backend keeps track of the nodes that were sent to the client\nand never sends the same node twice. It is client's responsibility to collect information about\nthe nodes that were sent to the client. Note that `iframe` owner elements will return\ncorresponding document elements as their child nodes."]
+    pub mod dom {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Unique DOM node identifier.\n[NodeId](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-NodeId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Copy, Hash)]
+        pub struct NodeId(i64);
+        impl NodeId {
+            pub fn new(val: impl Into<i64>) -> Self {
+                NodeId(val.into())
+            }
+            pub fn inner(&self) -> &i64 {
+                &self.0
+            }
+        }
+        impl NodeId {
+            pub const IDENTIFIER: &'static str = "DOM.NodeId";
+        }
+        #[doc = "Unique DOM node identifier used to reference a node that may not have been pushed to the\nfront-end.\n[BackendNodeId](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-BackendNodeId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Copy, Hash)]
+        pub struct BackendNodeId(i64);
+        impl BackendNodeId {
+            pub fn new(val: impl Into<i64>) -> Self {
+                BackendNodeId(val.into())
+            }
+            pub fn inner(&self) -> &i64 {
+                &self.0
+            }
+        }
+        impl BackendNodeId {
+            pub const IDENTIFIER: &'static str = "DOM.BackendNodeId";
+        }
+        #[doc = "Unique identifier for a CSS stylesheet.\n[StyleSheetId](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-StyleSheetId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct StyleSheetId(String);
+        impl StyleSheetId {
+            pub fn new(val: impl Into<String>) -> Self {
+                StyleSheetId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for StyleSheetId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<StyleSheetId> for String {
+            fn from(el: StyleSheetId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for StyleSheetId {
+            fn from(expr: String) -> Self {
+                StyleSheetId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for StyleSheetId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl StyleSheetId {
+            pub const IDENTIFIER: &'static str = "DOM.StyleSheetId";
+        }
+        #[doc = "Backend node with a friendly name.\n[BackendNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-BackendNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BackendNode {
+            #[doc = "`Node`'s nodeType."]
+            #[serde(rename = "nodeType")]
+            pub node_type: i64,
+            #[doc = "`Node`'s nodeName."]
+            #[serde(rename = "nodeName")]
+            pub node_name: String,
+            #[serde(rename = "backendNodeId")]
+            pub backend_node_id: BackendNodeId,
+        }
+        impl BackendNode {
+            pub fn new(
+                node_type: impl Into<i64>,
+                node_name: impl Into<String>,
+                backend_node_id: impl Into<BackendNodeId>,
+            ) -> Self {
+                Self {
+                    node_type: node_type.into(),
+                    node_name: node_name.into(),
+                    backend_node_id: backend_node_id.into(),
+                }
+            }
+        }
+        impl BackendNode {
+            pub fn builder() -> BackendNodeBuilder {
+                BackendNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BackendNodeBuilder {
+            node_type: Option<i64>,
+            node_name: Option<String>,
+            backend_node_id: Option<BackendNodeId>,
+        }
+        impl BackendNodeBuilder {
+            pub fn node_type(mut self, node_type: impl Into<i64>) -> Self {
+                self.node_type = Some(node_type.into());
+                self
+            }
+            pub fn node_name(mut self, node_name: impl Into<String>) -> Self {
+                self.node_name = Some(node_name.into());
+                self
+            }
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<BackendNode, String> {
+                Ok(BackendNode {
+                    node_type: self.node_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_type))
+                    })?,
+                    node_name: self.node_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_name))
+                    })?,
+                    backend_node_id: self.backend_node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(backend_node_id))
+                    })?,
+                })
+            }
+        }
+        impl BackendNode {
+            pub const IDENTIFIER: &'static str = "DOM.BackendNode";
+        }
+        #[doc = "Pseudo element type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PseudoType {
+            #[serde(rename = "first-line")]
+            FirstLine,
+            #[serde(rename = "first-letter")]
+            FirstLetter,
+            #[serde(rename = "checkmark")]
+            Checkmark,
+            #[serde(rename = "before")]
+            Before,
+            #[serde(rename = "after")]
+            After,
+            #[serde(rename = "picker-icon")]
+            PickerIcon,
+            #[serde(rename = "interest-hint")]
+            InterestHint,
+            #[serde(rename = "marker")]
+            Marker,
+            #[serde(rename = "backdrop")]
+            Backdrop,
+            #[serde(rename = "column")]
+            Column,
+            #[serde(rename = "selection")]
+            Selection,
+            #[serde(rename = "search-text")]
+            SearchText,
+            #[serde(rename = "target-text")]
+            TargetText,
+            #[serde(rename = "spelling-error")]
+            SpellingError,
+            #[serde(rename = "grammar-error")]
+            GrammarError,
+            #[serde(rename = "highlight")]
+            Highlight,
+            #[serde(rename = "first-line-inherited")]
+            FirstLineInherited,
+            #[serde(rename = "scroll-marker")]
+            ScrollMarker,
+            #[serde(rename = "scroll-marker-group")]
+            ScrollMarkerGroup,
+            #[serde(rename = "scroll-button")]
+            ScrollButton,
+            #[serde(rename = "scrollbar")]
+            Scrollbar,
+            #[serde(rename = "scrollbar-thumb")]
+            ScrollbarThumb,
+            #[serde(rename = "scrollbar-button")]
+            ScrollbarButton,
+            #[serde(rename = "scrollbar-track")]
+            ScrollbarTrack,
+            #[serde(rename = "scrollbar-track-piece")]
+            ScrollbarTrackPiece,
+            #[serde(rename = "scrollbar-corner")]
+            ScrollbarCorner,
+            #[serde(rename = "resizer")]
+            Resizer,
+            #[serde(rename = "input-list-button")]
+            InputListButton,
+            #[serde(rename = "view-transition")]
+            ViewTransition,
+            #[serde(rename = "view-transition-group")]
+            ViewTransitionGroup,
+            #[serde(rename = "view-transition-image-pair")]
+            ViewTransitionImagePair,
+            #[serde(rename = "view-transition-group-children")]
+            ViewTransitionGroupChildren,
+            #[serde(rename = "view-transition-old")]
+            ViewTransitionOld,
+            #[serde(rename = "view-transition-new")]
+            ViewTransitionNew,
+            #[serde(rename = "placeholder")]
+            Placeholder,
+            #[serde(rename = "file-selector-button")]
+            FileSelectorButton,
+            #[serde(rename = "details-content")]
+            DetailsContent,
+            #[serde(rename = "picker")]
+            Picker,
+            #[serde(rename = "permission-icon")]
+            PermissionIcon,
+            #[serde(rename = "overscroll-area-parent")]
+            OverscrollAreaParent,
+        }
+        impl AsRef<str> for PseudoType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PseudoType::FirstLine => "first-line",
+                    PseudoType::FirstLetter => "first-letter",
+                    PseudoType::Checkmark => "checkmark",
+                    PseudoType::Before => "before",
+                    PseudoType::After => "after",
+                    PseudoType::PickerIcon => "picker-icon",
+                    PseudoType::InterestHint => "interest-hint",
+                    PseudoType::Marker => "marker",
+                    PseudoType::Backdrop => "backdrop",
+                    PseudoType::Column => "column",
+                    PseudoType::Selection => "selection",
+                    PseudoType::SearchText => "search-text",
+                    PseudoType::TargetText => "target-text",
+                    PseudoType::SpellingError => "spelling-error",
+                    PseudoType::GrammarError => "grammar-error",
+                    PseudoType::Highlight => "highlight",
+                    PseudoType::FirstLineInherited => "first-line-inherited",
+                    PseudoType::ScrollMarker => "scroll-marker",
+                    PseudoType::ScrollMarkerGroup => "scroll-marker-group",
+                    PseudoType::ScrollButton => "scroll-button",
+                    PseudoType::Scrollbar => "scrollbar",
+                    PseudoType::ScrollbarThumb => "scrollbar-thumb",
+                    PseudoType::ScrollbarButton => "scrollbar-button",
+                    PseudoType::ScrollbarTrack => "scrollbar-track",
+                    PseudoType::ScrollbarTrackPiece => "scrollbar-track-piece",
+                    PseudoType::ScrollbarCorner => "scrollbar-corner",
+                    PseudoType::Resizer => "resizer",
+                    PseudoType::InputListButton => "input-list-button",
+                    PseudoType::ViewTransition => "view-transition",
+                    PseudoType::ViewTransitionGroup => "view-transition-group",
+                    PseudoType::ViewTransitionImagePair => "view-transition-image-pair",
+                    PseudoType::ViewTransitionGroupChildren => "view-transition-group-children",
+                    PseudoType::ViewTransitionOld => "view-transition-old",
+                    PseudoType::ViewTransitionNew => "view-transition-new",
+                    PseudoType::Placeholder => "placeholder",
+                    PseudoType::FileSelectorButton => "file-selector-button",
+                    PseudoType::DetailsContent => "details-content",
+                    PseudoType::Picker => "picker",
+                    PseudoType::PermissionIcon => "permission-icon",
+                    PseudoType::OverscrollAreaParent => "overscroll-area-parent",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PseudoType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "first-line" | "FirstLine" => Ok(PseudoType::FirstLine),
+                    "first-letter" | "FirstLetter" => Ok(PseudoType::FirstLetter),
+                    "checkmark" | "Checkmark" => Ok(PseudoType::Checkmark),
+                    "before" | "Before" => Ok(PseudoType::Before),
+                    "after" | "After" => Ok(PseudoType::After),
+                    "picker-icon" | "PickerIcon" => Ok(PseudoType::PickerIcon),
+                    "interest-hint" | "InterestHint" => Ok(PseudoType::InterestHint),
+                    "marker" | "Marker" => Ok(PseudoType::Marker),
+                    "backdrop" | "Backdrop" => Ok(PseudoType::Backdrop),
+                    "column" | "Column" => Ok(PseudoType::Column),
+                    "selection" | "Selection" => Ok(PseudoType::Selection),
+                    "search-text" | "SearchText" => Ok(PseudoType::SearchText),
+                    "target-text" | "TargetText" => Ok(PseudoType::TargetText),
+                    "spelling-error" | "SpellingError" => Ok(PseudoType::SpellingError),
+                    "grammar-error" | "GrammarError" => Ok(PseudoType::GrammarError),
+                    "highlight" | "Highlight" => Ok(PseudoType::Highlight),
+                    "first-line-inherited" | "FirstLineInherited" => {
+                        Ok(PseudoType::FirstLineInherited)
+                    }
+                    "scroll-marker" | "ScrollMarker" => Ok(PseudoType::ScrollMarker),
+                    "scroll-marker-group" | "ScrollMarkerGroup" => {
+                        Ok(PseudoType::ScrollMarkerGroup)
+                    }
+                    "scroll-button" | "ScrollButton" => Ok(PseudoType::ScrollButton),
+                    "scrollbar" | "Scrollbar" => Ok(PseudoType::Scrollbar),
+                    "scrollbar-thumb" | "ScrollbarThumb" => Ok(PseudoType::ScrollbarThumb),
+                    "scrollbar-button" | "ScrollbarButton" => Ok(PseudoType::ScrollbarButton),
+                    "scrollbar-track" | "ScrollbarTrack" => Ok(PseudoType::ScrollbarTrack),
+                    "scrollbar-track-piece" | "ScrollbarTrackPiece" => {
+                        Ok(PseudoType::ScrollbarTrackPiece)
+                    }
+                    "scrollbar-corner" | "ScrollbarCorner" => Ok(PseudoType::ScrollbarCorner),
+                    "resizer" | "Resizer" => Ok(PseudoType::Resizer),
+                    "input-list-button" | "InputListButton" => Ok(PseudoType::InputListButton),
+                    "view-transition" | "ViewTransition" => Ok(PseudoType::ViewTransition),
+                    "view-transition-group" | "ViewTransitionGroup" => {
+                        Ok(PseudoType::ViewTransitionGroup)
+                    }
+                    "view-transition-image-pair" | "ViewTransitionImagePair" => {
+                        Ok(PseudoType::ViewTransitionImagePair)
+                    }
+                    "view-transition-group-children" | "ViewTransitionGroupChildren" => {
+                        Ok(PseudoType::ViewTransitionGroupChildren)
+                    }
+                    "view-transition-old" | "ViewTransitionOld" => {
+                        Ok(PseudoType::ViewTransitionOld)
+                    }
+                    "view-transition-new" | "ViewTransitionNew" => {
+                        Ok(PseudoType::ViewTransitionNew)
+                    }
+                    "placeholder" | "Placeholder" => Ok(PseudoType::Placeholder),
+                    "file-selector-button" | "FileSelectorButton" => {
+                        Ok(PseudoType::FileSelectorButton)
+                    }
+                    "details-content" | "DetailsContent" => Ok(PseudoType::DetailsContent),
+                    "picker" | "Picker" => Ok(PseudoType::Picker),
+                    "permission-icon" | "PermissionIcon" => Ok(PseudoType::PermissionIcon),
+                    "overscroll-area-parent" | "OverscrollAreaParent" => {
+                        Ok(PseudoType::OverscrollAreaParent)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Shadow root type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ShadowRootType {
+            #[serde(rename = "user-agent")]
+            UserAgent,
+            #[serde(rename = "open")]
+            Open,
+            #[serde(rename = "closed")]
+            Closed,
+        }
+        impl AsRef<str> for ShadowRootType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ShadowRootType::UserAgent => "user-agent",
+                    ShadowRootType::Open => "open",
+                    ShadowRootType::Closed => "closed",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ShadowRootType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "user-agent" | "UserAgent" => Ok(ShadowRootType::UserAgent),
+                    "open" | "Open" => Ok(ShadowRootType::Open),
+                    "closed" | "Closed" => Ok(ShadowRootType::Closed),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Document compatibility mode."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CompatibilityMode {
+            #[serde(rename = "QuirksMode")]
+            QuirksMode,
+            #[serde(rename = "LimitedQuirksMode")]
+            LimitedQuirksMode,
+            #[serde(rename = "NoQuirksMode")]
+            NoQuirksMode,
+        }
+        impl AsRef<str> for CompatibilityMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CompatibilityMode::QuirksMode => "QuirksMode",
+                    CompatibilityMode::LimitedQuirksMode => "LimitedQuirksMode",
+                    CompatibilityMode::NoQuirksMode => "NoQuirksMode",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CompatibilityMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "QuirksMode" | "quirksmode" => Ok(CompatibilityMode::QuirksMode),
+                    "LimitedQuirksMode" | "limitedquirksmode" => {
+                        Ok(CompatibilityMode::LimitedQuirksMode)
+                    }
+                    "NoQuirksMode" | "noquirksmode" => Ok(CompatibilityMode::NoQuirksMode),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "ContainerSelector physical axes"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PhysicalAxes {
+            #[serde(rename = "Horizontal")]
+            Horizontal,
+            #[serde(rename = "Vertical")]
+            Vertical,
+            #[serde(rename = "Both")]
+            Both,
+        }
+        impl AsRef<str> for PhysicalAxes {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PhysicalAxes::Horizontal => "Horizontal",
+                    PhysicalAxes::Vertical => "Vertical",
+                    PhysicalAxes::Both => "Both",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PhysicalAxes {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Horizontal" | "horizontal" => Ok(PhysicalAxes::Horizontal),
+                    "Vertical" | "vertical" => Ok(PhysicalAxes::Vertical),
+                    "Both" | "both" => Ok(PhysicalAxes::Both),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "ContainerSelector logical axes"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum LogicalAxes {
+            #[serde(rename = "Inline")]
+            Inline,
+            #[serde(rename = "Block")]
+            Block,
+            #[serde(rename = "Both")]
+            Both,
+        }
+        impl AsRef<str> for LogicalAxes {
+            fn as_ref(&self) -> &str {
+                match self {
+                    LogicalAxes::Inline => "Inline",
+                    LogicalAxes::Block => "Block",
+                    LogicalAxes::Both => "Both",
+                }
+            }
+        }
+        impl ::std::str::FromStr for LogicalAxes {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Inline" | "inline" => Ok(LogicalAxes::Inline),
+                    "Block" | "block" => Ok(LogicalAxes::Block),
+                    "Both" | "both" => Ok(LogicalAxes::Both),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Physical scroll orientation"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ScrollOrientation {
+            #[serde(rename = "horizontal")]
+            Horizontal,
+            #[serde(rename = "vertical")]
+            Vertical,
+        }
+        impl AsRef<str> for ScrollOrientation {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ScrollOrientation::Horizontal => "horizontal",
+                    ScrollOrientation::Vertical => "vertical",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ScrollOrientation {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "horizontal" | "Horizontal" => Ok(ScrollOrientation::Horizontal),
+                    "vertical" | "Vertical" => Ok(ScrollOrientation::Vertical),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "DOM interaction is implemented in terms of mirror objects that represent the actual DOM nodes.\nDOMNode is a base node mirror type.\n[Node](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-Node)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Node {
+            #[doc = "Node identifier that is passed into the rest of the DOM messages as the `nodeId`. Backend\nwill only push node with given `id` once. It is aware of all requested nodes and will only\nfire DOM events for nodes known to the client."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "The id of the parent node if any."]
+            #[serde(rename = "parentId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent_id: Option<NodeId>,
+            #[doc = "The BackendNodeId for this node."]
+            #[serde(rename = "backendNodeId")]
+            pub backend_node_id: BackendNodeId,
+            #[doc = "`Node`'s nodeType."]
+            #[serde(rename = "nodeType")]
+            pub node_type: i64,
+            #[doc = "`Node`'s nodeName."]
+            #[serde(rename = "nodeName")]
+            pub node_name: String,
+            #[doc = "`Node`'s localName."]
+            #[serde(rename = "localName")]
+            pub local_name: String,
+            #[doc = "`Node`'s nodeValue."]
+            #[serde(rename = "nodeValue")]
+            pub node_value: String,
+            #[doc = "Child count for `Container` nodes."]
+            #[serde(rename = "childNodeCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub child_node_count: Option<i64>,
+            #[doc = "Child nodes of this node when requested with children."]
+            #[serde(rename = "children")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub children: Option<Vec<Node>>,
+            #[doc = "Attributes of the `Element` node in the form of flat array `[name1, value1, name2, value2]`."]
+            #[serde(rename = "attributes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub attributes: Option<Vec<String>>,
+            #[doc = "Document URL that `Document` or `FrameOwner` node points to."]
+            #[serde(rename = "documentURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub document_url: Option<String>,
+            #[doc = "Base URL that `Document` or `FrameOwner` node uses for URL completion."]
+            #[serde(rename = "baseURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub base_url: Option<String>,
+            #[doc = "`DocumentType`'s publicId."]
+            #[serde(rename = "publicId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub public_id: Option<String>,
+            #[doc = "`DocumentType`'s systemId."]
+            #[serde(rename = "systemId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub system_id: Option<String>,
+            #[doc = "`DocumentType`'s internalSubset."]
+            #[serde(rename = "internalSubset")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub internal_subset: Option<String>,
+            #[doc = "`Document`'s XML version in case of XML documents."]
+            #[serde(rename = "xmlVersion")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub xml_version: Option<String>,
+            #[doc = "`Attr`'s name."]
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[doc = "`Attr`'s value."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<String>,
+            #[doc = "Pseudo element type for this node."]
+            #[serde(rename = "pseudoType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub pseudo_type: Option<PseudoType>,
+            #[doc = "Pseudo element identifier for this node. Only present if there is a\nvalid pseudoType."]
+            #[serde(rename = "pseudoIdentifier")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pseudo_identifier: Option<String>,
+            #[doc = "Shadow root type."]
+            #[serde(rename = "shadowRootType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub shadow_root_type: Option<ShadowRootType>,
+            #[doc = "Frame ID for frame owner elements."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+            #[doc = "Content document for frame owner elements."]
+            #[serde(rename = "contentDocument")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub content_document: Option<Box<Node>>,
+            #[doc = "Shadow root list for given element host."]
+            #[serde(rename = "shadowRoots")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub shadow_roots: Option<Vec<Node>>,
+            #[doc = "Content document fragment for template elements."]
+            #[serde(rename = "templateContent")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub template_content: Option<Box<Node>>,
+            #[doc = "Pseudo elements associated with this node."]
+            #[serde(rename = "pseudoElements")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pseudo_elements: Option<Vec<Node>>,
+            #[doc = "Distributed nodes for given insertion point."]
+            #[serde(rename = "distributedNodes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub distributed_nodes: Option<Vec<BackendNode>>,
+            #[doc = "Whether the node is SVG."]
+            #[serde(rename = "isSVG")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_svg: Option<bool>,
+            #[serde(rename = "compatibilityMode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub compatibility_mode: Option<CompatibilityMode>,
+            #[serde(rename = "assignedSlot")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub assigned_slot: Option<BackendNode>,
+            #[serde(rename = "isScrollable")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_scrollable: Option<bool>,
+            #[serde(rename = "affectedByStartingStyles")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub affected_by_starting_styles: Option<bool>,
+            #[serde(rename = "adoptedStyleSheets")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub adopted_style_sheets: Option<Vec<StyleSheetId>>,
+        }
+        impl Node {
+            pub fn builder() -> NodeBuilder {
+                NodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct NodeBuilder {
+            node_id: Option<NodeId>,
+            parent_id: Option<NodeId>,
+            backend_node_id: Option<BackendNodeId>,
+            node_type: Option<i64>,
+            node_name: Option<String>,
+            local_name: Option<String>,
+            node_value: Option<String>,
+            child_node_count: Option<i64>,
+            children: Option<Vec<Node>>,
+            attributes: Option<Vec<String>>,
+            document_url: Option<String>,
+            base_url: Option<String>,
+            public_id: Option<String>,
+            system_id: Option<String>,
+            internal_subset: Option<String>,
+            xml_version: Option<String>,
+            name: Option<String>,
+            value: Option<String>,
+            pseudo_type: Option<PseudoType>,
+            pseudo_identifier: Option<String>,
+            shadow_root_type: Option<ShadowRootType>,
+            frame_id: Option<super::page::FrameId>,
+            content_document: Option<Node>,
+            shadow_roots: Option<Vec<Node>>,
+            template_content: Option<Node>,
+            pseudo_elements: Option<Vec<Node>>,
+            distributed_nodes: Option<Vec<BackendNode>>,
+            is_svg: Option<bool>,
+            compatibility_mode: Option<CompatibilityMode>,
+            assigned_slot: Option<BackendNode>,
+            is_scrollable: Option<bool>,
+            affected_by_starting_styles: Option<bool>,
+            adopted_style_sheets: Option<Vec<StyleSheetId>>,
+        }
+        impl NodeBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn parent_id(mut self, parent_id: impl Into<NodeId>) -> Self {
+                self.parent_id = Some(parent_id.into());
+                self
+            }
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn node_type(mut self, node_type: impl Into<i64>) -> Self {
+                self.node_type = Some(node_type.into());
+                self
+            }
+            pub fn node_name(mut self, node_name: impl Into<String>) -> Self {
+                self.node_name = Some(node_name.into());
+                self
+            }
+            pub fn local_name(mut self, local_name: impl Into<String>) -> Self {
+                self.local_name = Some(local_name.into());
+                self
+            }
+            pub fn node_value(mut self, node_value: impl Into<String>) -> Self {
+                self.node_value = Some(node_value.into());
+                self
+            }
+            pub fn child_node_count(mut self, child_node_count: impl Into<i64>) -> Self {
+                self.child_node_count = Some(child_node_count.into());
+                self
+            }
+            pub fn children(mut self, children: impl Into<Node>) -> Self {
+                let v = self.children.get_or_insert(Vec::new());
+                v.push(children.into());
+                self
+            }
+            pub fn childrens<I, S>(mut self, childrens: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Node>,
+            {
+                let v = self.children.get_or_insert(Vec::new());
+                for val in childrens {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn attribute(mut self, attribute: impl Into<String>) -> Self {
+                let v = self.attributes.get_or_insert(Vec::new());
+                v.push(attribute.into());
+                self
+            }
+            pub fn attributes<I, S>(mut self, attributes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.attributes.get_or_insert(Vec::new());
+                for val in attributes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn document_url(mut self, document_url: impl Into<String>) -> Self {
+                self.document_url = Some(document_url.into());
+                self
+            }
+            pub fn base_url(mut self, base_url: impl Into<String>) -> Self {
+                self.base_url = Some(base_url.into());
+                self
+            }
+            pub fn public_id(mut self, public_id: impl Into<String>) -> Self {
+                self.public_id = Some(public_id.into());
+                self
+            }
+            pub fn system_id(mut self, system_id: impl Into<String>) -> Self {
+                self.system_id = Some(system_id.into());
+                self
+            }
+            pub fn internal_subset(mut self, internal_subset: impl Into<String>) -> Self {
+                self.internal_subset = Some(internal_subset.into());
+                self
+            }
+            pub fn xml_version(mut self, xml_version: impl Into<String>) -> Self {
+                self.xml_version = Some(xml_version.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn pseudo_type(mut self, pseudo_type: impl Into<PseudoType>) -> Self {
+                self.pseudo_type = Some(pseudo_type.into());
+                self
+            }
+            pub fn pseudo_identifier(mut self, pseudo_identifier: impl Into<String>) -> Self {
+                self.pseudo_identifier = Some(pseudo_identifier.into());
+                self
+            }
+            pub fn shadow_root_type(mut self, shadow_root_type: impl Into<ShadowRootType>) -> Self {
+                self.shadow_root_type = Some(shadow_root_type.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn content_document(mut self, content_document: impl Into<Node>) -> Self {
+                self.content_document = Some(content_document.into());
+                self
+            }
+            pub fn shadow_root(mut self, shadow_root: impl Into<Node>) -> Self {
+                let v = self.shadow_roots.get_or_insert(Vec::new());
+                v.push(shadow_root.into());
+                self
+            }
+            pub fn shadow_roots<I, S>(mut self, shadow_roots: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Node>,
+            {
+                let v = self.shadow_roots.get_or_insert(Vec::new());
+                for val in shadow_roots {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn template_content(mut self, template_content: impl Into<Node>) -> Self {
+                self.template_content = Some(template_content.into());
+                self
+            }
+            pub fn pseudo_element(mut self, pseudo_element: impl Into<Node>) -> Self {
+                let v = self.pseudo_elements.get_or_insert(Vec::new());
+                v.push(pseudo_element.into());
+                self
+            }
+            pub fn pseudo_elements<I, S>(mut self, pseudo_elements: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Node>,
+            {
+                let v = self.pseudo_elements.get_or_insert(Vec::new());
+                for val in pseudo_elements {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn distributed_node(mut self, distributed_node: impl Into<BackendNode>) -> Self {
+                let v = self.distributed_nodes.get_or_insert(Vec::new());
+                v.push(distributed_node.into());
+                self
+            }
+            pub fn distributed_nodes<I, S>(mut self, distributed_nodes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<BackendNode>,
+            {
+                let v = self.distributed_nodes.get_or_insert(Vec::new());
+                for val in distributed_nodes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn is_svg(mut self, is_svg: impl Into<bool>) -> Self {
+                self.is_svg = Some(is_svg.into());
+                self
+            }
+            pub fn compatibility_mode(
+                mut self,
+                compatibility_mode: impl Into<CompatibilityMode>,
+            ) -> Self {
+                self.compatibility_mode = Some(compatibility_mode.into());
+                self
+            }
+            pub fn assigned_slot(mut self, assigned_slot: impl Into<BackendNode>) -> Self {
+                self.assigned_slot = Some(assigned_slot.into());
+                self
+            }
+            pub fn is_scrollable(mut self, is_scrollable: impl Into<bool>) -> Self {
+                self.is_scrollable = Some(is_scrollable.into());
+                self
+            }
+            pub fn affected_by_starting_styles(
+                mut self,
+                affected_by_starting_styles: impl Into<bool>,
+            ) -> Self {
+                self.affected_by_starting_styles = Some(affected_by_starting_styles.into());
+                self
+            }
+            pub fn adopted_style_sheet(
+                mut self,
+                adopted_style_sheet: impl Into<StyleSheetId>,
+            ) -> Self {
+                let v = self.adopted_style_sheets.get_or_insert(Vec::new());
+                v.push(adopted_style_sheet.into());
+                self
+            }
+            pub fn adopted_style_sheets<I, S>(mut self, adopted_style_sheets: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<StyleSheetId>,
+            {
+                let v = self.adopted_style_sheets.get_or_insert(Vec::new());
+                for val in adopted_style_sheets {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<Node, String> {
+                Ok(Node {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    parent_id: self.parent_id,
+                    backend_node_id: self.backend_node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(backend_node_id))
+                    })?,
+                    node_type: self.node_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_type))
+                    })?,
+                    node_name: self.node_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_name))
+                    })?,
+                    local_name: self.local_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(local_name))
+                    })?,
+                    node_value: self.node_value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_value))
+                    })?,
+                    child_node_count: self.child_node_count,
+                    children: self.children,
+                    attributes: self.attributes,
+                    document_url: self.document_url,
+                    base_url: self.base_url,
+                    public_id: self.public_id,
+                    system_id: self.system_id,
+                    internal_subset: self.internal_subset,
+                    xml_version: self.xml_version,
+                    name: self.name,
+                    value: self.value,
+                    pseudo_type: self.pseudo_type,
+                    pseudo_identifier: self.pseudo_identifier,
+                    shadow_root_type: self.shadow_root_type,
+                    frame_id: self.frame_id,
+                    content_document: self.content_document.map(Box::new),
+                    shadow_roots: self.shadow_roots,
+                    template_content: self.template_content.map(Box::new),
+                    pseudo_elements: self.pseudo_elements,
+                    distributed_nodes: self.distributed_nodes,
+                    is_svg: self.is_svg,
+                    compatibility_mode: self.compatibility_mode,
+                    assigned_slot: self.assigned_slot,
+                    is_scrollable: self.is_scrollable,
+                    affected_by_starting_styles: self.affected_by_starting_styles,
+                    adopted_style_sheets: self.adopted_style_sheets,
+                })
+            }
+        }
+        impl Node {
+            pub const IDENTIFIER: &'static str = "DOM.Node";
+        }
+        #[doc = "A structure to hold the top-level node of a detached tree and an array of its retained descendants.\n[DetachedElementInfo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-DetachedElementInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DetachedElementInfo {
+            #[serde(rename = "treeNode")]
+            pub tree_node: Node,
+            #[serde(rename = "retainedNodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub retained_node_ids: Vec<NodeId>,
+        }
+        impl DetachedElementInfo {
+            pub fn new(tree_node: impl Into<Node>, retained_node_ids: Vec<NodeId>) -> Self {
+                Self {
+                    tree_node: tree_node.into(),
+                    retained_node_ids,
+                }
+            }
+        }
+        impl DetachedElementInfo {
+            pub fn builder() -> DetachedElementInfoBuilder {
+                DetachedElementInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DetachedElementInfoBuilder {
+            tree_node: Option<Node>,
+            retained_node_ids: Option<Vec<NodeId>>,
+        }
+        impl DetachedElementInfoBuilder {
+            pub fn tree_node(mut self, tree_node: impl Into<Node>) -> Self {
+                self.tree_node = Some(tree_node.into());
+                self
+            }
+            pub fn retained_node_id(mut self, retained_node_id: impl Into<NodeId>) -> Self {
+                let v = self.retained_node_ids.get_or_insert(Vec::new());
+                v.push(retained_node_id.into());
+                self
+            }
+            pub fn retained_node_ids<I, S>(mut self, retained_node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NodeId>,
+            {
+                let v = self.retained_node_ids.get_or_insert(Vec::new());
+                for val in retained_node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<DetachedElementInfo, String> {
+                Ok(DetachedElementInfo {
+                    tree_node: self.tree_node.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(tree_node))
+                    })?,
+                    retained_node_ids: self.retained_node_ids.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(retained_node_ids)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl DetachedElementInfo {
+            pub const IDENTIFIER: &'static str = "DOM.DetachedElementInfo";
+        }
+        #[doc = "A structure holding an RGBA color.\n[RGBA](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-RGBA)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Rgba {
+            #[doc = "The red component, in the [0-255] range."]
+            #[serde(rename = "r")]
+            pub r: i64,
+            #[doc = "The green component, in the [0-255] range."]
+            #[serde(rename = "g")]
+            pub g: i64,
+            #[doc = "The blue component, in the [0-255] range."]
+            #[serde(rename = "b")]
+            pub b: i64,
+            #[doc = "The alpha component, in the [0-1] range (default: 1)."]
+            #[serde(rename = "a")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub a: Option<f64>,
+        }
+        impl Rgba {
+            pub fn new(r: impl Into<i64>, g: impl Into<i64>, b: impl Into<i64>) -> Self {
+                Self {
+                    r: r.into(),
+                    g: g.into(),
+                    b: b.into(),
+                    a: None,
+                }
+            }
+        }
+        impl Rgba {
+            pub fn builder() -> RgbaBuilder {
+                RgbaBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RgbaBuilder {
+            r: Option<i64>,
+            g: Option<i64>,
+            b: Option<i64>,
+            a: Option<f64>,
+        }
+        impl RgbaBuilder {
+            pub fn r(mut self, r: impl Into<i64>) -> Self {
+                self.r = Some(r.into());
+                self
+            }
+            pub fn g(mut self, g: impl Into<i64>) -> Self {
+                self.g = Some(g.into());
+                self
+            }
+            pub fn b(mut self, b: impl Into<i64>) -> Self {
+                self.b = Some(b.into());
+                self
+            }
+            pub fn a(mut self, a: impl Into<f64>) -> Self {
+                self.a = Some(a.into());
+                self
+            }
+            pub fn build(self) -> Result<Rgba, String> {
+                Ok(Rgba {
+                    r: self
+                        .r
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(r)))?,
+                    g: self
+                        .g
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(g)))?,
+                    b: self
+                        .b
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(b)))?,
+                    a: self.a,
+                })
+            }
+        }
+        impl Rgba {
+            pub const IDENTIFIER: &'static str = "DOM.RGBA";
+        }
+        #[doc = "An array of quad vertices, x immediately followed by y for each point, points clock-wise.\n[Quad](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-Quad)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct Quad(Vec<f64>);
+        impl Quad {
+            pub fn new(val: impl Into<Vec<f64>>) -> Self {
+                Quad(val.into())
+            }
+            pub fn inner(&self) -> &Vec<f64> {
+                &self.0
+            }
+        }
+        impl Quad {
+            pub const IDENTIFIER: &'static str = "DOM.Quad";
+        }
+        #[doc = "Box model.\n[BoxModel](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-BoxModel)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BoxModel {
+            #[doc = "Content box"]
+            #[serde(rename = "content")]
+            pub content: Quad,
+            #[doc = "Padding box"]
+            #[serde(rename = "padding")]
+            pub padding: Quad,
+            #[doc = "Border box"]
+            #[serde(rename = "border")]
+            pub border: Quad,
+            #[doc = "Margin box"]
+            #[serde(rename = "margin")]
+            pub margin: Quad,
+            #[doc = "Node width"]
+            #[serde(rename = "width")]
+            pub width: i64,
+            #[doc = "Node height"]
+            #[serde(rename = "height")]
+            pub height: i64,
+            #[doc = "Shape outside coordinates"]
+            #[serde(rename = "shapeOutside")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub shape_outside: Option<ShapeOutsideInfo>,
+        }
+        impl BoxModel {
+            pub fn builder() -> BoxModelBuilder {
+                BoxModelBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BoxModelBuilder {
+            content: Option<Quad>,
+            padding: Option<Quad>,
+            border: Option<Quad>,
+            margin: Option<Quad>,
+            width: Option<i64>,
+            height: Option<i64>,
+            shape_outside: Option<ShapeOutsideInfo>,
+        }
+        impl BoxModelBuilder {
+            pub fn content(mut self, content: impl Into<Quad>) -> Self {
+                self.content = Some(content.into());
+                self
+            }
+            pub fn padding(mut self, padding: impl Into<Quad>) -> Self {
+                self.padding = Some(padding.into());
+                self
+            }
+            pub fn border(mut self, border: impl Into<Quad>) -> Self {
+                self.border = Some(border.into());
+                self
+            }
+            pub fn margin(mut self, margin: impl Into<Quad>) -> Self {
+                self.margin = Some(margin.into());
+                self
+            }
+            pub fn width(mut self, width: impl Into<i64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<i64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn shape_outside(mut self, shape_outside: impl Into<ShapeOutsideInfo>) -> Self {
+                self.shape_outside = Some(shape_outside.into());
+                self
+            }
+            pub fn build(self) -> Result<BoxModel, String> {
+                Ok(BoxModel {
+                    content: self.content.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(content))
+                    })?,
+                    padding: self.padding.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(padding))
+                    })?,
+                    border: self.border.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(border))
+                    })?,
+                    margin: self.margin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(margin))
+                    })?,
+                    width: self.width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(width))
+                    })?,
+                    height: self.height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(height))
+                    })?,
+                    shape_outside: self.shape_outside,
+                })
+            }
+        }
+        impl BoxModel {
+            pub const IDENTIFIER: &'static str = "DOM.BoxModel";
+        }
+        #[doc = "CSS Shape Outside details.\n[ShapeOutsideInfo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-ShapeOutsideInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ShapeOutsideInfo {
+            #[doc = "Shape bounds"]
+            #[serde(rename = "bounds")]
+            pub bounds: Quad,
+            #[doc = "Shape coordinate details"]
+            #[serde(rename = "shape")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub shape: Vec<serde_json::Value>,
+            #[doc = "Margin shape bounds"]
+            #[serde(rename = "marginShape")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub margin_shape: Vec<serde_json::Value>,
+        }
+        impl ShapeOutsideInfo {
+            pub fn new(
+                bounds: impl Into<Quad>,
+                shape: Vec<serde_json::Value>,
+                margin_shape: Vec<serde_json::Value>,
+            ) -> Self {
+                Self {
+                    bounds: bounds.into(),
+                    shape,
+                    margin_shape,
+                }
+            }
+        }
+        impl ShapeOutsideInfo {
+            pub fn builder() -> ShapeOutsideInfoBuilder {
+                ShapeOutsideInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ShapeOutsideInfoBuilder {
+            bounds: Option<Quad>,
+            shape: Option<Vec<serde_json::Value>>,
+            margin_shape: Option<Vec<serde_json::Value>>,
+        }
+        impl ShapeOutsideInfoBuilder {
+            pub fn bounds(mut self, bounds: impl Into<Quad>) -> Self {
+                self.bounds = Some(bounds.into());
+                self
+            }
+            pub fn shape(mut self, shape: impl Into<serde_json::Value>) -> Self {
+                let v = self.shape.get_or_insert(Vec::new());
+                v.push(shape.into());
+                self
+            }
+            pub fn shapes<I, S>(mut self, shapes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<serde_json::Value>,
+            {
+                let v = self.shape.get_or_insert(Vec::new());
+                for val in shapes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn margin_shape(mut self, margin_shape: impl Into<serde_json::Value>) -> Self {
+                let v = self.margin_shape.get_or_insert(Vec::new());
+                v.push(margin_shape.into());
+                self
+            }
+            pub fn margin_shapes<I, S>(mut self, margin_shapes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<serde_json::Value>,
+            {
+                let v = self.margin_shape.get_or_insert(Vec::new());
+                for val in margin_shapes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ShapeOutsideInfo, String> {
+                Ok(ShapeOutsideInfo {
+                    bounds: self.bounds.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bounds))
+                    })?,
+                    shape: self.shape.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(shape))
+                    })?,
+                    margin_shape: self.margin_shape.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(margin_shape))
+                    })?,
+                })
+            }
+        }
+        impl ShapeOutsideInfo {
+            pub const IDENTIFIER: &'static str = "DOM.ShapeOutsideInfo";
+        }
+        #[doc = "Rectangle.\n[Rect](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#type-Rect)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Rect {
+            #[doc = "X coordinate"]
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[doc = "Y coordinate"]
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[doc = "Rectangle width"]
+            #[serde(rename = "width")]
+            pub width: f64,
+            #[doc = "Rectangle height"]
+            #[serde(rename = "height")]
+            pub height: f64,
+        }
+        impl Rect {
+            pub fn new(
+                x: impl Into<f64>,
+                y: impl Into<f64>,
+                width: impl Into<f64>,
+                height: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    x: x.into(),
+                    y: y.into(),
+                    width: width.into(),
+                    height: height.into(),
+                }
+            }
+        }
+        impl Rect {
+            pub fn builder() -> RectBuilder {
+                RectBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RectBuilder {
+            x: Option<f64>,
+            y: Option<f64>,
+            width: Option<f64>,
+            height: Option<f64>,
+        }
+        impl RectBuilder {
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn width(mut self, width: impl Into<f64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<f64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn build(self) -> Result<Rect, String> {
+                Ok(Rect {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    width: self.width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(width))
+                    })?,
+                    height: self.height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(height))
+                    })?,
+                })
+            }
+        }
+        impl Rect {
+            pub const IDENTIFIER: &'static str = "DOM.Rect";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CssComputedStyleProperty {
+            #[doc = "Computed style property name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Computed style property value."]
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl CssComputedStyleProperty {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl CssComputedStyleProperty {
+            pub fn builder() -> CssComputedStylePropertyBuilder {
+                CssComputedStylePropertyBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CssComputedStylePropertyBuilder {
+            name: Option<String>,
+            value: Option<String>,
+        }
+        impl CssComputedStylePropertyBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<CssComputedStyleProperty, String> {
+                Ok(CssComputedStyleProperty {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl CssComputedStyleProperty {
+            pub const IDENTIFIER: &'static str = "DOM.CSSComputedStyleProperty";
+        }
+        #[doc = "Collects class names for the node with given id and all of it's child nodes.\n[collectClassNamesFromSubtree](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-collectClassNamesFromSubtree)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CollectClassNamesFromSubtreeParams {
+            #[doc = "Id of the node to collect class names."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl CollectClassNamesFromSubtreeParams {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl CollectClassNamesFromSubtreeParams {
+            pub fn builder() -> CollectClassNamesFromSubtreeParamsBuilder {
+                CollectClassNamesFromSubtreeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CollectClassNamesFromSubtreeParamsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl CollectClassNamesFromSubtreeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CollectClassNamesFromSubtreeParams, String> {
+                Ok(CollectClassNamesFromSubtreeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl CollectClassNamesFromSubtreeParams {
+            pub const IDENTIFIER: &'static str = "DOM.collectClassNamesFromSubtree";
+        }
+        impl chromiumoxide_types::Method for CollectClassNamesFromSubtreeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CollectClassNamesFromSubtreeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Collects class names for the node with given id and all of it's child nodes.\n[collectClassNamesFromSubtree](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-collectClassNamesFromSubtree)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CollectClassNamesFromSubtreeReturns {
+            #[doc = "Class name list."]
+            #[serde(rename = "classNames")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub class_names: Vec<String>,
+        }
+        impl CollectClassNamesFromSubtreeReturns {
+            pub fn new(class_names: Vec<String>) -> Self {
+                Self { class_names }
+            }
+        }
+        impl CollectClassNamesFromSubtreeReturns {
+            pub fn builder() -> CollectClassNamesFromSubtreeReturnsBuilder {
+                CollectClassNamesFromSubtreeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CollectClassNamesFromSubtreeReturnsBuilder {
+            class_names: Option<Vec<String>>,
+        }
+        impl CollectClassNamesFromSubtreeReturnsBuilder {
+            pub fn class_name(mut self, class_name: impl Into<String>) -> Self {
+                let v = self.class_names.get_or_insert(Vec::new());
+                v.push(class_name.into());
+                self
+            }
+            pub fn class_names<I, S>(mut self, class_names: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.class_names.get_or_insert(Vec::new());
+                for val in class_names {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<CollectClassNamesFromSubtreeReturns, String> {
+                Ok(CollectClassNamesFromSubtreeReturns {
+                    class_names: self.class_names.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(class_names))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CollectClassNamesFromSubtreeParams {
+            type Response = CollectClassNamesFromSubtreeReturns;
+        }
+        #[doc = "Creates a deep copy of the specified node and places it into the target container before the\ngiven anchor.\n[copyTo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-copyTo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CopyToParams {
+            #[doc = "Id of the node to copy."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "Id of the element to drop the copy into."]
+            #[serde(rename = "targetNodeId")]
+            pub target_node_id: NodeId,
+            #[doc = "Drop the copy before this node (if absent, the copy becomes the last child of\n`targetNodeId`)."]
+            #[serde(rename = "insertBeforeNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub insert_before_node_id: Option<NodeId>,
+        }
+        impl CopyToParams {
+            pub fn new(node_id: impl Into<NodeId>, target_node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    target_node_id: target_node_id.into(),
+                    insert_before_node_id: None,
+                }
+            }
+        }
+        impl CopyToParams {
+            pub fn builder() -> CopyToParamsBuilder {
+                CopyToParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CopyToParamsBuilder {
+            node_id: Option<NodeId>,
+            target_node_id: Option<NodeId>,
+            insert_before_node_id: Option<NodeId>,
+        }
+        impl CopyToParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn target_node_id(mut self, target_node_id: impl Into<NodeId>) -> Self {
+                self.target_node_id = Some(target_node_id.into());
+                self
+            }
+            pub fn insert_before_node_id(
+                mut self,
+                insert_before_node_id: impl Into<NodeId>,
+            ) -> Self {
+                self.insert_before_node_id = Some(insert_before_node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CopyToParams, String> {
+                Ok(CopyToParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    target_node_id: self.target_node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_node_id))
+                    })?,
+                    insert_before_node_id: self.insert_before_node_id,
+                })
+            }
+        }
+        impl CopyToParams {
+            pub const IDENTIFIER: &'static str = "DOM.copyTo";
+        }
+        impl chromiumoxide_types::Method for CopyToParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CopyToParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Creates a deep copy of the specified node and places it into the target container before the\ngiven anchor.\n[copyTo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-copyTo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CopyToReturns {
+            #[doc = "Id of the node clone."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl CopyToReturns {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl CopyToReturns {
+            pub fn builder() -> CopyToReturnsBuilder {
+                CopyToReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CopyToReturnsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl CopyToReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CopyToReturns, String> {
+                Ok(CopyToReturns {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CopyToParams {
+            type Response = CopyToReturns;
+        }
+        #[doc = "Describes node given its id, does not require domain to be enabled. Does not start tracking any\nobjects, can be used for automation.\n[describeNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-describeNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DescribeNodeParams {
+            #[doc = "Identifier of the node."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+            #[doc = "Identifier of the backend node."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<BackendNodeId>,
+            #[doc = "JavaScript object id of the node wrapper."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            #[doc = "The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the\nentire subtree or provide an integer larger than 0."]
+            #[serde(rename = "depth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub depth: Option<i64>,
+            #[doc = "Whether or not iframes and shadow roots should be traversed when returning the subtree\n(default is false)."]
+            #[serde(rename = "pierce")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pierce: Option<bool>,
+        }
+        impl DescribeNodeParams {
+            pub fn builder() -> DescribeNodeParamsBuilder {
+                DescribeNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DescribeNodeParamsBuilder {
+            node_id: Option<NodeId>,
+            backend_node_id: Option<BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            depth: Option<i64>,
+            pierce: Option<bool>,
+        }
+        impl DescribeNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn depth(mut self, depth: impl Into<i64>) -> Self {
+                self.depth = Some(depth.into());
+                self
+            }
+            pub fn pierce(mut self, pierce: impl Into<bool>) -> Self {
+                self.pierce = Some(pierce.into());
+                self
+            }
+            pub fn build(self) -> DescribeNodeParams {
+                DescribeNodeParams {
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                    depth: self.depth,
+                    pierce: self.pierce,
+                }
+            }
+        }
+        impl DescribeNodeParams {
+            pub const IDENTIFIER: &'static str = "DOM.describeNode";
+        }
+        impl chromiumoxide_types::Method for DescribeNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DescribeNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Describes node given its id, does not require domain to be enabled. Does not start tracking any\nobjects, can be used for automation.\n[describeNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-describeNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DescribeNodeReturns {
+            #[doc = "Node description."]
+            #[serde(rename = "node")]
+            pub node: Node,
+        }
+        impl DescribeNodeReturns {
+            pub fn new(node: impl Into<Node>) -> Self {
+                Self { node: node.into() }
+            }
+        }
+        impl DescribeNodeReturns {
+            pub fn builder() -> DescribeNodeReturnsBuilder {
+                DescribeNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DescribeNodeReturnsBuilder {
+            node: Option<Node>,
+        }
+        impl DescribeNodeReturnsBuilder {
+            pub fn node(mut self, node: impl Into<Node>) -> Self {
+                self.node = Some(node.into());
+                self
+            }
+            pub fn build(self) -> Result<DescribeNodeReturns, String> {
+                Ok(DescribeNodeReturns {
+                    node: self.node.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for DescribeNodeParams {
+            type Response = DescribeNodeReturns;
+        }
+        #[doc = "Scrolls the specified rect of the given node into view if not already visible.\nNote: exactly one between nodeId, backendNodeId and objectId should be passed\nto identify the node.\n[scrollIntoViewIfNeeded](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-scrollIntoViewIfNeeded)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ScrollIntoViewIfNeededParams {
+            #[doc = "Identifier of the node."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+            #[doc = "Identifier of the backend node."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<BackendNodeId>,
+            #[doc = "JavaScript object id of the node wrapper."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            #[doc = "The rect to be scrolled into view, relative to the node's border box, in CSS pixels.\nWhen omitted, center of the node will be used, similar to Element.scrollIntoView."]
+            #[serde(rename = "rect")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub rect: Option<Rect>,
+        }
+        impl ScrollIntoViewIfNeededParams {
+            pub fn builder() -> ScrollIntoViewIfNeededParamsBuilder {
+                ScrollIntoViewIfNeededParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScrollIntoViewIfNeededParamsBuilder {
+            node_id: Option<NodeId>,
+            backend_node_id: Option<BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            rect: Option<Rect>,
+        }
+        impl ScrollIntoViewIfNeededParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn rect(mut self, rect: impl Into<Rect>) -> Self {
+                self.rect = Some(rect.into());
+                self
+            }
+            pub fn build(self) -> ScrollIntoViewIfNeededParams {
+                ScrollIntoViewIfNeededParams {
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                    rect: self.rect,
+                }
+            }
+        }
+        impl ScrollIntoViewIfNeededParams {
+            pub const IDENTIFIER: &'static str = "DOM.scrollIntoViewIfNeeded";
+        }
+        impl chromiumoxide_types::Method for ScrollIntoViewIfNeededParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ScrollIntoViewIfNeededParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Scrolls the specified rect of the given node into view if not already visible.\nNote: exactly one between nodeId, backendNodeId and objectId should be passed\nto identify the node.\n[scrollIntoViewIfNeeded](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-scrollIntoViewIfNeeded)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ScrollIntoViewIfNeededReturns {}
+        impl chromiumoxide_types::Command for ScrollIntoViewIfNeededParams {
+            type Response = ScrollIntoViewIfNeededReturns;
+        }
+        #[doc = "Disables DOM agent for the given page.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "DOM.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables DOM agent for the given page.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Discards search results from the session with the given id. `getSearchResults` should no longer\nbe called for that search.\n[discardSearchResults](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-discardSearchResults)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DiscardSearchResultsParams {
+            #[doc = "Unique search session identifier."]
+            #[serde(rename = "searchId")]
+            pub search_id: String,
+        }
+        impl DiscardSearchResultsParams {
+            pub fn new(search_id: impl Into<String>) -> Self {
+                Self {
+                    search_id: search_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for DiscardSearchResultsParams {
+            fn from(url: T) -> Self {
+                DiscardSearchResultsParams::new(url)
+            }
+        }
+        impl DiscardSearchResultsParams {
+            pub fn builder() -> DiscardSearchResultsParamsBuilder {
+                DiscardSearchResultsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DiscardSearchResultsParamsBuilder {
+            search_id: Option<String>,
+        }
+        impl DiscardSearchResultsParamsBuilder {
+            pub fn search_id(mut self, search_id: impl Into<String>) -> Self {
+                self.search_id = Some(search_id.into());
+                self
+            }
+            pub fn build(self) -> Result<DiscardSearchResultsParams, String> {
+                Ok(DiscardSearchResultsParams {
+                    search_id: self.search_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(search_id))
+                    })?,
+                })
+            }
+        }
+        impl DiscardSearchResultsParams {
+            pub const IDENTIFIER: &'static str = "DOM.discardSearchResults";
+        }
+        impl chromiumoxide_types::Method for DiscardSearchResultsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DiscardSearchResultsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Discards search results from the session with the given id. `getSearchResults` should no longer\nbe called for that search.\n[discardSearchResults](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-discardSearchResults)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DiscardSearchResultsReturns {}
+        impl chromiumoxide_types::Command for DiscardSearchResultsParams {
+            type Response = DiscardSearchResultsReturns;
+        }
+        #[doc = "Enables DOM agent for the given page.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[doc = "Whether to include whitespaces in the children array of returned Nodes."]
+            #[serde(rename = "includeWhitespace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub include_whitespace: Option<EnableIncludeWhitespace>,
+        }
+        #[doc = "Whether to include whitespaces in the children array of returned Nodes."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum EnableIncludeWhitespace {
+            #[doc = "Strip whitespaces from child arrays (default)."]
+            #[serde(rename = "none")]
+            None,
+            #[doc = "Return all children including block-level whitespace nodes."]
+            #[serde(rename = "all")]
+            All,
+        }
+        impl AsRef<str> for EnableIncludeWhitespace {
+            fn as_ref(&self) -> &str {
+                match self {
+                    EnableIncludeWhitespace::None => "none",
+                    EnableIncludeWhitespace::All => "all",
+                }
+            }
+        }
+        impl ::std::str::FromStr for EnableIncludeWhitespace {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "none" | "None" => Ok(EnableIncludeWhitespace::None),
+                    "all" | "All" => Ok(EnableIncludeWhitespace::All),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            include_whitespace: Option<EnableIncludeWhitespace>,
+        }
+        impl EnableParamsBuilder {
+            pub fn include_whitespace(
+                mut self,
+                include_whitespace: impl Into<EnableIncludeWhitespace>,
+            ) -> Self {
+                self.include_whitespace = Some(include_whitespace.into());
+                self
+            }
+            pub fn build(self) -> EnableParams {
+                EnableParams {
+                    include_whitespace: self.include_whitespace,
+                }
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "DOM.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables DOM agent for the given page.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Focuses the given element.\n[focus](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-focus)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct FocusParams {
+            #[doc = "Identifier of the node."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+            #[doc = "Identifier of the backend node."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<BackendNodeId>,
+            #[doc = "JavaScript object id of the node wrapper."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl FocusParams {
+            pub fn builder() -> FocusParamsBuilder {
+                FocusParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FocusParamsBuilder {
+            node_id: Option<NodeId>,
+            backend_node_id: Option<BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl FocusParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> FocusParams {
+                FocusParams {
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                }
+            }
+        }
+        impl FocusParams {
+            pub const IDENTIFIER: &'static str = "DOM.focus";
+        }
+        impl chromiumoxide_types::Method for FocusParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for FocusParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Focuses the given element.\n[focus](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-focus)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct FocusReturns {}
+        impl chromiumoxide_types::Command for FocusParams {
+            type Response = FocusReturns;
+        }
+        #[doc = "Returns attributes for the specified node.\n[getAttributes](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getAttributes)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAttributesParams {
+            #[doc = "Id of the node to retrieve attributes for."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl GetAttributesParams {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetAttributesParams {
+            pub fn builder() -> GetAttributesParamsBuilder {
+                GetAttributesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAttributesParamsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl GetAttributesParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetAttributesParams, String> {
+                Ok(GetAttributesParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetAttributesParams {
+            pub const IDENTIFIER: &'static str = "DOM.getAttributes";
+        }
+        impl chromiumoxide_types::Method for GetAttributesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetAttributesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns attributes for the specified node.\n[getAttributes](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getAttributes)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAttributesReturns {
+            #[doc = "An interleaved array of node attribute names and values."]
+            #[serde(rename = "attributes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub attributes: Vec<String>,
+        }
+        impl GetAttributesReturns {
+            pub fn new(attributes: Vec<String>) -> Self {
+                Self { attributes }
+            }
+        }
+        impl GetAttributesReturns {
+            pub fn builder() -> GetAttributesReturnsBuilder {
+                GetAttributesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAttributesReturnsBuilder {
+            attributes: Option<Vec<String>>,
+        }
+        impl GetAttributesReturnsBuilder {
+            pub fn attribute(mut self, attribute: impl Into<String>) -> Self {
+                let v = self.attributes.get_or_insert(Vec::new());
+                v.push(attribute.into());
+                self
+            }
+            pub fn attributes<I, S>(mut self, attributes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.attributes.get_or_insert(Vec::new());
+                for val in attributes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetAttributesReturns, String> {
+                Ok(GetAttributesReturns {
+                    attributes: self.attributes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(attributes))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetAttributesParams {
+            type Response = GetAttributesReturns;
+        }
+        #[doc = "Returns boxes for the given node.\n[getBoxModel](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getBoxModel)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetBoxModelParams {
+            #[doc = "Identifier of the node."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+            #[doc = "Identifier of the backend node."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<BackendNodeId>,
+            #[doc = "JavaScript object id of the node wrapper."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl GetBoxModelParams {
+            pub fn builder() -> GetBoxModelParamsBuilder {
+                GetBoxModelParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetBoxModelParamsBuilder {
+            node_id: Option<NodeId>,
+            backend_node_id: Option<BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl GetBoxModelParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> GetBoxModelParams {
+                GetBoxModelParams {
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                }
+            }
+        }
+        impl GetBoxModelParams {
+            pub const IDENTIFIER: &'static str = "DOM.getBoxModel";
+        }
+        impl chromiumoxide_types::Method for GetBoxModelParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetBoxModelParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns boxes for the given node.\n[getBoxModel](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getBoxModel)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetBoxModelReturns {
+            #[doc = "Box model for the node."]
+            #[serde(rename = "model")]
+            pub model: BoxModel,
+        }
+        impl GetBoxModelReturns {
+            pub fn new(model: impl Into<BoxModel>) -> Self {
+                Self {
+                    model: model.into(),
+                }
+            }
+        }
+        impl GetBoxModelReturns {
+            pub fn builder() -> GetBoxModelReturnsBuilder {
+                GetBoxModelReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetBoxModelReturnsBuilder {
+            model: Option<BoxModel>,
+        }
+        impl GetBoxModelReturnsBuilder {
+            pub fn model(mut self, model: impl Into<BoxModel>) -> Self {
+                self.model = Some(model.into());
+                self
+            }
+            pub fn build(self) -> Result<GetBoxModelReturns, String> {
+                Ok(GetBoxModelReturns {
+                    model: self.model.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(model))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetBoxModelParams {
+            type Response = GetBoxModelReturns;
+        }
+        #[doc = "Returns quads that describe node position on the page. This method\nmight return multiple quads for inline nodes.\n[getContentQuads](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getContentQuads)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetContentQuadsParams {
+            #[doc = "Identifier of the node."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+            #[doc = "Identifier of the backend node."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<BackendNodeId>,
+            #[doc = "JavaScript object id of the node wrapper."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl GetContentQuadsParams {
+            pub fn builder() -> GetContentQuadsParamsBuilder {
+                GetContentQuadsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetContentQuadsParamsBuilder {
+            node_id: Option<NodeId>,
+            backend_node_id: Option<BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl GetContentQuadsParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> GetContentQuadsParams {
+                GetContentQuadsParams {
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                }
+            }
+        }
+        impl GetContentQuadsParams {
+            pub const IDENTIFIER: &'static str = "DOM.getContentQuads";
+        }
+        impl chromiumoxide_types::Method for GetContentQuadsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetContentQuadsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns quads that describe node position on the page. This method\nmight return multiple quads for inline nodes.\n[getContentQuads](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getContentQuads)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetContentQuadsReturns {
+            #[doc = "Quads that describe node layout relative to viewport."]
+            #[serde(rename = "quads")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub quads: Vec<Quad>,
+        }
+        impl GetContentQuadsReturns {
+            pub fn new(quads: Vec<Quad>) -> Self {
+                Self { quads }
+            }
+        }
+        impl GetContentQuadsReturns {
+            pub fn builder() -> GetContentQuadsReturnsBuilder {
+                GetContentQuadsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetContentQuadsReturnsBuilder {
+            quads: Option<Vec<Quad>>,
+        }
+        impl GetContentQuadsReturnsBuilder {
+            pub fn quad(mut self, quad: impl Into<Quad>) -> Self {
+                let v = self.quads.get_or_insert(Vec::new());
+                v.push(quad.into());
+                self
+            }
+            pub fn quads<I, S>(mut self, quads: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Quad>,
+            {
+                let v = self.quads.get_or_insert(Vec::new());
+                for val in quads {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetContentQuadsReturns, String> {
+                Ok(GetContentQuadsReturns {
+                    quads: self.quads.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(quads))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetContentQuadsParams {
+            type Response = GetContentQuadsReturns;
+        }
+        #[doc = "Returns the root DOM node (and optionally the subtree) to the caller.\nImplicitly enables the DOM domain events for the current target.\n[getDocument](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getDocument)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetDocumentParams {
+            #[doc = "The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the\nentire subtree or provide an integer larger than 0."]
+            #[serde(rename = "depth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub depth: Option<i64>,
+            #[doc = "Whether or not iframes and shadow roots should be traversed when returning the subtree\n(default is false)."]
+            #[serde(rename = "pierce")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pierce: Option<bool>,
+        }
+        impl GetDocumentParams {
+            pub fn builder() -> GetDocumentParamsBuilder {
+                GetDocumentParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDocumentParamsBuilder {
+            depth: Option<i64>,
+            pierce: Option<bool>,
+        }
+        impl GetDocumentParamsBuilder {
+            pub fn depth(mut self, depth: impl Into<i64>) -> Self {
+                self.depth = Some(depth.into());
+                self
+            }
+            pub fn pierce(mut self, pierce: impl Into<bool>) -> Self {
+                self.pierce = Some(pierce.into());
+                self
+            }
+            pub fn build(self) -> GetDocumentParams {
+                GetDocumentParams {
+                    depth: self.depth,
+                    pierce: self.pierce,
+                }
+            }
+        }
+        impl GetDocumentParams {
+            pub const IDENTIFIER: &'static str = "DOM.getDocument";
+        }
+        impl chromiumoxide_types::Method for GetDocumentParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetDocumentParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the root DOM node (and optionally the subtree) to the caller.\nImplicitly enables the DOM domain events for the current target.\n[getDocument](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getDocument)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetDocumentReturns {
+            #[doc = "Resulting node."]
+            #[serde(rename = "root")]
+            pub root: Node,
+        }
+        impl GetDocumentReturns {
+            pub fn new(root: impl Into<Node>) -> Self {
+                Self { root: root.into() }
+            }
+        }
+        impl GetDocumentReturns {
+            pub fn builder() -> GetDocumentReturnsBuilder {
+                GetDocumentReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDocumentReturnsBuilder {
+            root: Option<Node>,
+        }
+        impl GetDocumentReturnsBuilder {
+            pub fn root(mut self, root: impl Into<Node>) -> Self {
+                self.root = Some(root.into());
+                self
+            }
+            pub fn build(self) -> Result<GetDocumentReturns, String> {
+                Ok(GetDocumentReturns {
+                    root: self.root.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(root))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetDocumentParams {
+            type Response = GetDocumentReturns;
+        }
+        #[doc = "Finds nodes with a given computed style in a subtree.\n[getNodesForSubtreeByStyle](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getNodesForSubtreeByStyle)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetNodesForSubtreeByStyleParams {
+            #[doc = "Node ID pointing to the root of a subtree."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "The style to filter nodes by (includes nodes if any of properties matches)."]
+            #[serde(rename = "computedStyles")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub computed_styles: Vec<CssComputedStyleProperty>,
+            #[doc = "Whether or not iframes and shadow roots in the same target should be traversed when returning the\nresults (default is false)."]
+            #[serde(rename = "pierce")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pierce: Option<bool>,
+        }
+        impl GetNodesForSubtreeByStyleParams {
+            pub fn new(
+                node_id: impl Into<NodeId>,
+                computed_styles: Vec<CssComputedStyleProperty>,
+            ) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    computed_styles,
+                    pierce: None,
+                }
+            }
+        }
+        impl GetNodesForSubtreeByStyleParams {
+            pub fn builder() -> GetNodesForSubtreeByStyleParamsBuilder {
+                GetNodesForSubtreeByStyleParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetNodesForSubtreeByStyleParamsBuilder {
+            node_id: Option<NodeId>,
+            computed_styles: Option<Vec<CssComputedStyleProperty>>,
+            pierce: Option<bool>,
+        }
+        impl GetNodesForSubtreeByStyleParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn computed_style(
+                mut self,
+                computed_style: impl Into<CssComputedStyleProperty>,
+            ) -> Self {
+                let v = self.computed_styles.get_or_insert(Vec::new());
+                v.push(computed_style.into());
+                self
+            }
+            pub fn computed_styles<I, S>(mut self, computed_styles: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CssComputedStyleProperty>,
+            {
+                let v = self.computed_styles.get_or_insert(Vec::new());
+                for val in computed_styles {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn pierce(mut self, pierce: impl Into<bool>) -> Self {
+                self.pierce = Some(pierce.into());
+                self
+            }
+            pub fn build(self) -> Result<GetNodesForSubtreeByStyleParams, String> {
+                Ok(GetNodesForSubtreeByStyleParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    computed_styles: self.computed_styles.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(computed_styles))
+                    })?,
+                    pierce: self.pierce,
+                })
+            }
+        }
+        impl GetNodesForSubtreeByStyleParams {
+            pub const IDENTIFIER: &'static str = "DOM.getNodesForSubtreeByStyle";
+        }
+        impl chromiumoxide_types::Method for GetNodesForSubtreeByStyleParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetNodesForSubtreeByStyleParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Finds nodes with a given computed style in a subtree.\n[getNodesForSubtreeByStyle](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getNodesForSubtreeByStyle)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetNodesForSubtreeByStyleReturns {
+            #[doc = "Resulting nodes."]
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<NodeId>,
+        }
+        impl GetNodesForSubtreeByStyleReturns {
+            pub fn new(node_ids: Vec<NodeId>) -> Self {
+                Self { node_ids }
+            }
+        }
+        impl GetNodesForSubtreeByStyleReturns {
+            pub fn builder() -> GetNodesForSubtreeByStyleReturnsBuilder {
+                GetNodesForSubtreeByStyleReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetNodesForSubtreeByStyleReturnsBuilder {
+            node_ids: Option<Vec<NodeId>>,
+        }
+        impl GetNodesForSubtreeByStyleReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                v.push(node_id.into());
+                self
+            }
+            pub fn node_ids<I, S>(mut self, node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NodeId>,
+            {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                for val in node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetNodesForSubtreeByStyleReturns, String> {
+                Ok(GetNodesForSubtreeByStyleReturns {
+                    node_ids: self.node_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_ids))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetNodesForSubtreeByStyleParams {
+            type Response = GetNodesForSubtreeByStyleReturns;
+        }
+        #[doc = "Returns node id at given location. Depending on whether DOM domain is enabled, nodeId is\neither returned or not.\n[getNodeForLocation](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getNodeForLocation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetNodeForLocationParams {
+            #[doc = "X coordinate."]
+            #[serde(rename = "x")]
+            pub x: i64,
+            #[doc = "Y coordinate."]
+            #[serde(rename = "y")]
+            pub y: i64,
+            #[doc = "False to skip to the nearest non-UA shadow root ancestor (default: false)."]
+            #[serde(rename = "includeUserAgentShadowDOM")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_user_agent_shadow_dom: Option<bool>,
+            #[doc = "Whether to ignore pointer-events: none on elements and hit test them."]
+            #[serde(rename = "ignorePointerEventsNone")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub ignore_pointer_events_none: Option<bool>,
+        }
+        impl GetNodeForLocationParams {
+            pub fn new(x: impl Into<i64>, y: impl Into<i64>) -> Self {
+                Self {
+                    x: x.into(),
+                    y: y.into(),
+                    include_user_agent_shadow_dom: None,
+                    ignore_pointer_events_none: None,
+                }
+            }
+        }
+        impl GetNodeForLocationParams {
+            pub fn builder() -> GetNodeForLocationParamsBuilder {
+                GetNodeForLocationParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetNodeForLocationParamsBuilder {
+            x: Option<i64>,
+            y: Option<i64>,
+            include_user_agent_shadow_dom: Option<bool>,
+            ignore_pointer_events_none: Option<bool>,
+        }
+        impl GetNodeForLocationParamsBuilder {
+            pub fn x(mut self, x: impl Into<i64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<i64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn include_user_agent_shadow_dom(
+                mut self,
+                include_user_agent_shadow_dom: impl Into<bool>,
+            ) -> Self {
+                self.include_user_agent_shadow_dom = Some(include_user_agent_shadow_dom.into());
+                self
+            }
+            pub fn ignore_pointer_events_none(
+                mut self,
+                ignore_pointer_events_none: impl Into<bool>,
+            ) -> Self {
+                self.ignore_pointer_events_none = Some(ignore_pointer_events_none.into());
+                self
+            }
+            pub fn build(self) -> Result<GetNodeForLocationParams, String> {
+                Ok(GetNodeForLocationParams {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    include_user_agent_shadow_dom: self.include_user_agent_shadow_dom,
+                    ignore_pointer_events_none: self.ignore_pointer_events_none,
+                })
+            }
+        }
+        impl GetNodeForLocationParams {
+            pub const IDENTIFIER: &'static str = "DOM.getNodeForLocation";
+        }
+        impl chromiumoxide_types::Method for GetNodeForLocationParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetNodeForLocationParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns node id at given location. Depending on whether DOM domain is enabled, nodeId is\neither returned or not.\n[getNodeForLocation](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getNodeForLocation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetNodeForLocationReturns {
+            #[doc = "Resulting node."]
+            #[serde(rename = "backendNodeId")]
+            pub backend_node_id: BackendNodeId,
+            #[doc = "Frame this node belongs to."]
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+            #[doc = "Id of the node at given coordinates, only when enabled and requested document."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+        }
+        impl GetNodeForLocationReturns {
+            pub fn new(
+                backend_node_id: impl Into<BackendNodeId>,
+                frame_id: impl Into<super::page::FrameId>,
+            ) -> Self {
+                Self {
+                    backend_node_id: backend_node_id.into(),
+                    frame_id: frame_id.into(),
+                    node_id: None,
+                }
+            }
+        }
+        impl GetNodeForLocationReturns {
+            pub fn builder() -> GetNodeForLocationReturnsBuilder {
+                GetNodeForLocationReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetNodeForLocationReturnsBuilder {
+            backend_node_id: Option<BackendNodeId>,
+            frame_id: Option<super::page::FrameId>,
+            node_id: Option<NodeId>,
+        }
+        impl GetNodeForLocationReturnsBuilder {
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetNodeForLocationReturns, String> {
+                Ok(GetNodeForLocationReturns {
+                    backend_node_id: self.backend_node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(backend_node_id))
+                    })?,
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    node_id: self.node_id,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetNodeForLocationParams {
+            type Response = GetNodeForLocationReturns;
+        }
+        #[doc = "Returns node's HTML markup.\n[getOuterHTML](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getOuterHTML)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetOuterHtmlParams {
+            #[doc = "Identifier of the node."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+            #[doc = "Identifier of the backend node."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<BackendNodeId>,
+            #[doc = "JavaScript object id of the node wrapper."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            #[doc = "Include all shadow roots. Equals to false if not specified."]
+            #[serde(rename = "includeShadowDOM")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_shadow_dom: Option<bool>,
+        }
+        impl GetOuterHtmlParams {
+            pub fn builder() -> GetOuterHtmlParamsBuilder {
+                GetOuterHtmlParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetOuterHtmlParamsBuilder {
+            node_id: Option<NodeId>,
+            backend_node_id: Option<BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            include_shadow_dom: Option<bool>,
+        }
+        impl GetOuterHtmlParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn include_shadow_dom(mut self, include_shadow_dom: impl Into<bool>) -> Self {
+                self.include_shadow_dom = Some(include_shadow_dom.into());
+                self
+            }
+            pub fn build(self) -> GetOuterHtmlParams {
+                GetOuterHtmlParams {
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                    include_shadow_dom: self.include_shadow_dom,
+                }
+            }
+        }
+        impl GetOuterHtmlParams {
+            pub const IDENTIFIER: &'static str = "DOM.getOuterHTML";
+        }
+        impl chromiumoxide_types::Method for GetOuterHtmlParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetOuterHtmlParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns node's HTML markup.\n[getOuterHTML](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getOuterHTML)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetOuterHtmlReturns {
+            #[doc = "Outer HTML markup."]
+            #[serde(rename = "outerHTML")]
+            pub outer_html: String,
+        }
+        impl GetOuterHtmlReturns {
+            pub fn new(outer_html: impl Into<String>) -> Self {
+                Self {
+                    outer_html: outer_html.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetOuterHtmlReturns {
+            fn from(url: T) -> Self {
+                GetOuterHtmlReturns::new(url)
+            }
+        }
+        impl GetOuterHtmlReturns {
+            pub fn builder() -> GetOuterHtmlReturnsBuilder {
+                GetOuterHtmlReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetOuterHtmlReturnsBuilder {
+            outer_html: Option<String>,
+        }
+        impl GetOuterHtmlReturnsBuilder {
+            pub fn outer_html(mut self, outer_html: impl Into<String>) -> Self {
+                self.outer_html = Some(outer_html.into());
+                self
+            }
+            pub fn build(self) -> Result<GetOuterHtmlReturns, String> {
+                Ok(GetOuterHtmlReturns {
+                    outer_html: self.outer_html.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(outer_html))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetOuterHtmlParams {
+            type Response = GetOuterHtmlReturns;
+        }
+        #[doc = "Returns the id of the nearest ancestor that is a relayout boundary.\n[getRelayoutBoundary](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getRelayoutBoundary)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetRelayoutBoundaryParams {
+            #[doc = "Id of the node."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl GetRelayoutBoundaryParams {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetRelayoutBoundaryParams {
+            pub fn builder() -> GetRelayoutBoundaryParamsBuilder {
+                GetRelayoutBoundaryParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetRelayoutBoundaryParamsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl GetRelayoutBoundaryParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetRelayoutBoundaryParams, String> {
+                Ok(GetRelayoutBoundaryParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetRelayoutBoundaryParams {
+            pub const IDENTIFIER: &'static str = "DOM.getRelayoutBoundary";
+        }
+        impl chromiumoxide_types::Method for GetRelayoutBoundaryParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetRelayoutBoundaryParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the id of the nearest ancestor that is a relayout boundary.\n[getRelayoutBoundary](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getRelayoutBoundary)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetRelayoutBoundaryReturns {
+            #[doc = "Relayout boundary node id for the given node."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl GetRelayoutBoundaryReturns {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetRelayoutBoundaryReturns {
+            pub fn builder() -> GetRelayoutBoundaryReturnsBuilder {
+                GetRelayoutBoundaryReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetRelayoutBoundaryReturnsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl GetRelayoutBoundaryReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetRelayoutBoundaryReturns, String> {
+                Ok(GetRelayoutBoundaryReturns {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetRelayoutBoundaryParams {
+            type Response = GetRelayoutBoundaryReturns;
+        }
+        #[doc = "Returns search results from given `fromIndex` to given `toIndex` from the search with the given\nidentifier.\n[getSearchResults](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getSearchResults)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSearchResultsParams {
+            #[doc = "Unique search session identifier."]
+            #[serde(rename = "searchId")]
+            pub search_id: String,
+            #[doc = "Start index of the search result to be returned."]
+            #[serde(rename = "fromIndex")]
+            pub from_index: i64,
+            #[doc = "End index of the search result to be returned."]
+            #[serde(rename = "toIndex")]
+            pub to_index: i64,
+        }
+        impl GetSearchResultsParams {
+            pub fn new(
+                search_id: impl Into<String>,
+                from_index: impl Into<i64>,
+                to_index: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    search_id: search_id.into(),
+                    from_index: from_index.into(),
+                    to_index: to_index.into(),
+                }
+            }
+        }
+        impl GetSearchResultsParams {
+            pub fn builder() -> GetSearchResultsParamsBuilder {
+                GetSearchResultsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSearchResultsParamsBuilder {
+            search_id: Option<String>,
+            from_index: Option<i64>,
+            to_index: Option<i64>,
+        }
+        impl GetSearchResultsParamsBuilder {
+            pub fn search_id(mut self, search_id: impl Into<String>) -> Self {
+                self.search_id = Some(search_id.into());
+                self
+            }
+            pub fn from_index(mut self, from_index: impl Into<i64>) -> Self {
+                self.from_index = Some(from_index.into());
+                self
+            }
+            pub fn to_index(mut self, to_index: impl Into<i64>) -> Self {
+                self.to_index = Some(to_index.into());
+                self
+            }
+            pub fn build(self) -> Result<GetSearchResultsParams, String> {
+                Ok(GetSearchResultsParams {
+                    search_id: self.search_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(search_id))
+                    })?,
+                    from_index: self.from_index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(from_index))
+                    })?,
+                    to_index: self.to_index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(to_index))
+                    })?,
+                })
+            }
+        }
+        impl GetSearchResultsParams {
+            pub const IDENTIFIER: &'static str = "DOM.getSearchResults";
+        }
+        impl chromiumoxide_types::Method for GetSearchResultsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetSearchResultsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns search results from given `fromIndex` to given `toIndex` from the search with the given\nidentifier.\n[getSearchResults](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getSearchResults)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSearchResultsReturns {
+            #[doc = "Ids of the search result nodes."]
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<NodeId>,
+        }
+        impl GetSearchResultsReturns {
+            pub fn new(node_ids: Vec<NodeId>) -> Self {
+                Self { node_ids }
+            }
+        }
+        impl GetSearchResultsReturns {
+            pub fn builder() -> GetSearchResultsReturnsBuilder {
+                GetSearchResultsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSearchResultsReturnsBuilder {
+            node_ids: Option<Vec<NodeId>>,
+        }
+        impl GetSearchResultsReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                v.push(node_id.into());
+                self
+            }
+            pub fn node_ids<I, S>(mut self, node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NodeId>,
+            {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                for val in node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetSearchResultsReturns, String> {
+                Ok(GetSearchResultsReturns {
+                    node_ids: self.node_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_ids))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetSearchResultsParams {
+            type Response = GetSearchResultsReturns;
+        }
+        #[doc = "Hides any highlight.\n[hideHighlight](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-hideHighlight)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HideHighlightParams {}
+        impl HideHighlightParams {
+            pub const IDENTIFIER: &'static str = "DOM.hideHighlight";
+        }
+        impl chromiumoxide_types::Method for HideHighlightParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for HideHighlightParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Hides any highlight.\n[hideHighlight](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-hideHighlight)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HideHighlightReturns {}
+        impl chromiumoxide_types::Command for HideHighlightParams {
+            type Response = HideHighlightReturns;
+        }
+        #[doc = "Highlights DOM node.\n[highlightNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-highlightNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HighlightNodeParams {}
+        impl HighlightNodeParams {
+            pub const IDENTIFIER: &'static str = "DOM.highlightNode";
+        }
+        impl chromiumoxide_types::Method for HighlightNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for HighlightNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Highlights DOM node.\n[highlightNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-highlightNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HighlightNodeReturns {}
+        impl chromiumoxide_types::Command for HighlightNodeParams {
+            type Response = HighlightNodeReturns;
+        }
+        #[doc = "Highlights given rectangle.\n[highlightRect](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-highlightRect)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HighlightRectParams {}
+        impl HighlightRectParams {
+            pub const IDENTIFIER: &'static str = "DOM.highlightRect";
+        }
+        impl chromiumoxide_types::Method for HighlightRectParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for HighlightRectParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Highlights given rectangle.\n[highlightRect](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-highlightRect)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HighlightRectReturns {}
+        impl chromiumoxide_types::Command for HighlightRectParams {
+            type Response = HighlightRectReturns;
+        }
+        #[doc = "Marks last undoable state.\n[markUndoableState](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-markUndoableState)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct MarkUndoableStateParams {}
+        impl MarkUndoableStateParams {
+            pub const IDENTIFIER: &'static str = "DOM.markUndoableState";
+        }
+        impl chromiumoxide_types::Method for MarkUndoableStateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for MarkUndoableStateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Marks last undoable state.\n[markUndoableState](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-markUndoableState)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct MarkUndoableStateReturns {}
+        impl chromiumoxide_types::Command for MarkUndoableStateParams {
+            type Response = MarkUndoableStateReturns;
+        }
+        #[doc = "Moves node into the new container, places it before the given anchor.\n[moveTo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-moveTo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct MoveToParams {
+            #[doc = "Id of the node to move."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "Id of the element to drop the moved node into."]
+            #[serde(rename = "targetNodeId")]
+            pub target_node_id: NodeId,
+            #[doc = "Drop node before this one (if absent, the moved node becomes the last child of\n`targetNodeId`)."]
+            #[serde(rename = "insertBeforeNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub insert_before_node_id: Option<NodeId>,
+        }
+        impl MoveToParams {
+            pub fn new(node_id: impl Into<NodeId>, target_node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    target_node_id: target_node_id.into(),
+                    insert_before_node_id: None,
+                }
+            }
+        }
+        impl MoveToParams {
+            pub fn builder() -> MoveToParamsBuilder {
+                MoveToParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct MoveToParamsBuilder {
+            node_id: Option<NodeId>,
+            target_node_id: Option<NodeId>,
+            insert_before_node_id: Option<NodeId>,
+        }
+        impl MoveToParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn target_node_id(mut self, target_node_id: impl Into<NodeId>) -> Self {
+                self.target_node_id = Some(target_node_id.into());
+                self
+            }
+            pub fn insert_before_node_id(
+                mut self,
+                insert_before_node_id: impl Into<NodeId>,
+            ) -> Self {
+                self.insert_before_node_id = Some(insert_before_node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<MoveToParams, String> {
+                Ok(MoveToParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    target_node_id: self.target_node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_node_id))
+                    })?,
+                    insert_before_node_id: self.insert_before_node_id,
+                })
+            }
+        }
+        impl MoveToParams {
+            pub const IDENTIFIER: &'static str = "DOM.moveTo";
+        }
+        impl chromiumoxide_types::Method for MoveToParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for MoveToParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Moves node into the new container, places it before the given anchor.\n[moveTo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-moveTo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct MoveToReturns {
+            #[doc = "New id of the moved node."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl MoveToReturns {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl MoveToReturns {
+            pub fn builder() -> MoveToReturnsBuilder {
+                MoveToReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct MoveToReturnsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl MoveToReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<MoveToReturns, String> {
+                Ok(MoveToReturns {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for MoveToParams {
+            type Response = MoveToReturns;
+        }
+        #[doc = "Searches for a given string in the DOM tree. Use `getSearchResults` to access search results or\n`cancelSearch` to end this search session.\n[performSearch](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-performSearch)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PerformSearchParams {
+            #[doc = "Plain text or query selector or XPath search query."]
+            #[serde(rename = "query")]
+            pub query: String,
+            #[doc = "True to search in user agent shadow DOM."]
+            #[serde(rename = "includeUserAgentShadowDOM")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_user_agent_shadow_dom: Option<bool>,
+        }
+        impl PerformSearchParams {
+            pub fn new(query: impl Into<String>) -> Self {
+                Self {
+                    query: query.into(),
+                    include_user_agent_shadow_dom: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for PerformSearchParams {
+            fn from(url: T) -> Self {
+                PerformSearchParams::new(url)
+            }
+        }
+        impl PerformSearchParams {
+            pub fn builder() -> PerformSearchParamsBuilder {
+                PerformSearchParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PerformSearchParamsBuilder {
+            query: Option<String>,
+            include_user_agent_shadow_dom: Option<bool>,
+        }
+        impl PerformSearchParamsBuilder {
+            pub fn query(mut self, query: impl Into<String>) -> Self {
+                self.query = Some(query.into());
+                self
+            }
+            pub fn include_user_agent_shadow_dom(
+                mut self,
+                include_user_agent_shadow_dom: impl Into<bool>,
+            ) -> Self {
+                self.include_user_agent_shadow_dom = Some(include_user_agent_shadow_dom.into());
+                self
+            }
+            pub fn build(self) -> Result<PerformSearchParams, String> {
+                Ok(PerformSearchParams {
+                    query: self.query.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(query))
+                    })?,
+                    include_user_agent_shadow_dom: self.include_user_agent_shadow_dom,
+                })
+            }
+        }
+        impl PerformSearchParams {
+            pub const IDENTIFIER: &'static str = "DOM.performSearch";
+        }
+        impl chromiumoxide_types::Method for PerformSearchParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for PerformSearchParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Searches for a given string in the DOM tree. Use `getSearchResults` to access search results or\n`cancelSearch` to end this search session.\n[performSearch](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-performSearch)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PerformSearchReturns {
+            #[doc = "Unique search session identifier."]
+            #[serde(rename = "searchId")]
+            pub search_id: String,
+            #[doc = "Number of search results."]
+            #[serde(rename = "resultCount")]
+            pub result_count: i64,
+        }
+        impl PerformSearchReturns {
+            pub fn new(search_id: impl Into<String>, result_count: impl Into<i64>) -> Self {
+                Self {
+                    search_id: search_id.into(),
+                    result_count: result_count.into(),
+                }
+            }
+        }
+        impl PerformSearchReturns {
+            pub fn builder() -> PerformSearchReturnsBuilder {
+                PerformSearchReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PerformSearchReturnsBuilder {
+            search_id: Option<String>,
+            result_count: Option<i64>,
+        }
+        impl PerformSearchReturnsBuilder {
+            pub fn search_id(mut self, search_id: impl Into<String>) -> Self {
+                self.search_id = Some(search_id.into());
+                self
+            }
+            pub fn result_count(mut self, result_count: impl Into<i64>) -> Self {
+                self.result_count = Some(result_count.into());
+                self
+            }
+            pub fn build(self) -> Result<PerformSearchReturns, String> {
+                Ok(PerformSearchReturns {
+                    search_id: self.search_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(search_id))
+                    })?,
+                    result_count: self.result_count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result_count))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for PerformSearchParams {
+            type Response = PerformSearchReturns;
+        }
+        #[doc = "Requests that the node is sent to the caller given its path. // FIXME, use XPath\n[pushNodeByPathToFrontend](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-pushNodeByPathToFrontend)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PushNodeByPathToFrontendParams {
+            #[doc = "Path to node in the proprietary format."]
+            #[serde(rename = "path")]
+            pub path: String,
+        }
+        impl PushNodeByPathToFrontendParams {
+            pub fn new(path: impl Into<String>) -> Self {
+                Self { path: path.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for PushNodeByPathToFrontendParams {
+            fn from(url: T) -> Self {
+                PushNodeByPathToFrontendParams::new(url)
+            }
+        }
+        impl PushNodeByPathToFrontendParams {
+            pub fn builder() -> PushNodeByPathToFrontendParamsBuilder {
+                PushNodeByPathToFrontendParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PushNodeByPathToFrontendParamsBuilder {
+            path: Option<String>,
+        }
+        impl PushNodeByPathToFrontendParamsBuilder {
+            pub fn path(mut self, path: impl Into<String>) -> Self {
+                self.path = Some(path.into());
+                self
+            }
+            pub fn build(self) -> Result<PushNodeByPathToFrontendParams, String> {
+                Ok(PushNodeByPathToFrontendParams {
+                    path: self.path.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(path))
+                    })?,
+                })
+            }
+        }
+        impl PushNodeByPathToFrontendParams {
+            pub const IDENTIFIER: &'static str = "DOM.pushNodeByPathToFrontend";
+        }
+        impl chromiumoxide_types::Method for PushNodeByPathToFrontendParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for PushNodeByPathToFrontendParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests that the node is sent to the caller given its path. // FIXME, use XPath\n[pushNodeByPathToFrontend](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-pushNodeByPathToFrontend)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PushNodeByPathToFrontendReturns {
+            #[doc = "Id of the node for given path."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl PushNodeByPathToFrontendReturns {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl PushNodeByPathToFrontendReturns {
+            pub fn builder() -> PushNodeByPathToFrontendReturnsBuilder {
+                PushNodeByPathToFrontendReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PushNodeByPathToFrontendReturnsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl PushNodeByPathToFrontendReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<PushNodeByPathToFrontendReturns, String> {
+                Ok(PushNodeByPathToFrontendReturns {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for PushNodeByPathToFrontendParams {
+            type Response = PushNodeByPathToFrontendReturns;
+        }
+        #[doc = "Requests that a batch of nodes is sent to the caller given their backend node ids.\n[pushNodesByBackendIdsToFrontend](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-pushNodesByBackendIdsToFrontend)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PushNodesByBackendIdsToFrontendParams {
+            #[doc = "The array of backend node ids."]
+            #[serde(rename = "backendNodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub backend_node_ids: Vec<BackendNodeId>,
+        }
+        impl PushNodesByBackendIdsToFrontendParams {
+            pub fn new(backend_node_ids: Vec<BackendNodeId>) -> Self {
+                Self { backend_node_ids }
+            }
+        }
+        impl PushNodesByBackendIdsToFrontendParams {
+            pub fn builder() -> PushNodesByBackendIdsToFrontendParamsBuilder {
+                PushNodesByBackendIdsToFrontendParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PushNodesByBackendIdsToFrontendParamsBuilder {
+            backend_node_ids: Option<Vec<BackendNodeId>>,
+        }
+        impl PushNodesByBackendIdsToFrontendParamsBuilder {
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                let v = self.backend_node_ids.get_or_insert(Vec::new());
+                v.push(backend_node_id.into());
+                self
+            }
+            pub fn backend_node_ids<I, S>(mut self, backend_node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<BackendNodeId>,
+            {
+                let v = self.backend_node_ids.get_or_insert(Vec::new());
+                for val in backend_node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<PushNodesByBackendIdsToFrontendParams, String> {
+                Ok(PushNodesByBackendIdsToFrontendParams {
+                    backend_node_ids: self.backend_node_ids.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(backend_node_ids)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl PushNodesByBackendIdsToFrontendParams {
+            pub const IDENTIFIER: &'static str = "DOM.pushNodesByBackendIdsToFrontend";
+        }
+        impl chromiumoxide_types::Method for PushNodesByBackendIdsToFrontendParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for PushNodesByBackendIdsToFrontendParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests that a batch of nodes is sent to the caller given their backend node ids.\n[pushNodesByBackendIdsToFrontend](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-pushNodesByBackendIdsToFrontend)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PushNodesByBackendIdsToFrontendReturns {
+            #[doc = "The array of ids of pushed nodes that correspond to the backend ids specified in\nbackendNodeIds."]
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<NodeId>,
+        }
+        impl PushNodesByBackendIdsToFrontendReturns {
+            pub fn new(node_ids: Vec<NodeId>) -> Self {
+                Self { node_ids }
+            }
+        }
+        impl PushNodesByBackendIdsToFrontendReturns {
+            pub fn builder() -> PushNodesByBackendIdsToFrontendReturnsBuilder {
+                PushNodesByBackendIdsToFrontendReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PushNodesByBackendIdsToFrontendReturnsBuilder {
+            node_ids: Option<Vec<NodeId>>,
+        }
+        impl PushNodesByBackendIdsToFrontendReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                v.push(node_id.into());
+                self
+            }
+            pub fn node_ids<I, S>(mut self, node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NodeId>,
+            {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                for val in node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<PushNodesByBackendIdsToFrontendReturns, String> {
+                Ok(PushNodesByBackendIdsToFrontendReturns {
+                    node_ids: self.node_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_ids))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for PushNodesByBackendIdsToFrontendParams {
+            type Response = PushNodesByBackendIdsToFrontendReturns;
+        }
+        #[doc = "Executes `querySelector` on a given node.\n[querySelector](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-querySelector)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct QuerySelectorParams {
+            #[doc = "Id of the node to query upon."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "Selector string."]
+            #[serde(rename = "selector")]
+            pub selector: String,
+        }
+        impl QuerySelectorParams {
+            pub fn new(node_id: impl Into<NodeId>, selector: impl Into<String>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    selector: selector.into(),
+                }
+            }
+        }
+        impl QuerySelectorParams {
+            pub fn builder() -> QuerySelectorParamsBuilder {
+                QuerySelectorParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct QuerySelectorParamsBuilder {
+            node_id: Option<NodeId>,
+            selector: Option<String>,
+        }
+        impl QuerySelectorParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn selector(mut self, selector: impl Into<String>) -> Self {
+                self.selector = Some(selector.into());
+                self
+            }
+            pub fn build(self) -> Result<QuerySelectorParams, String> {
+                Ok(QuerySelectorParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    selector: self.selector.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(selector))
+                    })?,
+                })
+            }
+        }
+        impl QuerySelectorParams {
+            pub const IDENTIFIER: &'static str = "DOM.querySelector";
+        }
+        impl chromiumoxide_types::Method for QuerySelectorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for QuerySelectorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Executes `querySelector` on a given node.\n[querySelector](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-querySelector)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct QuerySelectorReturns {
+            #[doc = "Query selector result."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl QuerySelectorReturns {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl QuerySelectorReturns {
+            pub fn builder() -> QuerySelectorReturnsBuilder {
+                QuerySelectorReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct QuerySelectorReturnsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl QuerySelectorReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<QuerySelectorReturns, String> {
+                Ok(QuerySelectorReturns {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for QuerySelectorParams {
+            type Response = QuerySelectorReturns;
+        }
+        #[doc = "Executes `querySelectorAll` on a given node.\n[querySelectorAll](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-querySelectorAll)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct QuerySelectorAllParams {
+            #[doc = "Id of the node to query upon."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "Selector string."]
+            #[serde(rename = "selector")]
+            pub selector: String,
+        }
+        impl QuerySelectorAllParams {
+            pub fn new(node_id: impl Into<NodeId>, selector: impl Into<String>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    selector: selector.into(),
+                }
+            }
+        }
+        impl QuerySelectorAllParams {
+            pub fn builder() -> QuerySelectorAllParamsBuilder {
+                QuerySelectorAllParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct QuerySelectorAllParamsBuilder {
+            node_id: Option<NodeId>,
+            selector: Option<String>,
+        }
+        impl QuerySelectorAllParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn selector(mut self, selector: impl Into<String>) -> Self {
+                self.selector = Some(selector.into());
+                self
+            }
+            pub fn build(self) -> Result<QuerySelectorAllParams, String> {
+                Ok(QuerySelectorAllParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    selector: self.selector.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(selector))
+                    })?,
+                })
+            }
+        }
+        impl QuerySelectorAllParams {
+            pub const IDENTIFIER: &'static str = "DOM.querySelectorAll";
+        }
+        impl chromiumoxide_types::Method for QuerySelectorAllParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for QuerySelectorAllParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Executes `querySelectorAll` on a given node.\n[querySelectorAll](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-querySelectorAll)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct QuerySelectorAllReturns {
+            #[doc = "Query selector result."]
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<NodeId>,
+        }
+        impl QuerySelectorAllReturns {
+            pub fn new(node_ids: Vec<NodeId>) -> Self {
+                Self { node_ids }
+            }
+        }
+        impl QuerySelectorAllReturns {
+            pub fn builder() -> QuerySelectorAllReturnsBuilder {
+                QuerySelectorAllReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct QuerySelectorAllReturnsBuilder {
+            node_ids: Option<Vec<NodeId>>,
+        }
+        impl QuerySelectorAllReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                v.push(node_id.into());
+                self
+            }
+            pub fn node_ids<I, S>(mut self, node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NodeId>,
+            {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                for val in node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<QuerySelectorAllReturns, String> {
+                Ok(QuerySelectorAllReturns {
+                    node_ids: self.node_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_ids))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for QuerySelectorAllParams {
+            type Response = QuerySelectorAllReturns;
+        }
+        #[doc = "Returns NodeIds of current top layer elements.\nTop layer is rendered closest to the user within a viewport, therefore its elements always\nappear on top of all other content.\n[getTopLayerElements](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getTopLayerElements)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetTopLayerElementsParams {}
+        impl GetTopLayerElementsParams {
+            pub const IDENTIFIER: &'static str = "DOM.getTopLayerElements";
+        }
+        impl chromiumoxide_types::Method for GetTopLayerElementsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetTopLayerElementsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns NodeIds of current top layer elements.\nTop layer is rendered closest to the user within a viewport, therefore its elements always\nappear on top of all other content.\n[getTopLayerElements](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getTopLayerElements)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetTopLayerElementsReturns {
+            #[doc = "NodeIds of top layer elements"]
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<NodeId>,
+        }
+        impl GetTopLayerElementsReturns {
+            pub fn new(node_ids: Vec<NodeId>) -> Self {
+                Self { node_ids }
+            }
+        }
+        impl GetTopLayerElementsReturns {
+            pub fn builder() -> GetTopLayerElementsReturnsBuilder {
+                GetTopLayerElementsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetTopLayerElementsReturnsBuilder {
+            node_ids: Option<Vec<NodeId>>,
+        }
+        impl GetTopLayerElementsReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                v.push(node_id.into());
+                self
+            }
+            pub fn node_ids<I, S>(mut self, node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NodeId>,
+            {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                for val in node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetTopLayerElementsReturns, String> {
+                Ok(GetTopLayerElementsReturns {
+                    node_ids: self.node_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_ids))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetTopLayerElementsParams {
+            type Response = GetTopLayerElementsReturns;
+        }
+        #[doc = "Returns the NodeId of the matched element according to certain relations.\n[getElementByRelation](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getElementByRelation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetElementByRelationParams {
+            #[doc = "Id of the node from which to query the relation."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "Type of relation to get."]
+            #[serde(rename = "relation")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub relation: GetElementByRelationRelation,
+        }
+        #[doc = "Type of relation to get."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum GetElementByRelationRelation {
+            #[doc = "Get the popover target for a given element. In this case, this given\nelement can only be an HTMLFormControlElement (<input>, <button>)."]
+            #[serde(rename = "PopoverTarget")]
+            PopoverTarget,
+            #[doc = "Get the interestfor target (the attribute used to be named\n`interesttarget`) for for a given element."]
+            #[serde(rename = "InterestTarget")]
+            InterestTarget,
+            #[doc = "Get the commandfor target for a given element. In this case, this given\nelement can only be an HTMLButtonElement."]
+            #[serde(rename = "CommandFor")]
+            CommandFor,
+        }
+        impl AsRef<str> for GetElementByRelationRelation {
+            fn as_ref(&self) -> &str {
+                match self {
+                    GetElementByRelationRelation::PopoverTarget => "PopoverTarget",
+                    GetElementByRelationRelation::InterestTarget => "InterestTarget",
+                    GetElementByRelationRelation::CommandFor => "CommandFor",
+                }
+            }
+        }
+        impl ::std::str::FromStr for GetElementByRelationRelation {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "PopoverTarget" | "popovertarget" => {
+                        Ok(GetElementByRelationRelation::PopoverTarget)
+                    }
+                    "InterestTarget" | "interesttarget" => {
+                        Ok(GetElementByRelationRelation::InterestTarget)
+                    }
+                    "CommandFor" | "commandfor" => Ok(GetElementByRelationRelation::CommandFor),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl GetElementByRelationParams {
+            pub fn new(
+                node_id: impl Into<NodeId>,
+                relation: impl Into<GetElementByRelationRelation>,
+            ) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    relation: relation.into(),
+                }
+            }
+        }
+        impl GetElementByRelationParams {
+            pub fn builder() -> GetElementByRelationParamsBuilder {
+                GetElementByRelationParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetElementByRelationParamsBuilder {
+            node_id: Option<NodeId>,
+            relation: Option<GetElementByRelationRelation>,
+        }
+        impl GetElementByRelationParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn relation(mut self, relation: impl Into<GetElementByRelationRelation>) -> Self {
+                self.relation = Some(relation.into());
+                self
+            }
+            pub fn build(self) -> Result<GetElementByRelationParams, String> {
+                Ok(GetElementByRelationParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    relation: self.relation.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(relation))
+                    })?,
+                })
+            }
+        }
+        impl GetElementByRelationParams {
+            pub const IDENTIFIER: &'static str = "DOM.getElementByRelation";
+        }
+        impl chromiumoxide_types::Method for GetElementByRelationParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetElementByRelationParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the NodeId of the matched element according to certain relations.\n[getElementByRelation](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getElementByRelation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetElementByRelationReturns {
+            #[doc = "NodeId of the element matching the queried relation."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl GetElementByRelationReturns {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetElementByRelationReturns {
+            pub fn builder() -> GetElementByRelationReturnsBuilder {
+                GetElementByRelationReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetElementByRelationReturnsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl GetElementByRelationReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetElementByRelationReturns, String> {
+                Ok(GetElementByRelationReturns {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetElementByRelationParams {
+            type Response = GetElementByRelationReturns;
+        }
+        #[doc = "Re-does the last undone action.\n[redo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-redo)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RedoParams {}
+        impl RedoParams {
+            pub const IDENTIFIER: &'static str = "DOM.redo";
+        }
+        impl chromiumoxide_types::Method for RedoParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RedoParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Re-does the last undone action.\n[redo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-redo)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RedoReturns {}
+        impl chromiumoxide_types::Command for RedoParams {
+            type Response = RedoReturns;
+        }
+        #[doc = "Removes attribute with given name from an element with given id.\n[removeAttribute](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-removeAttribute)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveAttributeParams {
+            #[doc = "Id of the element to remove attribute from."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "Name of the attribute to remove."]
+            #[serde(rename = "name")]
+            pub name: String,
+        }
+        impl RemoveAttributeParams {
+            pub fn new(node_id: impl Into<NodeId>, name: impl Into<String>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    name: name.into(),
+                }
+            }
+        }
+        impl RemoveAttributeParams {
+            pub fn builder() -> RemoveAttributeParamsBuilder {
+                RemoveAttributeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveAttributeParamsBuilder {
+            node_id: Option<NodeId>,
+            name: Option<String>,
+        }
+        impl RemoveAttributeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveAttributeParams, String> {
+                Ok(RemoveAttributeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                })
+            }
+        }
+        impl RemoveAttributeParams {
+            pub const IDENTIFIER: &'static str = "DOM.removeAttribute";
+        }
+        impl chromiumoxide_types::Method for RemoveAttributeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveAttributeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes attribute with given name from an element with given id.\n[removeAttribute](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-removeAttribute)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveAttributeReturns {}
+        impl chromiumoxide_types::Command for RemoveAttributeParams {
+            type Response = RemoveAttributeReturns;
+        }
+        #[doc = "Removes node with given id.\n[removeNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-removeNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveNodeParams {
+            #[doc = "Id of the node to remove."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl RemoveNodeParams {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl RemoveNodeParams {
+            pub fn builder() -> RemoveNodeParamsBuilder {
+                RemoveNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveNodeParamsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl RemoveNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveNodeParams, String> {
+                Ok(RemoveNodeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl RemoveNodeParams {
+            pub const IDENTIFIER: &'static str = "DOM.removeNode";
+        }
+        impl chromiumoxide_types::Method for RemoveNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes node with given id.\n[removeNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-removeNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveNodeReturns {}
+        impl chromiumoxide_types::Command for RemoveNodeParams {
+            type Response = RemoveNodeReturns;
+        }
+        #[doc = "Requests that children of the node with given id are returned to the caller in form of\n`setChildNodes` events where not only immediate children are retrieved, but all children down to\nthe specified depth.\n[requestChildNodes](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-requestChildNodes)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestChildNodesParams {
+            #[doc = "Id of the node to get children for."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the\nentire subtree or provide an integer larger than 0."]
+            #[serde(rename = "depth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub depth: Option<i64>,
+            #[doc = "Whether or not iframes and shadow roots should be traversed when returning the sub-tree\n(default is false)."]
+            #[serde(rename = "pierce")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pierce: Option<bool>,
+        }
+        impl RequestChildNodesParams {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    depth: None,
+                    pierce: None,
+                }
+            }
+        }
+        impl RequestChildNodesParams {
+            pub fn builder() -> RequestChildNodesParamsBuilder {
+                RequestChildNodesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestChildNodesParamsBuilder {
+            node_id: Option<NodeId>,
+            depth: Option<i64>,
+            pierce: Option<bool>,
+        }
+        impl RequestChildNodesParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn depth(mut self, depth: impl Into<i64>) -> Self {
+                self.depth = Some(depth.into());
+                self
+            }
+            pub fn pierce(mut self, pierce: impl Into<bool>) -> Self {
+                self.pierce = Some(pierce.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestChildNodesParams, String> {
+                Ok(RequestChildNodesParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    depth: self.depth,
+                    pierce: self.pierce,
+                })
+            }
+        }
+        impl RequestChildNodesParams {
+            pub const IDENTIFIER: &'static str = "DOM.requestChildNodes";
+        }
+        impl chromiumoxide_types::Method for RequestChildNodesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RequestChildNodesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests that children of the node with given id are returned to the caller in form of\n`setChildNodes` events where not only immediate children are retrieved, but all children down to\nthe specified depth.\n[requestChildNodes](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-requestChildNodes)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RequestChildNodesReturns {}
+        impl chromiumoxide_types::Command for RequestChildNodesParams {
+            type Response = RequestChildNodesReturns;
+        }
+        #[doc = "Requests that the node is sent to the caller given the JavaScript node object reference. All\nnodes that form the path from the node to the root are also sent to the client as a series of\n`setChildNodes` notifications.\n[requestNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-requestNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestNodeParams {
+            #[doc = "JavaScript object id to convert into node."]
+            #[serde(rename = "objectId")]
+            pub object_id: super::super::js_protocol::runtime::RemoteObjectId,
+        }
+        impl RequestNodeParams {
+            pub fn new(
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                Self {
+                    object_id: object_id.into(),
+                }
+            }
+        }
+        impl RequestNodeParams {
+            pub fn builder() -> RequestNodeParamsBuilder {
+                RequestNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestNodeParamsBuilder {
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl RequestNodeParamsBuilder {
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestNodeParams, String> {
+                Ok(RequestNodeParams {
+                    object_id: self.object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_id))
+                    })?,
+                })
+            }
+        }
+        impl RequestNodeParams {
+            pub const IDENTIFIER: &'static str = "DOM.requestNode";
+        }
+        impl chromiumoxide_types::Method for RequestNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RequestNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests that the node is sent to the caller given the JavaScript node object reference. All\nnodes that form the path from the node to the root are also sent to the client as a series of\n`setChildNodes` notifications.\n[requestNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-requestNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestNodeReturns {
+            #[doc = "Node id for given object."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl RequestNodeReturns {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl RequestNodeReturns {
+            pub fn builder() -> RequestNodeReturnsBuilder {
+                RequestNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestNodeReturnsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl RequestNodeReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestNodeReturns, String> {
+                Ok(RequestNodeReturns {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for RequestNodeParams {
+            type Response = RequestNodeReturns;
+        }
+        #[doc = "Resolves the JavaScript node object for a given NodeId or BackendNodeId.\n[resolveNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-resolveNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResolveNodeParams {
+            #[doc = "Id of the node to resolve."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+            #[doc = "Backend identifier of the node to resolve."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "Symbolic group name that can be used to release multiple objects."]
+            #[serde(rename = "objectGroup")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_group: Option<String>,
+            #[doc = "Execution context in which to resolve the node."]
+            #[serde(rename = "executionContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub execution_context_id:
+                Option<super::super::js_protocol::runtime::ExecutionContextId>,
+        }
+        impl ResolveNodeParams {
+            pub fn builder() -> ResolveNodeParamsBuilder {
+                ResolveNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResolveNodeParamsBuilder {
+            node_id: Option<NodeId>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+            object_group: Option<String>,
+            execution_context_id: Option<super::super::js_protocol::runtime::ExecutionContextId>,
+        }
+        impl ResolveNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_group(mut self, object_group: impl Into<String>) -> Self {
+                self.object_group = Some(object_group.into());
+                self
+            }
+            pub fn execution_context_id(
+                mut self,
+                execution_context_id: impl Into<super::super::js_protocol::runtime::ExecutionContextId>,
+            ) -> Self {
+                self.execution_context_id = Some(execution_context_id.into());
+                self
+            }
+            pub fn build(self) -> ResolveNodeParams {
+                ResolveNodeParams {
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_group: self.object_group,
+                    execution_context_id: self.execution_context_id,
+                }
+            }
+        }
+        impl ResolveNodeParams {
+            pub const IDENTIFIER: &'static str = "DOM.resolveNode";
+        }
+        impl chromiumoxide_types::Method for ResolveNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ResolveNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Resolves the JavaScript node object for a given NodeId or BackendNodeId.\n[resolveNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-resolveNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ResolveNodeReturns {
+            #[doc = "JavaScript object wrapper for given node."]
+            #[serde(rename = "object")]
+            pub object: super::super::js_protocol::runtime::RemoteObject,
+        }
+        impl ResolveNodeReturns {
+            pub fn new(
+                object: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                Self {
+                    object: object.into(),
+                }
+            }
+        }
+        impl ResolveNodeReturns {
+            pub fn builder() -> ResolveNodeReturnsBuilder {
+                ResolveNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResolveNodeReturnsBuilder {
+            object: Option<super::super::js_protocol::runtime::RemoteObject>,
+        }
+        impl ResolveNodeReturnsBuilder {
+            pub fn object(
+                mut self,
+                object: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                self.object = Some(object.into());
+                self
+            }
+            pub fn build(self) -> Result<ResolveNodeReturns, String> {
+                Ok(ResolveNodeReturns {
+                    object: self.object.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for ResolveNodeParams {
+            type Response = ResolveNodeReturns;
+        }
+        #[doc = "Sets attribute for an element with given id.\n[setAttributeValue](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setAttributeValue)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAttributeValueParams {
+            #[doc = "Id of the element to set attribute for."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "Attribute name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Attribute value."]
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl SetAttributeValueParams {
+            pub fn new(
+                node_id: impl Into<NodeId>,
+                name: impl Into<String>,
+                value: impl Into<String>,
+            ) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl SetAttributeValueParams {
+            pub fn builder() -> SetAttributeValueParamsBuilder {
+                SetAttributeValueParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAttributeValueParamsBuilder {
+            node_id: Option<NodeId>,
+            name: Option<String>,
+            value: Option<String>,
+        }
+        impl SetAttributeValueParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAttributeValueParams, String> {
+                Ok(SetAttributeValueParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl SetAttributeValueParams {
+            pub const IDENTIFIER: &'static str = "DOM.setAttributeValue";
+        }
+        impl chromiumoxide_types::Method for SetAttributeValueParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAttributeValueParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets attribute for an element with given id.\n[setAttributeValue](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setAttributeValue)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAttributeValueReturns {}
+        impl chromiumoxide_types::Command for SetAttributeValueParams {
+            type Response = SetAttributeValueReturns;
+        }
+        #[doc = "Sets attributes on element with given id. This method is useful when user edits some existing\nattribute value and types in several attribute name/value pairs.\n[setAttributesAsText](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setAttributesAsText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAttributesAsTextParams {
+            #[doc = "Id of the element to set attributes for."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "Text with a number of attributes. Will parse this text using HTML parser."]
+            #[serde(rename = "text")]
+            pub text: String,
+            #[doc = "Attribute name to replace with new attributes derived from text in case text parsed\nsuccessfully."]
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+        }
+        impl SetAttributesAsTextParams {
+            pub fn new(node_id: impl Into<NodeId>, text: impl Into<String>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    text: text.into(),
+                    name: None,
+                }
+            }
+        }
+        impl SetAttributesAsTextParams {
+            pub fn builder() -> SetAttributesAsTextParamsBuilder {
+                SetAttributesAsTextParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAttributesAsTextParamsBuilder {
+            node_id: Option<NodeId>,
+            text: Option<String>,
+            name: Option<String>,
+        }
+        impl SetAttributesAsTextParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAttributesAsTextParams, String> {
+                Ok(SetAttributesAsTextParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    name: self.name,
+                })
+            }
+        }
+        impl SetAttributesAsTextParams {
+            pub const IDENTIFIER: &'static str = "DOM.setAttributesAsText";
+        }
+        impl chromiumoxide_types::Method for SetAttributesAsTextParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAttributesAsTextParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets attributes on element with given id. This method is useful when user edits some existing\nattribute value and types in several attribute name/value pairs.\n[setAttributesAsText](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setAttributesAsText)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAttributesAsTextReturns {}
+        impl chromiumoxide_types::Command for SetAttributesAsTextParams {
+            type Response = SetAttributesAsTextReturns;
+        }
+        #[doc = "Sets files for the given file input element.\n[setFileInputFiles](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setFileInputFiles)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetFileInputFilesParams {
+            #[doc = "Array of file paths to set."]
+            #[serde(rename = "files")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub files: Vec<String>,
+            #[doc = "Identifier of the node."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+            #[doc = "Identifier of the backend node."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<BackendNodeId>,
+            #[doc = "JavaScript object id of the node wrapper."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl SetFileInputFilesParams {
+            pub fn new(files: Vec<String>) -> Self {
+                Self {
+                    files,
+                    node_id: None,
+                    backend_node_id: None,
+                    object_id: None,
+                }
+            }
+        }
+        impl SetFileInputFilesParams {
+            pub fn builder() -> SetFileInputFilesParamsBuilder {
+                SetFileInputFilesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetFileInputFilesParamsBuilder {
+            files: Option<Vec<String>>,
+            node_id: Option<NodeId>,
+            backend_node_id: Option<BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl SetFileInputFilesParamsBuilder {
+            pub fn file(mut self, file: impl Into<String>) -> Self {
+                let v = self.files.get_or_insert(Vec::new());
+                v.push(file.into());
+                self
+            }
+            pub fn files<I, S>(mut self, files: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.files.get_or_insert(Vec::new());
+                for val in files {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SetFileInputFilesParams, String> {
+                Ok(SetFileInputFilesParams {
+                    files: self.files.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(files))
+                    })?,
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                })
+            }
+        }
+        impl SetFileInputFilesParams {
+            pub const IDENTIFIER: &'static str = "DOM.setFileInputFiles";
+        }
+        impl chromiumoxide_types::Method for SetFileInputFilesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetFileInputFilesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets files for the given file input element.\n[setFileInputFiles](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setFileInputFiles)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetFileInputFilesReturns {}
+        impl chromiumoxide_types::Command for SetFileInputFilesParams {
+            type Response = SetFileInputFilesReturns;
+        }
+        #[doc = "Sets if stack traces should be captured for Nodes. See `Node.getNodeStackTraces`. Default is disabled.\n[setNodeStackTracesEnabled](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setNodeStackTracesEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetNodeStackTracesEnabledParams {
+            #[doc = "Enable or disable."]
+            #[serde(rename = "enable")]
+            pub enable: bool,
+        }
+        impl SetNodeStackTracesEnabledParams {
+            pub fn new(enable: impl Into<bool>) -> Self {
+                Self {
+                    enable: enable.into(),
+                }
+            }
+        }
+        impl SetNodeStackTracesEnabledParams {
+            pub fn builder() -> SetNodeStackTracesEnabledParamsBuilder {
+                SetNodeStackTracesEnabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetNodeStackTracesEnabledParamsBuilder {
+            enable: Option<bool>,
+        }
+        impl SetNodeStackTracesEnabledParamsBuilder {
+            pub fn enable(mut self, enable: impl Into<bool>) -> Self {
+                self.enable = Some(enable.into());
+                self
+            }
+            pub fn build(self) -> Result<SetNodeStackTracesEnabledParams, String> {
+                Ok(SetNodeStackTracesEnabledParams {
+                    enable: self.enable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enable))
+                    })?,
+                })
+            }
+        }
+        impl SetNodeStackTracesEnabledParams {
+            pub const IDENTIFIER: &'static str = "DOM.setNodeStackTracesEnabled";
+        }
+        impl chromiumoxide_types::Method for SetNodeStackTracesEnabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetNodeStackTracesEnabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets if stack traces should be captured for Nodes. See `Node.getNodeStackTraces`. Default is disabled.\n[setNodeStackTracesEnabled](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setNodeStackTracesEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetNodeStackTracesEnabledReturns {}
+        impl chromiumoxide_types::Command for SetNodeStackTracesEnabledParams {
+            type Response = SetNodeStackTracesEnabledReturns;
+        }
+        #[doc = "Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation.\n[getNodeStackTraces](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getNodeStackTraces)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetNodeStackTracesParams {
+            #[doc = "Id of the node to get stack traces for."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl GetNodeStackTracesParams {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetNodeStackTracesParams {
+            pub fn builder() -> GetNodeStackTracesParamsBuilder {
+                GetNodeStackTracesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetNodeStackTracesParamsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl GetNodeStackTracesParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetNodeStackTracesParams, String> {
+                Ok(GetNodeStackTracesParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetNodeStackTracesParams {
+            pub const IDENTIFIER: &'static str = "DOM.getNodeStackTraces";
+        }
+        impl chromiumoxide_types::Method for GetNodeStackTracesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetNodeStackTracesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation.\n[getNodeStackTraces](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getNodeStackTraces)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetNodeStackTracesReturns {
+            #[doc = "Creation stack trace, if available."]
+            #[serde(rename = "creation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub creation: Option<super::super::js_protocol::runtime::StackTrace>,
+        }
+        impl GetNodeStackTracesReturns {
+            pub fn builder() -> GetNodeStackTracesReturnsBuilder {
+                GetNodeStackTracesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetNodeStackTracesReturnsBuilder {
+            creation: Option<super::super::js_protocol::runtime::StackTrace>,
+        }
+        impl GetNodeStackTracesReturnsBuilder {
+            pub fn creation(
+                mut self,
+                creation: impl Into<super::super::js_protocol::runtime::StackTrace>,
+            ) -> Self {
+                self.creation = Some(creation.into());
+                self
+            }
+            pub fn build(self) -> GetNodeStackTracesReturns {
+                GetNodeStackTracesReturns {
+                    creation: self.creation,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for GetNodeStackTracesParams {
+            type Response = GetNodeStackTracesReturns;
+        }
+        #[doc = "Returns file information for the given\nFile wrapper.\n[getFileInfo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getFileInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetFileInfoParams {
+            #[doc = "JavaScript object id of the node wrapper."]
+            #[serde(rename = "objectId")]
+            pub object_id: super::super::js_protocol::runtime::RemoteObjectId,
+        }
+        impl GetFileInfoParams {
+            pub fn new(
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                Self {
+                    object_id: object_id.into(),
+                }
+            }
+        }
+        impl GetFileInfoParams {
+            pub fn builder() -> GetFileInfoParamsBuilder {
+                GetFileInfoParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetFileInfoParamsBuilder {
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl GetFileInfoParamsBuilder {
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetFileInfoParams, String> {
+                Ok(GetFileInfoParams {
+                    object_id: self.object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_id))
+                    })?,
+                })
+            }
+        }
+        impl GetFileInfoParams {
+            pub const IDENTIFIER: &'static str = "DOM.getFileInfo";
+        }
+        impl chromiumoxide_types::Method for GetFileInfoParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetFileInfoParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns file information for the given\nFile wrapper.\n[getFileInfo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getFileInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetFileInfoReturns {
+            #[serde(rename = "path")]
+            pub path: String,
+        }
+        impl GetFileInfoReturns {
+            pub fn new(path: impl Into<String>) -> Self {
+                Self { path: path.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetFileInfoReturns {
+            fn from(url: T) -> Self {
+                GetFileInfoReturns::new(url)
+            }
+        }
+        impl GetFileInfoReturns {
+            pub fn builder() -> GetFileInfoReturnsBuilder {
+                GetFileInfoReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetFileInfoReturnsBuilder {
+            path: Option<String>,
+        }
+        impl GetFileInfoReturnsBuilder {
+            pub fn path(mut self, path: impl Into<String>) -> Self {
+                self.path = Some(path.into());
+                self
+            }
+            pub fn build(self) -> Result<GetFileInfoReturns, String> {
+                Ok(GetFileInfoReturns {
+                    path: self.path.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(path))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetFileInfoParams {
+            type Response = GetFileInfoReturns;
+        }
+        #[doc = "Returns list of detached nodes\n[getDetachedDomNodes](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getDetachedDomNodes)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetDetachedDomNodesParams {}
+        impl GetDetachedDomNodesParams {
+            pub const IDENTIFIER: &'static str = "DOM.getDetachedDomNodes";
+        }
+        impl chromiumoxide_types::Method for GetDetachedDomNodesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetDetachedDomNodesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns list of detached nodes\n[getDetachedDomNodes](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getDetachedDomNodes)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetDetachedDomNodesReturns {
+            #[doc = "The list of detached nodes"]
+            #[serde(rename = "detachedNodes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub detached_nodes: Vec<DetachedElementInfo>,
+        }
+        impl GetDetachedDomNodesReturns {
+            pub fn new(detached_nodes: Vec<DetachedElementInfo>) -> Self {
+                Self { detached_nodes }
+            }
+        }
+        impl GetDetachedDomNodesReturns {
+            pub fn builder() -> GetDetachedDomNodesReturnsBuilder {
+                GetDetachedDomNodesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDetachedDomNodesReturnsBuilder {
+            detached_nodes: Option<Vec<DetachedElementInfo>>,
+        }
+        impl GetDetachedDomNodesReturnsBuilder {
+            pub fn detached_node(mut self, detached_node: impl Into<DetachedElementInfo>) -> Self {
+                let v = self.detached_nodes.get_or_insert(Vec::new());
+                v.push(detached_node.into());
+                self
+            }
+            pub fn detached_nodes<I, S>(mut self, detached_nodes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<DetachedElementInfo>,
+            {
+                let v = self.detached_nodes.get_or_insert(Vec::new());
+                for val in detached_nodes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetDetachedDomNodesReturns, String> {
+                Ok(GetDetachedDomNodesReturns {
+                    detached_nodes: self.detached_nodes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(detached_nodes))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetDetachedDomNodesParams {
+            type Response = GetDetachedDomNodesReturns;
+        }
+        #[doc = "Enables console to refer to the node with given id via $x (see Command Line API for more details\n$x functions).\n[setInspectedNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setInspectedNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetInspectedNodeParams {
+            #[doc = "DOM node id to be accessible by means of $x command line API."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl SetInspectedNodeParams {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl SetInspectedNodeParams {
+            pub fn builder() -> SetInspectedNodeParamsBuilder {
+                SetInspectedNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetInspectedNodeParamsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl SetInspectedNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SetInspectedNodeParams, String> {
+                Ok(SetInspectedNodeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl SetInspectedNodeParams {
+            pub const IDENTIFIER: &'static str = "DOM.setInspectedNode";
+        }
+        impl chromiumoxide_types::Method for SetInspectedNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetInspectedNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables console to refer to the node with given id via $x (see Command Line API for more details\n$x functions).\n[setInspectedNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setInspectedNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetInspectedNodeReturns {}
+        impl chromiumoxide_types::Command for SetInspectedNodeParams {
+            type Response = SetInspectedNodeReturns;
+        }
+        #[doc = "Sets node name for a node with given id.\n[setNodeName](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setNodeName)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetNodeNameParams {
+            #[doc = "Id of the node to set name for."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "New node's name."]
+            #[serde(rename = "name")]
+            pub name: String,
+        }
+        impl SetNodeNameParams {
+            pub fn new(node_id: impl Into<NodeId>, name: impl Into<String>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    name: name.into(),
+                }
+            }
+        }
+        impl SetNodeNameParams {
+            pub fn builder() -> SetNodeNameParamsBuilder {
+                SetNodeNameParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetNodeNameParamsBuilder {
+            node_id: Option<NodeId>,
+            name: Option<String>,
+        }
+        impl SetNodeNameParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn build(self) -> Result<SetNodeNameParams, String> {
+                Ok(SetNodeNameParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                })
+            }
+        }
+        impl SetNodeNameParams {
+            pub const IDENTIFIER: &'static str = "DOM.setNodeName";
+        }
+        impl chromiumoxide_types::Method for SetNodeNameParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetNodeNameParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets node name for a node with given id.\n[setNodeName](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setNodeName)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetNodeNameReturns {
+            #[doc = "New node's id."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl SetNodeNameReturns {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl SetNodeNameReturns {
+            pub fn builder() -> SetNodeNameReturnsBuilder {
+                SetNodeNameReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetNodeNameReturnsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl SetNodeNameReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SetNodeNameReturns, String> {
+                Ok(SetNodeNameReturns {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetNodeNameParams {
+            type Response = SetNodeNameReturns;
+        }
+        #[doc = "Sets node value for a node with given id.\n[setNodeValue](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setNodeValue)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetNodeValueParams {
+            #[doc = "Id of the node to set value for."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "New node's value."]
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl SetNodeValueParams {
+            pub fn new(node_id: impl Into<NodeId>, value: impl Into<String>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl SetNodeValueParams {
+            pub fn builder() -> SetNodeValueParamsBuilder {
+                SetNodeValueParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetNodeValueParamsBuilder {
+            node_id: Option<NodeId>,
+            value: Option<String>,
+        }
+        impl SetNodeValueParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<SetNodeValueParams, String> {
+                Ok(SetNodeValueParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl SetNodeValueParams {
+            pub const IDENTIFIER: &'static str = "DOM.setNodeValue";
+        }
+        impl chromiumoxide_types::Method for SetNodeValueParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetNodeValueParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets node value for a node with given id.\n[setNodeValue](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setNodeValue)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetNodeValueReturns {}
+        impl chromiumoxide_types::Command for SetNodeValueParams {
+            type Response = SetNodeValueReturns;
+        }
+        #[doc = "Sets node HTML markup, returns new node id.\n[setOuterHTML](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setOuterHTML)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetOuterHtmlParams {
+            #[doc = "Id of the node to set markup for."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "Outer HTML markup to set."]
+            #[serde(rename = "outerHTML")]
+            pub outer_html: String,
+        }
+        impl SetOuterHtmlParams {
+            pub fn new(node_id: impl Into<NodeId>, outer_html: impl Into<String>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    outer_html: outer_html.into(),
+                }
+            }
+        }
+        impl SetOuterHtmlParams {
+            pub fn builder() -> SetOuterHtmlParamsBuilder {
+                SetOuterHtmlParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetOuterHtmlParamsBuilder {
+            node_id: Option<NodeId>,
+            outer_html: Option<String>,
+        }
+        impl SetOuterHtmlParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn outer_html(mut self, outer_html: impl Into<String>) -> Self {
+                self.outer_html = Some(outer_html.into());
+                self
+            }
+            pub fn build(self) -> Result<SetOuterHtmlParams, String> {
+                Ok(SetOuterHtmlParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    outer_html: self.outer_html.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(outer_html))
+                    })?,
+                })
+            }
+        }
+        impl SetOuterHtmlParams {
+            pub const IDENTIFIER: &'static str = "DOM.setOuterHTML";
+        }
+        impl chromiumoxide_types::Method for SetOuterHtmlParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetOuterHtmlParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets node HTML markup, returns new node id.\n[setOuterHTML](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-setOuterHTML)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetOuterHtmlReturns {}
+        impl chromiumoxide_types::Command for SetOuterHtmlParams {
+            type Response = SetOuterHtmlReturns;
+        }
+        #[doc = "Undoes the last performed action.\n[undo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-undo)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UndoParams {}
+        impl UndoParams {
+            pub const IDENTIFIER: &'static str = "DOM.undo";
+        }
+        impl chromiumoxide_types::Method for UndoParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for UndoParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Undoes the last performed action.\n[undo](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-undo)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UndoReturns {}
+        impl chromiumoxide_types::Command for UndoParams {
+            type Response = UndoReturns;
+        }
+        #[doc = "Returns iframe node that owns iframe with the given domain.\n[getFrameOwner](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getFrameOwner)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetFrameOwnerParams {
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+        }
+        impl GetFrameOwnerParams {
+            pub fn new(frame_id: impl Into<super::page::FrameId>) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                }
+            }
+        }
+        impl GetFrameOwnerParams {
+            pub fn builder() -> GetFrameOwnerParamsBuilder {
+                GetFrameOwnerParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetFrameOwnerParamsBuilder {
+            frame_id: Option<super::page::FrameId>,
+        }
+        impl GetFrameOwnerParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetFrameOwnerParams, String> {
+                Ok(GetFrameOwnerParams {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                })
+            }
+        }
+        impl GetFrameOwnerParams {
+            pub const IDENTIFIER: &'static str = "DOM.getFrameOwner";
+        }
+        impl chromiumoxide_types::Method for GetFrameOwnerParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetFrameOwnerParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns iframe node that owns iframe with the given domain.\n[getFrameOwner](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getFrameOwner)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetFrameOwnerReturns {
+            #[doc = "Resulting node."]
+            #[serde(rename = "backendNodeId")]
+            pub backend_node_id: BackendNodeId,
+            #[doc = "Id of the node at given coordinates, only when enabled and requested document."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+        }
+        impl GetFrameOwnerReturns {
+            pub fn new(backend_node_id: impl Into<BackendNodeId>) -> Self {
+                Self {
+                    backend_node_id: backend_node_id.into(),
+                    node_id: None,
+                }
+            }
+        }
+        impl GetFrameOwnerReturns {
+            pub fn builder() -> GetFrameOwnerReturnsBuilder {
+                GetFrameOwnerReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetFrameOwnerReturnsBuilder {
+            backend_node_id: Option<BackendNodeId>,
+            node_id: Option<NodeId>,
+        }
+        impl GetFrameOwnerReturnsBuilder {
+            pub fn backend_node_id(mut self, backend_node_id: impl Into<BackendNodeId>) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetFrameOwnerReturns, String> {
+                Ok(GetFrameOwnerReturns {
+                    backend_node_id: self.backend_node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(backend_node_id))
+                    })?,
+                    node_id: self.node_id,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetFrameOwnerParams {
+            type Response = GetFrameOwnerReturns;
+        }
+        #[doc = "Returns the query container of the given node based on container query\nconditions: containerName, physical and logical axes, and whether it queries\nscroll-state or anchored elements. If no axes are provided and\nqueriesScrollState is false, the style container is returned, which is the\ndirect parent or the closest element with a matching container-name.\n[getContainerForNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getContainerForNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetContainerForNodeParams {
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[serde(rename = "containerName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub container_name: Option<String>,
+            #[serde(rename = "physicalAxes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub physical_axes: Option<PhysicalAxes>,
+            #[serde(rename = "logicalAxes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub logical_axes: Option<LogicalAxes>,
+            #[serde(rename = "queriesScrollState")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub queries_scroll_state: Option<bool>,
+            #[serde(rename = "queriesAnchored")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub queries_anchored: Option<bool>,
+        }
+        impl GetContainerForNodeParams {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    container_name: None,
+                    physical_axes: None,
+                    logical_axes: None,
+                    queries_scroll_state: None,
+                    queries_anchored: None,
+                }
+            }
+        }
+        impl GetContainerForNodeParams {
+            pub fn builder() -> GetContainerForNodeParamsBuilder {
+                GetContainerForNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetContainerForNodeParamsBuilder {
+            node_id: Option<NodeId>,
+            container_name: Option<String>,
+            physical_axes: Option<PhysicalAxes>,
+            logical_axes: Option<LogicalAxes>,
+            queries_scroll_state: Option<bool>,
+            queries_anchored: Option<bool>,
+        }
+        impl GetContainerForNodeParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn container_name(mut self, container_name: impl Into<String>) -> Self {
+                self.container_name = Some(container_name.into());
+                self
+            }
+            pub fn physical_axes(mut self, physical_axes: impl Into<PhysicalAxes>) -> Self {
+                self.physical_axes = Some(physical_axes.into());
+                self
+            }
+            pub fn logical_axes(mut self, logical_axes: impl Into<LogicalAxes>) -> Self {
+                self.logical_axes = Some(logical_axes.into());
+                self
+            }
+            pub fn queries_scroll_state(mut self, queries_scroll_state: impl Into<bool>) -> Self {
+                self.queries_scroll_state = Some(queries_scroll_state.into());
+                self
+            }
+            pub fn queries_anchored(mut self, queries_anchored: impl Into<bool>) -> Self {
+                self.queries_anchored = Some(queries_anchored.into());
+                self
+            }
+            pub fn build(self) -> Result<GetContainerForNodeParams, String> {
+                Ok(GetContainerForNodeParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    container_name: self.container_name,
+                    physical_axes: self.physical_axes,
+                    logical_axes: self.logical_axes,
+                    queries_scroll_state: self.queries_scroll_state,
+                    queries_anchored: self.queries_anchored,
+                })
+            }
+        }
+        impl GetContainerForNodeParams {
+            pub const IDENTIFIER: &'static str = "DOM.getContainerForNode";
+        }
+        impl chromiumoxide_types::Method for GetContainerForNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetContainerForNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the query container of the given node based on container query\nconditions: containerName, physical and logical axes, and whether it queries\nscroll-state or anchored elements. If no axes are provided and\nqueriesScrollState is false, the style container is returned, which is the\ndirect parent or the closest element with a matching container-name.\n[getContainerForNode](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getContainerForNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetContainerForNodeReturns {
+            #[doc = "The container node for the given node, or null if not found."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<NodeId>,
+        }
+        impl GetContainerForNodeReturns {
+            pub fn builder() -> GetContainerForNodeReturnsBuilder {
+                GetContainerForNodeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetContainerForNodeReturnsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl GetContainerForNodeReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> GetContainerForNodeReturns {
+                GetContainerForNodeReturns {
+                    node_id: self.node_id,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for GetContainerForNodeParams {
+            type Response = GetContainerForNodeReturns;
+        }
+        #[doc = "Returns the descendants of a container query container that have\ncontainer queries against this container.\n[getQueryingDescendantsForContainer](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getQueryingDescendantsForContainer)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetQueryingDescendantsForContainerParams {
+            #[doc = "Id of the container node to find querying descendants from."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl GetQueryingDescendantsForContainerParams {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetQueryingDescendantsForContainerParams {
+            pub fn builder() -> GetQueryingDescendantsForContainerParamsBuilder {
+                GetQueryingDescendantsForContainerParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetQueryingDescendantsForContainerParamsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl GetQueryingDescendantsForContainerParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetQueryingDescendantsForContainerParams, String> {
+                Ok(GetQueryingDescendantsForContainerParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetQueryingDescendantsForContainerParams {
+            pub const IDENTIFIER: &'static str = "DOM.getQueryingDescendantsForContainer";
+        }
+        impl chromiumoxide_types::Method for GetQueryingDescendantsForContainerParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetQueryingDescendantsForContainerParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the descendants of a container query container that have\ncontainer queries against this container.\n[getQueryingDescendantsForContainer](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getQueryingDescendantsForContainer)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetQueryingDescendantsForContainerReturns {
+            #[doc = "Descendant nodes with container queries against the given container."]
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<NodeId>,
+        }
+        impl GetQueryingDescendantsForContainerReturns {
+            pub fn new(node_ids: Vec<NodeId>) -> Self {
+                Self { node_ids }
+            }
+        }
+        impl GetQueryingDescendantsForContainerReturns {
+            pub fn builder() -> GetQueryingDescendantsForContainerReturnsBuilder {
+                GetQueryingDescendantsForContainerReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetQueryingDescendantsForContainerReturnsBuilder {
+            node_ids: Option<Vec<NodeId>>,
+        }
+        impl GetQueryingDescendantsForContainerReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                v.push(node_id.into());
+                self
+            }
+            pub fn node_ids<I, S>(mut self, node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NodeId>,
+            {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                for val in node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetQueryingDescendantsForContainerReturns, String> {
+                Ok(GetQueryingDescendantsForContainerReturns {
+                    node_ids: self.node_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_ids))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetQueryingDescendantsForContainerParams {
+            type Response = GetQueryingDescendantsForContainerReturns;
+        }
+        #[doc = "Returns the target anchor element of the given anchor query according to\nhttps://www.w3.org/TR/css-anchor-position-1/#target.\n[getAnchorElement](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getAnchorElement)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAnchorElementParams {
+            #[doc = "Id of the positioned element from which to find the anchor."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "An optional anchor specifier, as defined in\nhttps://www.w3.org/TR/css-anchor-position-1/#anchor-specifier.\nIf not provided, it will return the implicit anchor element for\nthe given positioned element."]
+            #[serde(rename = "anchorSpecifier")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub anchor_specifier: Option<String>,
+        }
+        impl GetAnchorElementParams {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    anchor_specifier: None,
+                }
+            }
+        }
+        impl GetAnchorElementParams {
+            pub fn builder() -> GetAnchorElementParamsBuilder {
+                GetAnchorElementParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAnchorElementParamsBuilder {
+            node_id: Option<NodeId>,
+            anchor_specifier: Option<String>,
+        }
+        impl GetAnchorElementParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn anchor_specifier(mut self, anchor_specifier: impl Into<String>) -> Self {
+                self.anchor_specifier = Some(anchor_specifier.into());
+                self
+            }
+            pub fn build(self) -> Result<GetAnchorElementParams, String> {
+                Ok(GetAnchorElementParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    anchor_specifier: self.anchor_specifier,
+                })
+            }
+        }
+        impl GetAnchorElementParams {
+            pub const IDENTIFIER: &'static str = "DOM.getAnchorElement";
+        }
+        impl chromiumoxide_types::Method for GetAnchorElementParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetAnchorElementParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the target anchor element of the given anchor query according to\nhttps://www.w3.org/TR/css-anchor-position-1/#target.\n[getAnchorElement](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getAnchorElement)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAnchorElementReturns {
+            #[doc = "The anchor element of the given anchor query."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl GetAnchorElementReturns {
+            pub fn new(node_id: impl Into<NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetAnchorElementReturns {
+            pub fn builder() -> GetAnchorElementReturnsBuilder {
+                GetAnchorElementReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAnchorElementReturnsBuilder {
+            node_id: Option<NodeId>,
+        }
+        impl GetAnchorElementReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetAnchorElementReturns, String> {
+                Ok(GetAnchorElementReturns {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetAnchorElementParams {
+            type Response = GetAnchorElementReturns;
+        }
+        #[doc = "When enabling, this API force-opens the popover identified by nodeId\nand keeps it open until disabled.\n[forceShowPopover](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-forceShowPopover)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ForceShowPopoverParams {
+            #[doc = "Id of the popover HTMLElement"]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "If true, opens the popover and keeps it open. If false, closes the\npopover if it was previously force-opened."]
+            #[serde(rename = "enable")]
+            pub enable: bool,
+        }
+        impl ForceShowPopoverParams {
+            pub fn new(node_id: impl Into<NodeId>, enable: impl Into<bool>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    enable: enable.into(),
+                }
+            }
+        }
+        impl ForceShowPopoverParams {
+            pub fn builder() -> ForceShowPopoverParamsBuilder {
+                ForceShowPopoverParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ForceShowPopoverParamsBuilder {
+            node_id: Option<NodeId>,
+            enable: Option<bool>,
+        }
+        impl ForceShowPopoverParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn enable(mut self, enable: impl Into<bool>) -> Self {
+                self.enable = Some(enable.into());
+                self
+            }
+            pub fn build(self) -> Result<ForceShowPopoverParams, String> {
+                Ok(ForceShowPopoverParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    enable: self.enable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enable))
+                    })?,
+                })
+            }
+        }
+        impl ForceShowPopoverParams {
+            pub const IDENTIFIER: &'static str = "DOM.forceShowPopover";
+        }
+        impl chromiumoxide_types::Method for ForceShowPopoverParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ForceShowPopoverParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "When enabling, this API force-opens the popover identified by nodeId\nand keeps it open until disabled.\n[forceShowPopover](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-forceShowPopover)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ForceShowPopoverReturns {
+            #[doc = "List of popovers that were closed in order to respect popover stacking order."]
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<NodeId>,
+        }
+        impl ForceShowPopoverReturns {
+            pub fn new(node_ids: Vec<NodeId>) -> Self {
+                Self { node_ids }
+            }
+        }
+        impl ForceShowPopoverReturns {
+            pub fn builder() -> ForceShowPopoverReturnsBuilder {
+                ForceShowPopoverReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ForceShowPopoverReturnsBuilder {
+            node_ids: Option<Vec<NodeId>>,
+        }
+        impl ForceShowPopoverReturnsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<NodeId>) -> Self {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                v.push(node_id.into());
+                self
+            }
+            pub fn node_ids<I, S>(mut self, node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NodeId>,
+            {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                for val in node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ForceShowPopoverReturns, String> {
+                Ok(ForceShowPopoverReturns {
+                    node_ids: self.node_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_ids))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for ForceShowPopoverParams {
+            type Response = ForceShowPopoverReturns;
+        }
+        #[doc = "Fired when `Element`'s attribute is modified.\n[attributeModified](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-attributeModified)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAttributeModified {
+            #[doc = "Id of the node that has changed."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "Attribute name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Attribute value."]
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl EventAttributeModified {
+            pub const IDENTIFIER: &'static str = "DOM.attributeModified";
+        }
+        impl chromiumoxide_types::Method for EventAttributeModified {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAttributeModified {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when `Element`'s adoptedStyleSheets are modified.\n[adoptedStyleSheetsModified](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-adoptedStyleSheetsModified)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAdoptedStyleSheetsModified {
+            #[doc = "Id of the node that has changed."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "New adoptedStyleSheets array."]
+            #[serde(rename = "adoptedStyleSheets")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub adopted_style_sheets: Vec<StyleSheetId>,
+        }
+        impl EventAdoptedStyleSheetsModified {
+            pub const IDENTIFIER: &'static str = "DOM.adoptedStyleSheetsModified";
+        }
+        impl chromiumoxide_types::Method for EventAdoptedStyleSheetsModified {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAdoptedStyleSheetsModified {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when `Element`'s attribute is removed.\n[attributeRemoved](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-attributeRemoved)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAttributeRemoved {
+            #[doc = "Id of the node that has changed."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "A ttribute name."]
+            #[serde(rename = "name")]
+            pub name: String,
+        }
+        impl EventAttributeRemoved {
+            pub const IDENTIFIER: &'static str = "DOM.attributeRemoved";
+        }
+        impl chromiumoxide_types::Method for EventAttributeRemoved {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAttributeRemoved {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Mirrors `DOMCharacterDataModified` event.\n[characterDataModified](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-characterDataModified)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventCharacterDataModified {
+            #[doc = "Id of the node that has changed."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "New text value."]
+            #[serde(rename = "characterData")]
+            pub character_data: String,
+        }
+        impl EventCharacterDataModified {
+            pub const IDENTIFIER: &'static str = "DOM.characterDataModified";
+        }
+        impl chromiumoxide_types::Method for EventCharacterDataModified {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventCharacterDataModified {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when `Container`'s child node count has changed.\n[childNodeCountUpdated](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-childNodeCountUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventChildNodeCountUpdated {
+            #[doc = "Id of the node that has changed."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+            #[doc = "New node count."]
+            #[serde(rename = "childNodeCount")]
+            pub child_node_count: i64,
+        }
+        impl EventChildNodeCountUpdated {
+            pub const IDENTIFIER: &'static str = "DOM.childNodeCountUpdated";
+        }
+        impl chromiumoxide_types::Method for EventChildNodeCountUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventChildNodeCountUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Mirrors `DOMNodeInserted` event.\n[childNodeInserted](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-childNodeInserted)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventChildNodeInserted {
+            #[doc = "Id of the node that has changed."]
+            #[serde(rename = "parentNodeId")]
+            pub parent_node_id: NodeId,
+            #[doc = "Id of the previous sibling."]
+            #[serde(rename = "previousNodeId")]
+            pub previous_node_id: NodeId,
+            #[doc = "Inserted node data."]
+            #[serde(rename = "node")]
+            pub node: Node,
+        }
+        impl EventChildNodeInserted {
+            pub const IDENTIFIER: &'static str = "DOM.childNodeInserted";
+        }
+        impl chromiumoxide_types::Method for EventChildNodeInserted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventChildNodeInserted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Mirrors `DOMNodeRemoved` event.\n[childNodeRemoved](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-childNodeRemoved)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventChildNodeRemoved {
+            #[doc = "Parent id."]
+            #[serde(rename = "parentNodeId")]
+            pub parent_node_id: NodeId,
+            #[doc = "Id of the node that has been removed."]
+            #[serde(rename = "nodeId")]
+            pub node_id: NodeId,
+        }
+        impl EventChildNodeRemoved {
+            pub const IDENTIFIER: &'static str = "DOM.childNodeRemoved";
+        }
+        impl chromiumoxide_types::Method for EventChildNodeRemoved {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventChildNodeRemoved {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Called when distribution is changed.\n[distributedNodesUpdated](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-distributedNodesUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDistributedNodesUpdated {
+            #[doc = "Insertion point where distributed nodes were updated."]
+            #[serde(rename = "insertionPointId")]
+            pub insertion_point_id: NodeId,
+            #[doc = "Distributed nodes for given insertion point."]
+            #[serde(rename = "distributedNodes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub distributed_nodes: Vec<BackendNode>,
+        }
+        impl EventDistributedNodesUpdated {
+            pub const IDENTIFIER: &'static str = "DOM.distributedNodesUpdated";
+        }
+        impl chromiumoxide_types::Method for EventDistributedNodesUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDistributedNodesUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when `Document` has been totally updated. Node ids are no longer valid.\n[documentUpdated](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-documentUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventDocumentUpdated {}
+        impl EventDocumentUpdated {
+            pub const IDENTIFIER: &'static str = "DOM.documentUpdated";
+        }
+        impl chromiumoxide_types::Method for EventDocumentUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDocumentUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when `Element`'s inline style is modified via a CSS property modification.\n[inlineStyleInvalidated](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-inlineStyleInvalidated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventInlineStyleInvalidated {
+            #[doc = "Ids of the nodes for which the inline styles have been invalidated."]
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<NodeId>,
+        }
+        impl EventInlineStyleInvalidated {
+            pub const IDENTIFIER: &'static str = "DOM.inlineStyleInvalidated";
+        }
+        impl chromiumoxide_types::Method for EventInlineStyleInvalidated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventInlineStyleInvalidated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Called when a pseudo element is added to an element.\n[pseudoElementAdded](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-pseudoElementAdded)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPseudoElementAdded {
+            #[doc = "Pseudo element's parent element id."]
+            #[serde(rename = "parentId")]
+            pub parent_id: NodeId,
+            #[doc = "The added pseudo element."]
+            #[serde(rename = "pseudoElement")]
+            pub pseudo_element: Node,
+        }
+        impl EventPseudoElementAdded {
+            pub const IDENTIFIER: &'static str = "DOM.pseudoElementAdded";
+        }
+        impl chromiumoxide_types::Method for EventPseudoElementAdded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPseudoElementAdded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Called when top layer elements are changed.\n[topLayerElementsUpdated](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-topLayerElementsUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventTopLayerElementsUpdated {}
+        impl EventTopLayerElementsUpdated {
+            pub const IDENTIFIER: &'static str = "DOM.topLayerElementsUpdated";
+        }
+        impl chromiumoxide_types::Method for EventTopLayerElementsUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventTopLayerElementsUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a node's scrollability state changes.\n[scrollableFlagUpdated](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-scrollableFlagUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventScrollableFlagUpdated {
+            #[doc = "The id of the node."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+            #[doc = "If the node is scrollable."]
+            #[serde(rename = "isScrollable")]
+            pub is_scrollable: bool,
+        }
+        impl EventScrollableFlagUpdated {
+            pub const IDENTIFIER: &'static str = "DOM.scrollableFlagUpdated";
+        }
+        impl chromiumoxide_types::Method for EventScrollableFlagUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventScrollableFlagUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a node's starting styles changes.\n[affectedByStartingStylesFlagUpdated](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-affectedByStartingStylesFlagUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAffectedByStartingStylesFlagUpdated {
+            #[doc = "The id of the node."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+            #[doc = "If the node has starting styles."]
+            #[serde(rename = "affectedByStartingStyles")]
+            pub affected_by_starting_styles: bool,
+        }
+        impl EventAffectedByStartingStylesFlagUpdated {
+            pub const IDENTIFIER: &'static str = "DOM.affectedByStartingStylesFlagUpdated";
+        }
+        impl chromiumoxide_types::Method for EventAffectedByStartingStylesFlagUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAffectedByStartingStylesFlagUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Called when a pseudo element is removed from an element.\n[pseudoElementRemoved](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-pseudoElementRemoved)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPseudoElementRemoved {
+            #[doc = "Pseudo element's parent element id."]
+            #[serde(rename = "parentId")]
+            pub parent_id: NodeId,
+            #[doc = "The removed pseudo element id."]
+            #[serde(rename = "pseudoElementId")]
+            pub pseudo_element_id: NodeId,
+        }
+        impl EventPseudoElementRemoved {
+            pub const IDENTIFIER: &'static str = "DOM.pseudoElementRemoved";
+        }
+        impl chromiumoxide_types::Method for EventPseudoElementRemoved {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPseudoElementRemoved {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when backend wants to provide client with the missing DOM structure. This happens upon\nmost of the calls requesting node ids.\n[setChildNodes](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-setChildNodes)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventSetChildNodes {
+            #[doc = "Parent node id to populate with children."]
+            #[serde(rename = "parentId")]
+            pub parent_id: NodeId,
+            #[doc = "Child nodes array."]
+            #[serde(rename = "nodes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub nodes: Vec<Node>,
+        }
+        impl EventSetChildNodes {
+            pub const IDENTIFIER: &'static str = "DOM.setChildNodes";
+        }
+        impl chromiumoxide_types::Method for EventSetChildNodes {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventSetChildNodes {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Called when shadow root is popped from the element.\n[shadowRootPopped](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-shadowRootPopped)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventShadowRootPopped {
+            #[doc = "Host element id."]
+            #[serde(rename = "hostId")]
+            pub host_id: NodeId,
+            #[doc = "Shadow root id."]
+            #[serde(rename = "rootId")]
+            pub root_id: NodeId,
+        }
+        impl EventShadowRootPopped {
+            pub const IDENTIFIER: &'static str = "DOM.shadowRootPopped";
+        }
+        impl chromiumoxide_types::Method for EventShadowRootPopped {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventShadowRootPopped {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Called when shadow root is pushed into the element.\n[shadowRootPushed](https://chromedevtools.github.io/devtools-protocol/tot/DOM/#event-shadowRootPushed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventShadowRootPushed {
+            #[doc = "Host element id."]
+            #[serde(rename = "hostId")]
+            pub host_id: NodeId,
+            #[doc = "Shadow root."]
+            #[serde(rename = "root")]
+            pub root: Node,
+        }
+        impl EventShadowRootPushed {
+            pub const IDENTIFIER: &'static str = "DOM.shadowRootPushed";
+        }
+        impl chromiumoxide_types::Method for EventShadowRootPushed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventShadowRootPushed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "DOM debugging allows setting breakpoints on particular DOM operations and events. JavaScript\nexecution will stop on these operations as if there was a regular breakpoint set."]
+    pub mod dom_debugger {
+        use serde::{Deserialize, Serialize};
+        #[doc = "DOM breakpoint type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DomBreakpointType {
+            #[serde(rename = "subtree-modified")]
+            SubtreeModified,
+            #[serde(rename = "attribute-modified")]
+            AttributeModified,
+            #[serde(rename = "node-removed")]
+            NodeRemoved,
+        }
+        impl AsRef<str> for DomBreakpointType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DomBreakpointType::SubtreeModified => "subtree-modified",
+                    DomBreakpointType::AttributeModified => "attribute-modified",
+                    DomBreakpointType::NodeRemoved => "node-removed",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DomBreakpointType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "subtree-modified" | "SubtreeModified" => {
+                        Ok(DomBreakpointType::SubtreeModified)
+                    }
+                    "attribute-modified" | "AttributeModified" => {
+                        Ok(DomBreakpointType::AttributeModified)
+                    }
+                    "node-removed" | "NodeRemoved" => Ok(DomBreakpointType::NodeRemoved),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "CSP Violation type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CspViolationType {
+            #[serde(rename = "trustedtype-sink-violation")]
+            TrustedtypeSinkViolation,
+            #[serde(rename = "trustedtype-policy-violation")]
+            TrustedtypePolicyViolation,
+        }
+        impl AsRef<str> for CspViolationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CspViolationType::TrustedtypeSinkViolation => "trustedtype-sink-violation",
+                    CspViolationType::TrustedtypePolicyViolation => "trustedtype-policy-violation",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CspViolationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "trustedtype-sink-violation" | "TrustedtypeSinkViolation" => {
+                        Ok(CspViolationType::TrustedtypeSinkViolation)
+                    }
+                    "trustedtype-policy-violation" | "TrustedtypePolicyViolation" => {
+                        Ok(CspViolationType::TrustedtypePolicyViolation)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Object event listener.\n[EventListener](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#type-EventListener)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventListener {
+            #[doc = "`EventListener`'s type."]
+            #[serde(rename = "type")]
+            pub r#type: String,
+            #[doc = "`EventListener`'s useCapture."]
+            #[serde(rename = "useCapture")]
+            pub use_capture: bool,
+            #[doc = "`EventListener`'s passive flag."]
+            #[serde(rename = "passive")]
+            pub passive: bool,
+            #[doc = "`EventListener`'s once flag."]
+            #[serde(rename = "once")]
+            pub once: bool,
+            #[doc = "Script id of the handler code."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::super::js_protocol::runtime::ScriptId,
+            #[doc = "Line number in the script (0-based)."]
+            #[serde(rename = "lineNumber")]
+            pub line_number: i64,
+            #[doc = "Column number in the script (0-based)."]
+            #[serde(rename = "columnNumber")]
+            pub column_number: i64,
+            #[doc = "Event handler function value."]
+            #[serde(rename = "handler")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub handler: Option<super::super::js_protocol::runtime::RemoteObject>,
+            #[doc = "Event original handler function value."]
+            #[serde(rename = "originalHandler")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub original_handler: Option<super::super::js_protocol::runtime::RemoteObject>,
+            #[doc = "Node the listener is added to (if any)."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+        }
+        impl EventListener {
+            pub fn builder() -> EventListenerBuilder {
+                EventListenerBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EventListenerBuilder {
+            r#type: Option<String>,
+            use_capture: Option<bool>,
+            passive: Option<bool>,
+            once: Option<bool>,
+            script_id: Option<super::super::js_protocol::runtime::ScriptId>,
+            line_number: Option<i64>,
+            column_number: Option<i64>,
+            handler: Option<super::super::js_protocol::runtime::RemoteObject>,
+            original_handler: Option<super::super::js_protocol::runtime::RemoteObject>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+        }
+        impl EventListenerBuilder {
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn use_capture(mut self, use_capture: impl Into<bool>) -> Self {
+                self.use_capture = Some(use_capture.into());
+                self
+            }
+            pub fn passive(mut self, passive: impl Into<bool>) -> Self {
+                self.passive = Some(passive.into());
+                self
+            }
+            pub fn once(mut self, once: impl Into<bool>) -> Self {
+                self.once = Some(once.into());
+                self
+            }
+            pub fn script_id(
+                mut self,
+                script_id: impl Into<super::super::js_protocol::runtime::ScriptId>,
+            ) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<i64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn handler(
+                mut self,
+                handler: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                self.handler = Some(handler.into());
+                self
+            }
+            pub fn original_handler(
+                mut self,
+                original_handler: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                self.original_handler = Some(original_handler.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<EventListener, String> {
+                Ok(EventListener {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    use_capture: self.use_capture.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(use_capture))
+                    })?,
+                    passive: self.passive.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(passive))
+                    })?,
+                    once: self.once.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(once))
+                    })?,
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    column_number: self.column_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(column_number))
+                    })?,
+                    handler: self.handler,
+                    original_handler: self.original_handler,
+                    backend_node_id: self.backend_node_id,
+                })
+            }
+        }
+        impl EventListener {
+            pub const IDENTIFIER: &'static str = "DOMDebugger.EventListener";
+        }
+        #[doc = "Returns event listeners of the given object.\n[getEventListeners](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-getEventListeners)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetEventListenersParams {
+            #[doc = "Identifier of the object to return listeners for."]
+            #[serde(rename = "objectId")]
+            pub object_id: super::super::js_protocol::runtime::RemoteObjectId,
+            #[doc = "The maximum depth at which Node children should be retrieved, defaults to 1. Use -1 for the\nentire subtree or provide an integer larger than 0."]
+            #[serde(rename = "depth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub depth: Option<i64>,
+            #[doc = "Whether or not iframes and shadow roots should be traversed when returning the subtree\n(default is false). Reports listeners for all contexts if pierce is enabled."]
+            #[serde(rename = "pierce")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pierce: Option<bool>,
+        }
+        impl GetEventListenersParams {
+            pub fn new(
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                Self {
+                    object_id: object_id.into(),
+                    depth: None,
+                    pierce: None,
+                }
+            }
+        }
+        impl GetEventListenersParams {
+            pub fn builder() -> GetEventListenersParamsBuilder {
+                GetEventListenersParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetEventListenersParamsBuilder {
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            depth: Option<i64>,
+            pierce: Option<bool>,
+        }
+        impl GetEventListenersParamsBuilder {
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn depth(mut self, depth: impl Into<i64>) -> Self {
+                self.depth = Some(depth.into());
+                self
+            }
+            pub fn pierce(mut self, pierce: impl Into<bool>) -> Self {
+                self.pierce = Some(pierce.into());
+                self
+            }
+            pub fn build(self) -> Result<GetEventListenersParams, String> {
+                Ok(GetEventListenersParams {
+                    object_id: self.object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_id))
+                    })?,
+                    depth: self.depth,
+                    pierce: self.pierce,
+                })
+            }
+        }
+        impl GetEventListenersParams {
+            pub const IDENTIFIER: &'static str = "DOMDebugger.getEventListeners";
+        }
+        impl chromiumoxide_types::Method for GetEventListenersParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetEventListenersParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns event listeners of the given object.\n[getEventListeners](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-getEventListeners)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetEventListenersReturns {
+            #[doc = "Array of relevant listeners."]
+            #[serde(rename = "listeners")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub listeners: Vec<EventListener>,
+        }
+        impl GetEventListenersReturns {
+            pub fn new(listeners: Vec<EventListener>) -> Self {
+                Self { listeners }
+            }
+        }
+        impl GetEventListenersReturns {
+            pub fn builder() -> GetEventListenersReturnsBuilder {
+                GetEventListenersReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetEventListenersReturnsBuilder {
+            listeners: Option<Vec<EventListener>>,
+        }
+        impl GetEventListenersReturnsBuilder {
+            pub fn listener(mut self, listener: impl Into<EventListener>) -> Self {
+                let v = self.listeners.get_or_insert(Vec::new());
+                v.push(listener.into());
+                self
+            }
+            pub fn listeners<I, S>(mut self, listeners: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<EventListener>,
+            {
+                let v = self.listeners.get_or_insert(Vec::new());
+                for val in listeners {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetEventListenersReturns, String> {
+                Ok(GetEventListenersReturns {
+                    listeners: self.listeners.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(listeners))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetEventListenersParams {
+            type Response = GetEventListenersReturns;
+        }
+        #[doc = "Removes DOM breakpoint that was set using `setDOMBreakpoint`.\n[removeDOMBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-removeDOMBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveDomBreakpointParams {
+            #[doc = "Identifier of the node to remove breakpoint from."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+            #[doc = "Type of the breakpoint to remove."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DomBreakpointType,
+        }
+        impl RemoveDomBreakpointParams {
+            pub fn new(
+                node_id: impl Into<super::dom::NodeId>,
+                r#type: impl Into<DomBreakpointType>,
+            ) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    r#type: r#type.into(),
+                }
+            }
+        }
+        impl RemoveDomBreakpointParams {
+            pub fn builder() -> RemoveDomBreakpointParamsBuilder {
+                RemoveDomBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveDomBreakpointParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+            r#type: Option<DomBreakpointType>,
+        }
+        impl RemoveDomBreakpointParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<DomBreakpointType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveDomBreakpointParams, String> {
+                Ok(RemoveDomBreakpointParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                })
+            }
+        }
+        impl RemoveDomBreakpointParams {
+            pub const IDENTIFIER: &'static str = "DOMDebugger.removeDOMBreakpoint";
+        }
+        impl chromiumoxide_types::Method for RemoveDomBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveDomBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes DOM breakpoint that was set using `setDOMBreakpoint`.\n[removeDOMBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-removeDOMBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveDomBreakpointReturns {}
+        impl chromiumoxide_types::Command for RemoveDomBreakpointParams {
+            type Response = RemoveDomBreakpointReturns;
+        }
+        #[doc = "Removes breakpoint on particular DOM event.\n[removeEventListenerBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-removeEventListenerBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveEventListenerBreakpointParams {
+            #[doc = "Event name."]
+            #[serde(rename = "eventName")]
+            pub event_name: String,
+            #[doc = "EventTarget interface name."]
+            #[serde(rename = "targetName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub target_name: Option<String>,
+        }
+        impl RemoveEventListenerBreakpointParams {
+            pub fn new(event_name: impl Into<String>) -> Self {
+                Self {
+                    event_name: event_name.into(),
+                    target_name: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for RemoveEventListenerBreakpointParams {
+            fn from(url: T) -> Self {
+                RemoveEventListenerBreakpointParams::new(url)
+            }
+        }
+        impl RemoveEventListenerBreakpointParams {
+            pub fn builder() -> RemoveEventListenerBreakpointParamsBuilder {
+                RemoveEventListenerBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveEventListenerBreakpointParamsBuilder {
+            event_name: Option<String>,
+            target_name: Option<String>,
+        }
+        impl RemoveEventListenerBreakpointParamsBuilder {
+            pub fn event_name(mut self, event_name: impl Into<String>) -> Self {
+                self.event_name = Some(event_name.into());
+                self
+            }
+            pub fn target_name(mut self, target_name: impl Into<String>) -> Self {
+                self.target_name = Some(target_name.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveEventListenerBreakpointParams, String> {
+                Ok(RemoveEventListenerBreakpointParams {
+                    event_name: self.event_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(event_name))
+                    })?,
+                    target_name: self.target_name,
+                })
+            }
+        }
+        impl RemoveEventListenerBreakpointParams {
+            pub const IDENTIFIER: &'static str = "DOMDebugger.removeEventListenerBreakpoint";
+        }
+        impl chromiumoxide_types::Method for RemoveEventListenerBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveEventListenerBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes breakpoint on particular DOM event.\n[removeEventListenerBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-removeEventListenerBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveEventListenerBreakpointReturns {}
+        impl chromiumoxide_types::Command for RemoveEventListenerBreakpointParams {
+            type Response = RemoveEventListenerBreakpointReturns;
+        }
+        #[doc = "Removes breakpoint from XMLHttpRequest.\n[removeXHRBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-removeXHRBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveXhrBreakpointParams {
+            #[doc = "Resource URL substring."]
+            #[serde(rename = "url")]
+            pub url: String,
+        }
+        impl RemoveXhrBreakpointParams {
+            pub fn new(url: impl Into<String>) -> Self {
+                Self { url: url.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for RemoveXhrBreakpointParams {
+            fn from(url: T) -> Self {
+                RemoveXhrBreakpointParams::new(url)
+            }
+        }
+        impl RemoveXhrBreakpointParams {
+            pub fn builder() -> RemoveXhrBreakpointParamsBuilder {
+                RemoveXhrBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveXhrBreakpointParamsBuilder {
+            url: Option<String>,
+        }
+        impl RemoveXhrBreakpointParamsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveXhrBreakpointParams, String> {
+                Ok(RemoveXhrBreakpointParams {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                })
+            }
+        }
+        impl RemoveXhrBreakpointParams {
+            pub const IDENTIFIER: &'static str = "DOMDebugger.removeXHRBreakpoint";
+        }
+        impl chromiumoxide_types::Method for RemoveXhrBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveXhrBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes breakpoint from XMLHttpRequest.\n[removeXHRBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-removeXHRBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveXhrBreakpointReturns {}
+        impl chromiumoxide_types::Command for RemoveXhrBreakpointParams {
+            type Response = RemoveXhrBreakpointReturns;
+        }
+        #[doc = "Sets breakpoint on particular CSP violations.\n[setBreakOnCSPViolation](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-setBreakOnCSPViolation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBreakOnCspViolationParams {
+            #[doc = "CSP Violations to stop upon."]
+            #[serde(rename = "violationTypes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub violation_types: Vec<CspViolationType>,
+        }
+        impl SetBreakOnCspViolationParams {
+            pub fn new(violation_types: Vec<CspViolationType>) -> Self {
+                Self { violation_types }
+            }
+        }
+        impl SetBreakOnCspViolationParams {
+            pub fn builder() -> SetBreakOnCspViolationParamsBuilder {
+                SetBreakOnCspViolationParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBreakOnCspViolationParamsBuilder {
+            violation_types: Option<Vec<CspViolationType>>,
+        }
+        impl SetBreakOnCspViolationParamsBuilder {
+            pub fn violation_type(mut self, violation_type: impl Into<CspViolationType>) -> Self {
+                let v = self.violation_types.get_or_insert(Vec::new());
+                v.push(violation_type.into());
+                self
+            }
+            pub fn violation_types<I, S>(mut self, violation_types: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CspViolationType>,
+            {
+                let v = self.violation_types.get_or_insert(Vec::new());
+                for val in violation_types {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetBreakOnCspViolationParams, String> {
+                Ok(SetBreakOnCspViolationParams {
+                    violation_types: self.violation_types.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(violation_types))
+                    })?,
+                })
+            }
+        }
+        impl SetBreakOnCspViolationParams {
+            pub const IDENTIFIER: &'static str = "DOMDebugger.setBreakOnCSPViolation";
+        }
+        impl chromiumoxide_types::Method for SetBreakOnCspViolationParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBreakOnCspViolationParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets breakpoint on particular CSP violations.\n[setBreakOnCSPViolation](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-setBreakOnCSPViolation)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetBreakOnCspViolationReturns {}
+        impl chromiumoxide_types::Command for SetBreakOnCspViolationParams {
+            type Response = SetBreakOnCspViolationReturns;
+        }
+        #[doc = "Sets breakpoint on particular operation with DOM.\n[setDOMBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-setDOMBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDomBreakpointParams {
+            #[doc = "Identifier of the node to set breakpoint on."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+            #[doc = "Type of the operation to stop upon."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DomBreakpointType,
+        }
+        impl SetDomBreakpointParams {
+            pub fn new(
+                node_id: impl Into<super::dom::NodeId>,
+                r#type: impl Into<DomBreakpointType>,
+            ) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    r#type: r#type.into(),
+                }
+            }
+        }
+        impl SetDomBreakpointParams {
+            pub fn builder() -> SetDomBreakpointParamsBuilder {
+                SetDomBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDomBreakpointParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+            r#type: Option<DomBreakpointType>,
+        }
+        impl SetDomBreakpointParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<DomBreakpointType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<SetDomBreakpointParams, String> {
+                Ok(SetDomBreakpointParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                })
+            }
+        }
+        impl SetDomBreakpointParams {
+            pub const IDENTIFIER: &'static str = "DOMDebugger.setDOMBreakpoint";
+        }
+        impl chromiumoxide_types::Method for SetDomBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDomBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets breakpoint on particular operation with DOM.\n[setDOMBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-setDOMBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDomBreakpointReturns {}
+        impl chromiumoxide_types::Command for SetDomBreakpointParams {
+            type Response = SetDomBreakpointReturns;
+        }
+        #[doc = "Sets breakpoint on particular DOM event.\n[setEventListenerBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-setEventListenerBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetEventListenerBreakpointParams {
+            #[doc = "DOM Event name to stop on (any DOM event will do)."]
+            #[serde(rename = "eventName")]
+            pub event_name: String,
+            #[doc = "EventTarget interface name to stop on. If equal to `\"*\"` or not provided, will stop on any\nEventTarget."]
+            #[serde(rename = "targetName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub target_name: Option<String>,
+        }
+        impl SetEventListenerBreakpointParams {
+            pub fn new(event_name: impl Into<String>) -> Self {
+                Self {
+                    event_name: event_name.into(),
+                    target_name: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for SetEventListenerBreakpointParams {
+            fn from(url: T) -> Self {
+                SetEventListenerBreakpointParams::new(url)
+            }
+        }
+        impl SetEventListenerBreakpointParams {
+            pub fn builder() -> SetEventListenerBreakpointParamsBuilder {
+                SetEventListenerBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetEventListenerBreakpointParamsBuilder {
+            event_name: Option<String>,
+            target_name: Option<String>,
+        }
+        impl SetEventListenerBreakpointParamsBuilder {
+            pub fn event_name(mut self, event_name: impl Into<String>) -> Self {
+                self.event_name = Some(event_name.into());
+                self
+            }
+            pub fn target_name(mut self, target_name: impl Into<String>) -> Self {
+                self.target_name = Some(target_name.into());
+                self
+            }
+            pub fn build(self) -> Result<SetEventListenerBreakpointParams, String> {
+                Ok(SetEventListenerBreakpointParams {
+                    event_name: self.event_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(event_name))
+                    })?,
+                    target_name: self.target_name,
+                })
+            }
+        }
+        impl SetEventListenerBreakpointParams {
+            pub const IDENTIFIER: &'static str = "DOMDebugger.setEventListenerBreakpoint";
+        }
+        impl chromiumoxide_types::Method for SetEventListenerBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetEventListenerBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets breakpoint on particular DOM event.\n[setEventListenerBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-setEventListenerBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetEventListenerBreakpointReturns {}
+        impl chromiumoxide_types::Command for SetEventListenerBreakpointParams {
+            type Response = SetEventListenerBreakpointReturns;
+        }
+        #[doc = "Sets breakpoint on XMLHttpRequest.\n[setXHRBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-setXHRBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetXhrBreakpointParams {
+            #[doc = "Resource URL substring. All XHRs having this substring in the URL will get stopped upon."]
+            #[serde(rename = "url")]
+            pub url: String,
+        }
+        impl SetXhrBreakpointParams {
+            pub fn new(url: impl Into<String>) -> Self {
+                Self { url: url.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for SetXhrBreakpointParams {
+            fn from(url: T) -> Self {
+                SetXhrBreakpointParams::new(url)
+            }
+        }
+        impl SetXhrBreakpointParams {
+            pub fn builder() -> SetXhrBreakpointParamsBuilder {
+                SetXhrBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetXhrBreakpointParamsBuilder {
+            url: Option<String>,
+        }
+        impl SetXhrBreakpointParamsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn build(self) -> Result<SetXhrBreakpointParams, String> {
+                Ok(SetXhrBreakpointParams {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                })
+            }
+        }
+        impl SetXhrBreakpointParams {
+            pub const IDENTIFIER: &'static str = "DOMDebugger.setXHRBreakpoint";
+        }
+        impl chromiumoxide_types::Method for SetXhrBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetXhrBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets breakpoint on XMLHttpRequest.\n[setXHRBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/DOMDebugger/#method-setXHRBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetXhrBreakpointReturns {}
+        impl chromiumoxide_types::Command for SetXhrBreakpointParams {
+            type Response = SetXhrBreakpointReturns;
+        }
+    }
+    #[doc = "This domain facilitates obtaining document snapshots with DOM, layout, and style information."]
+    pub mod dom_snapshot {
+        use serde::{Deserialize, Serialize};
+        #[doc = "A Node in the DOM tree.\n[DOMNode](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-DOMNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DomNode {
+            #[doc = "`Node`'s nodeType."]
+            #[serde(rename = "nodeType")]
+            pub node_type: i64,
+            #[doc = "`Node`'s nodeName."]
+            #[serde(rename = "nodeName")]
+            pub node_name: String,
+            #[doc = "`Node`'s nodeValue."]
+            #[serde(rename = "nodeValue")]
+            pub node_value: String,
+            #[doc = "Only set for textarea elements, contains the text value."]
+            #[serde(rename = "textValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub text_value: Option<String>,
+            #[doc = "Only set for input elements, contains the input's associated text value."]
+            #[serde(rename = "inputValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub input_value: Option<String>,
+            #[doc = "Only set for radio and checkbox input elements, indicates if the element has been checked"]
+            #[serde(rename = "inputChecked")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub input_checked: Option<bool>,
+            #[doc = "Only set for option elements, indicates if the element has been selected"]
+            #[serde(rename = "optionSelected")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub option_selected: Option<bool>,
+            #[doc = "`Node`'s id, corresponds to DOM.Node.backendNodeId."]
+            #[serde(rename = "backendNodeId")]
+            pub backend_node_id: super::dom::BackendNodeId,
+            #[doc = "The indexes of the node's child nodes in the `domNodes` array returned by `getSnapshot`, if\nany."]
+            #[serde(rename = "childNodeIndexes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub child_node_indexes: Option<Vec<i64>>,
+            #[doc = "Attributes of an `Element` node."]
+            #[serde(rename = "attributes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub attributes: Option<Vec<NameValue>>,
+            #[doc = "Indexes of pseudo elements associated with this node in the `domNodes` array returned by\n`getSnapshot`, if any."]
+            #[serde(rename = "pseudoElementIndexes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pseudo_element_indexes: Option<Vec<i64>>,
+            #[doc = "The index of the node's related layout tree node in the `layoutTreeNodes` array returned by\n`getSnapshot`, if any."]
+            #[serde(rename = "layoutNodeIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub layout_node_index: Option<i64>,
+            #[doc = "Document URL that `Document` or `FrameOwner` node points to."]
+            #[serde(rename = "documentURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub document_url: Option<String>,
+            #[doc = "Base URL that `Document` or `FrameOwner` node uses for URL completion."]
+            #[serde(rename = "baseURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub base_url: Option<String>,
+            #[doc = "Only set for documents, contains the document's content language."]
+            #[serde(rename = "contentLanguage")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub content_language: Option<String>,
+            #[doc = "Only set for documents, contains the document's character set encoding."]
+            #[serde(rename = "documentEncoding")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub document_encoding: Option<String>,
+            #[doc = "`DocumentType` node's publicId."]
+            #[serde(rename = "publicId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub public_id: Option<String>,
+            #[doc = "`DocumentType` node's systemId."]
+            #[serde(rename = "systemId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub system_id: Option<String>,
+            #[doc = "Frame ID for frame owner elements and also for the document node."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+            #[doc = "The index of a frame owner element's content document in the `domNodes` array returned by\n`getSnapshot`, if any."]
+            #[serde(rename = "contentDocumentIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub content_document_index: Option<i64>,
+            #[doc = "Type of a pseudo element node."]
+            #[serde(rename = "pseudoType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub pseudo_type: Option<super::dom::PseudoType>,
+            #[doc = "Shadow root type."]
+            #[serde(rename = "shadowRootType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub shadow_root_type: Option<super::dom::ShadowRootType>,
+            #[doc = "Whether this DOM node responds to mouse clicks. This includes nodes that have had click\nevent listeners attached via JavaScript as well as anchor tags that naturally navigate when\nclicked."]
+            #[serde(rename = "isClickable")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_clickable: Option<bool>,
+            #[doc = "Details of the node's event listeners, if any."]
+            #[serde(rename = "eventListeners")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub event_listeners: Option<Vec<super::dom_debugger::EventListener>>,
+            #[doc = "The selected url for nodes with a srcset attribute."]
+            #[serde(rename = "currentSourceURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub current_source_url: Option<String>,
+            #[doc = "The url of the script (if any) that generates this node."]
+            #[serde(rename = "originURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub origin_url: Option<String>,
+            #[doc = "Scroll offsets, set when this node is a Document."]
+            #[serde(rename = "scrollOffsetX")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scroll_offset_x: Option<f64>,
+            #[serde(rename = "scrollOffsetY")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scroll_offset_y: Option<f64>,
+        }
+        impl DomNode {
+            pub fn new(
+                node_type: impl Into<i64>,
+                node_name: impl Into<String>,
+                node_value: impl Into<String>,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                Self {
+                    node_type: node_type.into(),
+                    node_name: node_name.into(),
+                    node_value: node_value.into(),
+                    backend_node_id: backend_node_id.into(),
+                    text_value: None,
+                    input_value: None,
+                    input_checked: None,
+                    option_selected: None,
+                    child_node_indexes: None,
+                    attributes: None,
+                    pseudo_element_indexes: None,
+                    layout_node_index: None,
+                    document_url: None,
+                    base_url: None,
+                    content_language: None,
+                    document_encoding: None,
+                    public_id: None,
+                    system_id: None,
+                    frame_id: None,
+                    content_document_index: None,
+                    pseudo_type: None,
+                    shadow_root_type: None,
+                    is_clickable: None,
+                    event_listeners: None,
+                    current_source_url: None,
+                    origin_url: None,
+                    scroll_offset_x: None,
+                    scroll_offset_y: None,
+                }
+            }
+        }
+        impl DomNode {
+            pub fn builder() -> DomNodeBuilder {
+                DomNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DomNodeBuilder {
+            node_type: Option<i64>,
+            node_name: Option<String>,
+            node_value: Option<String>,
+            text_value: Option<String>,
+            input_value: Option<String>,
+            input_checked: Option<bool>,
+            option_selected: Option<bool>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+            child_node_indexes: Option<Vec<i64>>,
+            attributes: Option<Vec<NameValue>>,
+            pseudo_element_indexes: Option<Vec<i64>>,
+            layout_node_index: Option<i64>,
+            document_url: Option<String>,
+            base_url: Option<String>,
+            content_language: Option<String>,
+            document_encoding: Option<String>,
+            public_id: Option<String>,
+            system_id: Option<String>,
+            frame_id: Option<super::page::FrameId>,
+            content_document_index: Option<i64>,
+            pseudo_type: Option<super::dom::PseudoType>,
+            shadow_root_type: Option<super::dom::ShadowRootType>,
+            is_clickable: Option<bool>,
+            event_listeners: Option<Vec<super::dom_debugger::EventListener>>,
+            current_source_url: Option<String>,
+            origin_url: Option<String>,
+            scroll_offset_x: Option<f64>,
+            scroll_offset_y: Option<f64>,
+        }
+        impl DomNodeBuilder {
+            pub fn node_type(mut self, node_type: impl Into<i64>) -> Self {
+                self.node_type = Some(node_type.into());
+                self
+            }
+            pub fn node_name(mut self, node_name: impl Into<String>) -> Self {
+                self.node_name = Some(node_name.into());
+                self
+            }
+            pub fn node_value(mut self, node_value: impl Into<String>) -> Self {
+                self.node_value = Some(node_value.into());
+                self
+            }
+            pub fn text_value(mut self, text_value: impl Into<String>) -> Self {
+                self.text_value = Some(text_value.into());
+                self
+            }
+            pub fn input_value(mut self, input_value: impl Into<String>) -> Self {
+                self.input_value = Some(input_value.into());
+                self
+            }
+            pub fn input_checked(mut self, input_checked: impl Into<bool>) -> Self {
+                self.input_checked = Some(input_checked.into());
+                self
+            }
+            pub fn option_selected(mut self, option_selected: impl Into<bool>) -> Self {
+                self.option_selected = Some(option_selected.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn child_node_indexe(mut self, child_node_indexe: impl Into<i64>) -> Self {
+                let v = self.child_node_indexes.get_or_insert(Vec::new());
+                v.push(child_node_indexe.into());
+                self
+            }
+            pub fn child_node_indexes<I, S>(mut self, child_node_indexes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.child_node_indexes.get_or_insert(Vec::new());
+                for val in child_node_indexes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn attribute(mut self, attribute: impl Into<NameValue>) -> Self {
+                let v = self.attributes.get_or_insert(Vec::new());
+                v.push(attribute.into());
+                self
+            }
+            pub fn attributes<I, S>(mut self, attributes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NameValue>,
+            {
+                let v = self.attributes.get_or_insert(Vec::new());
+                for val in attributes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn pseudo_element_indexe(mut self, pseudo_element_indexe: impl Into<i64>) -> Self {
+                let v = self.pseudo_element_indexes.get_or_insert(Vec::new());
+                v.push(pseudo_element_indexe.into());
+                self
+            }
+            pub fn pseudo_element_indexes<I, S>(mut self, pseudo_element_indexes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.pseudo_element_indexes.get_or_insert(Vec::new());
+                for val in pseudo_element_indexes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn layout_node_index(mut self, layout_node_index: impl Into<i64>) -> Self {
+                self.layout_node_index = Some(layout_node_index.into());
+                self
+            }
+            pub fn document_url(mut self, document_url: impl Into<String>) -> Self {
+                self.document_url = Some(document_url.into());
+                self
+            }
+            pub fn base_url(mut self, base_url: impl Into<String>) -> Self {
+                self.base_url = Some(base_url.into());
+                self
+            }
+            pub fn content_language(mut self, content_language: impl Into<String>) -> Self {
+                self.content_language = Some(content_language.into());
+                self
+            }
+            pub fn document_encoding(mut self, document_encoding: impl Into<String>) -> Self {
+                self.document_encoding = Some(document_encoding.into());
+                self
+            }
+            pub fn public_id(mut self, public_id: impl Into<String>) -> Self {
+                self.public_id = Some(public_id.into());
+                self
+            }
+            pub fn system_id(mut self, system_id: impl Into<String>) -> Self {
+                self.system_id = Some(system_id.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn content_document_index(
+                mut self,
+                content_document_index: impl Into<i64>,
+            ) -> Self {
+                self.content_document_index = Some(content_document_index.into());
+                self
+            }
+            pub fn pseudo_type(mut self, pseudo_type: impl Into<super::dom::PseudoType>) -> Self {
+                self.pseudo_type = Some(pseudo_type.into());
+                self
+            }
+            pub fn shadow_root_type(
+                mut self,
+                shadow_root_type: impl Into<super::dom::ShadowRootType>,
+            ) -> Self {
+                self.shadow_root_type = Some(shadow_root_type.into());
+                self
+            }
+            pub fn is_clickable(mut self, is_clickable: impl Into<bool>) -> Self {
+                self.is_clickable = Some(is_clickable.into());
+                self
+            }
+            pub fn event_listener(
+                mut self,
+                event_listener: impl Into<super::dom_debugger::EventListener>,
+            ) -> Self {
+                let v = self.event_listeners.get_or_insert(Vec::new());
+                v.push(event_listener.into());
+                self
+            }
+            pub fn event_listeners<I, S>(mut self, event_listeners: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::dom_debugger::EventListener>,
+            {
+                let v = self.event_listeners.get_or_insert(Vec::new());
+                for val in event_listeners {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn current_source_url(mut self, current_source_url: impl Into<String>) -> Self {
+                self.current_source_url = Some(current_source_url.into());
+                self
+            }
+            pub fn origin_url(mut self, origin_url: impl Into<String>) -> Self {
+                self.origin_url = Some(origin_url.into());
+                self
+            }
+            pub fn scroll_offset_x(mut self, scroll_offset_x: impl Into<f64>) -> Self {
+                self.scroll_offset_x = Some(scroll_offset_x.into());
+                self
+            }
+            pub fn scroll_offset_y(mut self, scroll_offset_y: impl Into<f64>) -> Self {
+                self.scroll_offset_y = Some(scroll_offset_y.into());
+                self
+            }
+            pub fn build(self) -> Result<DomNode, String> {
+                Ok(DomNode {
+                    node_type: self.node_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_type))
+                    })?,
+                    node_name: self.node_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_name))
+                    })?,
+                    node_value: self.node_value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_value))
+                    })?,
+                    text_value: self.text_value,
+                    input_value: self.input_value,
+                    input_checked: self.input_checked,
+                    option_selected: self.option_selected,
+                    backend_node_id: self.backend_node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(backend_node_id))
+                    })?,
+                    child_node_indexes: self.child_node_indexes,
+                    attributes: self.attributes,
+                    pseudo_element_indexes: self.pseudo_element_indexes,
+                    layout_node_index: self.layout_node_index,
+                    document_url: self.document_url,
+                    base_url: self.base_url,
+                    content_language: self.content_language,
+                    document_encoding: self.document_encoding,
+                    public_id: self.public_id,
+                    system_id: self.system_id,
+                    frame_id: self.frame_id,
+                    content_document_index: self.content_document_index,
+                    pseudo_type: self.pseudo_type,
+                    shadow_root_type: self.shadow_root_type,
+                    is_clickable: self.is_clickable,
+                    event_listeners: self.event_listeners,
+                    current_source_url: self.current_source_url,
+                    origin_url: self.origin_url,
+                    scroll_offset_x: self.scroll_offset_x,
+                    scroll_offset_y: self.scroll_offset_y,
+                })
+            }
+        }
+        impl DomNode {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.DOMNode";
+        }
+        #[doc = "Details of post layout rendered text positions. The exact layout should not be regarded as\nstable and may change between versions.\n[InlineTextBox](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-InlineTextBox)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct InlineTextBox {
+            #[doc = "The bounding box in document coordinates. Note that scroll offset of the document is ignored."]
+            #[serde(rename = "boundingBox")]
+            pub bounding_box: super::dom::Rect,
+            #[doc = "The starting index in characters, for this post layout textbox substring. Characters that\nwould be represented as a surrogate pair in UTF-16 have length 2."]
+            #[serde(rename = "startCharacterIndex")]
+            pub start_character_index: i64,
+            #[doc = "The number of characters in this post layout textbox substring. Characters that would be\nrepresented as a surrogate pair in UTF-16 have length 2."]
+            #[serde(rename = "numCharacters")]
+            pub num_characters: i64,
+        }
+        impl InlineTextBox {
+            pub fn new(
+                bounding_box: impl Into<super::dom::Rect>,
+                start_character_index: impl Into<i64>,
+                num_characters: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    bounding_box: bounding_box.into(),
+                    start_character_index: start_character_index.into(),
+                    num_characters: num_characters.into(),
+                }
+            }
+        }
+        impl InlineTextBox {
+            pub fn builder() -> InlineTextBoxBuilder {
+                InlineTextBoxBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InlineTextBoxBuilder {
+            bounding_box: Option<super::dom::Rect>,
+            start_character_index: Option<i64>,
+            num_characters: Option<i64>,
+        }
+        impl InlineTextBoxBuilder {
+            pub fn bounding_box(mut self, bounding_box: impl Into<super::dom::Rect>) -> Self {
+                self.bounding_box = Some(bounding_box.into());
+                self
+            }
+            pub fn start_character_index(mut self, start_character_index: impl Into<i64>) -> Self {
+                self.start_character_index = Some(start_character_index.into());
+                self
+            }
+            pub fn num_characters(mut self, num_characters: impl Into<i64>) -> Self {
+                self.num_characters = Some(num_characters.into());
+                self
+            }
+            pub fn build(self) -> Result<InlineTextBox, String> {
+                Ok(InlineTextBox {
+                    bounding_box: self.bounding_box.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bounding_box))
+                    })?,
+                    start_character_index: self.start_character_index.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(start_character_index)
+                        )
+                    })?,
+                    num_characters: self.num_characters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(num_characters))
+                    })?,
+                })
+            }
+        }
+        impl InlineTextBox {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.InlineTextBox";
+        }
+        #[doc = "Details of an element in the DOM tree with a LayoutObject.\n[LayoutTreeNode](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-LayoutTreeNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LayoutTreeNode {
+            #[doc = "The index of the related DOM node in the `domNodes` array returned by `getSnapshot`."]
+            #[serde(rename = "domNodeIndex")]
+            pub dom_node_index: i64,
+            #[doc = "The bounding box in document coordinates. Note that scroll offset of the document is ignored."]
+            #[serde(rename = "boundingBox")]
+            pub bounding_box: super::dom::Rect,
+            #[doc = "Contents of the LayoutText, if any."]
+            #[serde(rename = "layoutText")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub layout_text: Option<String>,
+            #[doc = "The post-layout inline text nodes, if any."]
+            #[serde(rename = "inlineTextNodes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub inline_text_nodes: Option<Vec<InlineTextBox>>,
+            #[doc = "Index into the `computedStyles` array returned by `getSnapshot`."]
+            #[serde(rename = "styleIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub style_index: Option<i64>,
+            #[doc = "Global paint order index, which is determined by the stacking order of the nodes. Nodes\nthat are painted together will have the same index. Only provided if includePaintOrder in\ngetSnapshot was true."]
+            #[serde(rename = "paintOrder")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub paint_order: Option<i64>,
+            #[doc = "Set to true to indicate the element begins a new stacking context."]
+            #[serde(rename = "isStackingContext")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_stacking_context: Option<bool>,
+        }
+        impl LayoutTreeNode {
+            pub fn new(
+                dom_node_index: impl Into<i64>,
+                bounding_box: impl Into<super::dom::Rect>,
+            ) -> Self {
+                Self {
+                    dom_node_index: dom_node_index.into(),
+                    bounding_box: bounding_box.into(),
+                    layout_text: None,
+                    inline_text_nodes: None,
+                    style_index: None,
+                    paint_order: None,
+                    is_stacking_context: None,
+                }
+            }
+        }
+        impl LayoutTreeNode {
+            pub fn builder() -> LayoutTreeNodeBuilder {
+                LayoutTreeNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LayoutTreeNodeBuilder {
+            dom_node_index: Option<i64>,
+            bounding_box: Option<super::dom::Rect>,
+            layout_text: Option<String>,
+            inline_text_nodes: Option<Vec<InlineTextBox>>,
+            style_index: Option<i64>,
+            paint_order: Option<i64>,
+            is_stacking_context: Option<bool>,
+        }
+        impl LayoutTreeNodeBuilder {
+            pub fn dom_node_index(mut self, dom_node_index: impl Into<i64>) -> Self {
+                self.dom_node_index = Some(dom_node_index.into());
+                self
+            }
+            pub fn bounding_box(mut self, bounding_box: impl Into<super::dom::Rect>) -> Self {
+                self.bounding_box = Some(bounding_box.into());
+                self
+            }
+            pub fn layout_text(mut self, layout_text: impl Into<String>) -> Self {
+                self.layout_text = Some(layout_text.into());
+                self
+            }
+            pub fn inline_text_node(mut self, inline_text_node: impl Into<InlineTextBox>) -> Self {
+                let v = self.inline_text_nodes.get_or_insert(Vec::new());
+                v.push(inline_text_node.into());
+                self
+            }
+            pub fn inline_text_nodes<I, S>(mut self, inline_text_nodes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<InlineTextBox>,
+            {
+                let v = self.inline_text_nodes.get_or_insert(Vec::new());
+                for val in inline_text_nodes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn style_index(mut self, style_index: impl Into<i64>) -> Self {
+                self.style_index = Some(style_index.into());
+                self
+            }
+            pub fn paint_order(mut self, paint_order: impl Into<i64>) -> Self {
+                self.paint_order = Some(paint_order.into());
+                self
+            }
+            pub fn is_stacking_context(mut self, is_stacking_context: impl Into<bool>) -> Self {
+                self.is_stacking_context = Some(is_stacking_context.into());
+                self
+            }
+            pub fn build(self) -> Result<LayoutTreeNode, String> {
+                Ok(LayoutTreeNode {
+                    dom_node_index: self.dom_node_index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(dom_node_index))
+                    })?,
+                    bounding_box: self.bounding_box.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bounding_box))
+                    })?,
+                    layout_text: self.layout_text,
+                    inline_text_nodes: self.inline_text_nodes,
+                    style_index: self.style_index,
+                    paint_order: self.paint_order,
+                    is_stacking_context: self.is_stacking_context,
+                })
+            }
+        }
+        impl LayoutTreeNode {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.LayoutTreeNode";
+        }
+        #[doc = "A subset of the full ComputedStyle as defined by the request whitelist.\n[ComputedStyle](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-ComputedStyle)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ComputedStyle {
+            #[doc = "Name/value pairs of computed style properties."]
+            #[serde(rename = "properties")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub properties: Vec<NameValue>,
+        }
+        impl ComputedStyle {
+            pub fn new(properties: Vec<NameValue>) -> Self {
+                Self { properties }
+            }
+        }
+        impl ComputedStyle {
+            pub fn builder() -> ComputedStyleBuilder {
+                ComputedStyleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ComputedStyleBuilder {
+            properties: Option<Vec<NameValue>>,
+        }
+        impl ComputedStyleBuilder {
+            pub fn propertie(mut self, propertie: impl Into<NameValue>) -> Self {
+                let v = self.properties.get_or_insert(Vec::new());
+                v.push(propertie.into());
+                self
+            }
+            pub fn properties<I, S>(mut self, properties: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NameValue>,
+            {
+                let v = self.properties.get_or_insert(Vec::new());
+                for val in properties {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ComputedStyle, String> {
+                Ok(ComputedStyle {
+                    properties: self.properties.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(properties))
+                    })?,
+                })
+            }
+        }
+        impl ComputedStyle {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.ComputedStyle";
+        }
+        #[doc = "A name/value pair.\n[NameValue](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-NameValue)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct NameValue {
+            #[doc = "Attribute/property name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Attribute/property value."]
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl NameValue {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl NameValue {
+            pub fn builder() -> NameValueBuilder {
+                NameValueBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct NameValueBuilder {
+            name: Option<String>,
+            value: Option<String>,
+        }
+        impl NameValueBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<NameValue, String> {
+                Ok(NameValue {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl NameValue {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.NameValue";
+        }
+        #[doc = "Index of the string in the strings table.\n[StringIndex](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-StringIndex)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Copy, Hash)]
+        pub struct StringIndex(i64);
+        impl StringIndex {
+            pub fn new(val: impl Into<i64>) -> Self {
+                StringIndex(val.into())
+            }
+            pub fn inner(&self) -> &i64 {
+                &self.0
+            }
+        }
+        impl StringIndex {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.StringIndex";
+        }
+        #[doc = "Index of the string in the strings table.\n[ArrayOfStrings](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-ArrayOfStrings)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ArrayOfStrings(Vec<StringIndex>);
+        impl ArrayOfStrings {
+            pub fn new(val: impl Into<Vec<StringIndex>>) -> Self {
+                ArrayOfStrings(val.into())
+            }
+            pub fn inner(&self) -> &Vec<StringIndex> {
+                &self.0
+            }
+        }
+        impl ArrayOfStrings {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.ArrayOfStrings";
+        }
+        #[doc = "Data that is only present on rare nodes.\n[RareStringData](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-RareStringData)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RareStringData {
+            #[serde(rename = "index")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub index: Vec<i64>,
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub value: Vec<StringIndex>,
+        }
+        impl RareStringData {
+            pub fn new(index: Vec<i64>, value: Vec<StringIndex>) -> Self {
+                Self { index, value }
+            }
+        }
+        impl RareStringData {
+            pub fn builder() -> RareStringDataBuilder {
+                RareStringDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RareStringDataBuilder {
+            index: Option<Vec<i64>>,
+            value: Option<Vec<StringIndex>>,
+        }
+        impl RareStringDataBuilder {
+            pub fn index(mut self, index: impl Into<i64>) -> Self {
+                let v = self.index.get_or_insert(Vec::new());
+                v.push(index.into());
+                self
+            }
+            pub fn indexs<I, S>(mut self, indexs: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.index.get_or_insert(Vec::new());
+                for val in indexs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn value(mut self, value: impl Into<StringIndex>) -> Self {
+                let v = self.value.get_or_insert(Vec::new());
+                v.push(value.into());
+                self
+            }
+            pub fn values<I, S>(mut self, values: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<StringIndex>,
+            {
+                let v = self.value.get_or_insert(Vec::new());
+                for val in values {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<RareStringData, String> {
+                Ok(RareStringData {
+                    index: self.index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(index))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl RareStringData {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.RareStringData";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RareBooleanData {
+            #[serde(rename = "index")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub index: Vec<i64>,
+        }
+        impl RareBooleanData {
+            pub fn new(index: Vec<i64>) -> Self {
+                Self { index }
+            }
+        }
+        impl RareBooleanData {
+            pub fn builder() -> RareBooleanDataBuilder {
+                RareBooleanDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RareBooleanDataBuilder {
+            index: Option<Vec<i64>>,
+        }
+        impl RareBooleanDataBuilder {
+            pub fn index(mut self, index: impl Into<i64>) -> Self {
+                let v = self.index.get_or_insert(Vec::new());
+                v.push(index.into());
+                self
+            }
+            pub fn indexs<I, S>(mut self, indexs: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.index.get_or_insert(Vec::new());
+                for val in indexs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<RareBooleanData, String> {
+                Ok(RareBooleanData {
+                    index: self.index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(index))
+                    })?,
+                })
+            }
+        }
+        impl RareBooleanData {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.RareBooleanData";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RareIntegerData {
+            #[serde(rename = "index")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub index: Vec<i64>,
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub value: Vec<i64>,
+        }
+        impl RareIntegerData {
+            pub fn new(index: Vec<i64>, value: Vec<i64>) -> Self {
+                Self { index, value }
+            }
+        }
+        impl RareIntegerData {
+            pub fn builder() -> RareIntegerDataBuilder {
+                RareIntegerDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RareIntegerDataBuilder {
+            index: Option<Vec<i64>>,
+            value: Option<Vec<i64>>,
+        }
+        impl RareIntegerDataBuilder {
+            pub fn index(mut self, index: impl Into<i64>) -> Self {
+                let v = self.index.get_or_insert(Vec::new());
+                v.push(index.into());
+                self
+            }
+            pub fn indexs<I, S>(mut self, indexs: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.index.get_or_insert(Vec::new());
+                for val in indexs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn value(mut self, value: impl Into<i64>) -> Self {
+                let v = self.value.get_or_insert(Vec::new());
+                v.push(value.into());
+                self
+            }
+            pub fn values<I, S>(mut self, values: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.value.get_or_insert(Vec::new());
+                for val in values {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<RareIntegerData, String> {
+                Ok(RareIntegerData {
+                    index: self.index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(index))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl RareIntegerData {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.RareIntegerData";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct Rectangle(Vec<f64>);
+        impl Rectangle {
+            pub fn new(val: impl Into<Vec<f64>>) -> Self {
+                Rectangle(val.into())
+            }
+            pub fn inner(&self) -> &Vec<f64> {
+                &self.0
+            }
+        }
+        impl Rectangle {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.Rectangle";
+        }
+        #[doc = "Document snapshot.\n[DocumentSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-DocumentSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DocumentSnapshot {
+            #[doc = "Document URL that `Document` or `FrameOwner` node points to."]
+            #[serde(rename = "documentURL")]
+            pub document_url: StringIndex,
+            #[doc = "Document title."]
+            #[serde(rename = "title")]
+            pub title: StringIndex,
+            #[doc = "Base URL that `Document` or `FrameOwner` node uses for URL completion."]
+            #[serde(rename = "baseURL")]
+            pub base_url: StringIndex,
+            #[doc = "Contains the document's content language."]
+            #[serde(rename = "contentLanguage")]
+            pub content_language: StringIndex,
+            #[doc = "Contains the document's character set encoding."]
+            #[serde(rename = "encodingName")]
+            pub encoding_name: StringIndex,
+            #[doc = "`DocumentType` node's publicId."]
+            #[serde(rename = "publicId")]
+            pub public_id: StringIndex,
+            #[doc = "`DocumentType` node's systemId."]
+            #[serde(rename = "systemId")]
+            pub system_id: StringIndex,
+            #[doc = "Frame ID for frame owner elements and also for the document node."]
+            #[serde(rename = "frameId")]
+            pub frame_id: StringIndex,
+            #[doc = "A table with dom nodes."]
+            #[serde(rename = "nodes")]
+            pub nodes: NodeTreeSnapshot,
+            #[doc = "The nodes in the layout tree."]
+            #[serde(rename = "layout")]
+            pub layout: LayoutTreeSnapshot,
+            #[doc = "The post-layout inline text nodes."]
+            #[serde(rename = "textBoxes")]
+            pub text_boxes: TextBoxSnapshot,
+            #[doc = "Horizontal scroll offset."]
+            #[serde(rename = "scrollOffsetX")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scroll_offset_x: Option<f64>,
+            #[doc = "Vertical scroll offset."]
+            #[serde(rename = "scrollOffsetY")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scroll_offset_y: Option<f64>,
+            #[doc = "Document content width."]
+            #[serde(rename = "contentWidth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub content_width: Option<f64>,
+            #[doc = "Document content height."]
+            #[serde(rename = "contentHeight")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub content_height: Option<f64>,
+        }
+        impl DocumentSnapshot {
+            pub fn builder() -> DocumentSnapshotBuilder {
+                DocumentSnapshotBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DocumentSnapshotBuilder {
+            document_url: Option<StringIndex>,
+            title: Option<StringIndex>,
+            base_url: Option<StringIndex>,
+            content_language: Option<StringIndex>,
+            encoding_name: Option<StringIndex>,
+            public_id: Option<StringIndex>,
+            system_id: Option<StringIndex>,
+            frame_id: Option<StringIndex>,
+            nodes: Option<NodeTreeSnapshot>,
+            layout: Option<LayoutTreeSnapshot>,
+            text_boxes: Option<TextBoxSnapshot>,
+            scroll_offset_x: Option<f64>,
+            scroll_offset_y: Option<f64>,
+            content_width: Option<f64>,
+            content_height: Option<f64>,
+        }
+        impl DocumentSnapshotBuilder {
+            pub fn document_url(mut self, document_url: impl Into<StringIndex>) -> Self {
+                self.document_url = Some(document_url.into());
+                self
+            }
+            pub fn title(mut self, title: impl Into<StringIndex>) -> Self {
+                self.title = Some(title.into());
+                self
+            }
+            pub fn base_url(mut self, base_url: impl Into<StringIndex>) -> Self {
+                self.base_url = Some(base_url.into());
+                self
+            }
+            pub fn content_language(mut self, content_language: impl Into<StringIndex>) -> Self {
+                self.content_language = Some(content_language.into());
+                self
+            }
+            pub fn encoding_name(mut self, encoding_name: impl Into<StringIndex>) -> Self {
+                self.encoding_name = Some(encoding_name.into());
+                self
+            }
+            pub fn public_id(mut self, public_id: impl Into<StringIndex>) -> Self {
+                self.public_id = Some(public_id.into());
+                self
+            }
+            pub fn system_id(mut self, system_id: impl Into<StringIndex>) -> Self {
+                self.system_id = Some(system_id.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<StringIndex>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn nodes(mut self, nodes: impl Into<NodeTreeSnapshot>) -> Self {
+                self.nodes = Some(nodes.into());
+                self
+            }
+            pub fn layout(mut self, layout: impl Into<LayoutTreeSnapshot>) -> Self {
+                self.layout = Some(layout.into());
+                self
+            }
+            pub fn text_boxes(mut self, text_boxes: impl Into<TextBoxSnapshot>) -> Self {
+                self.text_boxes = Some(text_boxes.into());
+                self
+            }
+            pub fn scroll_offset_x(mut self, scroll_offset_x: impl Into<f64>) -> Self {
+                self.scroll_offset_x = Some(scroll_offset_x.into());
+                self
+            }
+            pub fn scroll_offset_y(mut self, scroll_offset_y: impl Into<f64>) -> Self {
+                self.scroll_offset_y = Some(scroll_offset_y.into());
+                self
+            }
+            pub fn content_width(mut self, content_width: impl Into<f64>) -> Self {
+                self.content_width = Some(content_width.into());
+                self
+            }
+            pub fn content_height(mut self, content_height: impl Into<f64>) -> Self {
+                self.content_height = Some(content_height.into());
+                self
+            }
+            pub fn build(self) -> Result<DocumentSnapshot, String> {
+                Ok(DocumentSnapshot {
+                    document_url: self.document_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(document_url))
+                    })?,
+                    title: self.title.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(title))
+                    })?,
+                    base_url: self.base_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(base_url))
+                    })?,
+                    content_language: self.content_language.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(content_language)
+                        )
+                    })?,
+                    encoding_name: self.encoding_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(encoding_name))
+                    })?,
+                    public_id: self.public_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(public_id))
+                    })?,
+                    system_id: self.system_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(system_id))
+                    })?,
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    nodes: self.nodes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(nodes))
+                    })?,
+                    layout: self.layout.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(layout))
+                    })?,
+                    text_boxes: self.text_boxes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text_boxes))
+                    })?,
+                    scroll_offset_x: self.scroll_offset_x,
+                    scroll_offset_y: self.scroll_offset_y,
+                    content_width: self.content_width,
+                    content_height: self.content_height,
+                })
+            }
+        }
+        impl DocumentSnapshot {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.DocumentSnapshot";
+        }
+        #[doc = "Table containing nodes.\n[NodeTreeSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-NodeTreeSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct NodeTreeSnapshot {
+            #[doc = "Parent node index."]
+            #[serde(rename = "parentIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent_index: Option<Vec<i64>>,
+            #[doc = "`Node`'s nodeType."]
+            #[serde(rename = "nodeType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_type: Option<Vec<i64>>,
+            #[doc = "Type of the shadow root the `Node` is in. String values are equal to the `ShadowRootType` enum."]
+            #[serde(rename = "shadowRootType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub shadow_root_type: Option<RareStringData>,
+            #[doc = "`Node`'s nodeName."]
+            #[serde(rename = "nodeName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_name: Option<Vec<StringIndex>>,
+            #[doc = "`Node`'s nodeValue."]
+            #[serde(rename = "nodeValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_value: Option<Vec<StringIndex>>,
+            #[doc = "`Node`'s id, corresponds to DOM.Node.backendNodeId."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<Vec<super::dom::BackendNodeId>>,
+            #[doc = "Attributes of an `Element` node. Flatten name, value pairs."]
+            #[serde(rename = "attributes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub attributes: Option<Vec<ArrayOfStrings>>,
+            #[doc = "Only set for textarea elements, contains the text value."]
+            #[serde(rename = "textValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub text_value: Option<RareStringData>,
+            #[doc = "Only set for input elements, contains the input's associated text value."]
+            #[serde(rename = "inputValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub input_value: Option<RareStringData>,
+            #[doc = "Only set for radio and checkbox input elements, indicates if the element has been checked"]
+            #[serde(rename = "inputChecked")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub input_checked: Option<RareBooleanData>,
+            #[doc = "Only set for option elements, indicates if the element has been selected"]
+            #[serde(rename = "optionSelected")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub option_selected: Option<RareBooleanData>,
+            #[doc = "The index of the document in the list of the snapshot documents."]
+            #[serde(rename = "contentDocumentIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub content_document_index: Option<RareIntegerData>,
+            #[doc = "Type of a pseudo element node."]
+            #[serde(rename = "pseudoType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pseudo_type: Option<RareStringData>,
+            #[doc = "Pseudo element identifier for this node. Only present if there is a\nvalid pseudoType."]
+            #[serde(rename = "pseudoIdentifier")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub pseudo_identifier: Option<RareStringData>,
+            #[doc = "Whether this DOM node responds to mouse clicks. This includes nodes that have had click\nevent listeners attached via JavaScript as well as anchor tags that naturally navigate when\nclicked."]
+            #[serde(rename = "isClickable")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_clickable: Option<RareBooleanData>,
+            #[doc = "The selected url for nodes with a srcset attribute."]
+            #[serde(rename = "currentSourceURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub current_source_url: Option<RareStringData>,
+            #[doc = "The url of the script (if any) that generates this node."]
+            #[serde(rename = "originURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub origin_url: Option<RareStringData>,
+        }
+        impl NodeTreeSnapshot {
+            pub fn builder() -> NodeTreeSnapshotBuilder {
+                NodeTreeSnapshotBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct NodeTreeSnapshotBuilder {
+            parent_index: Option<Vec<i64>>,
+            node_type: Option<Vec<i64>>,
+            shadow_root_type: Option<RareStringData>,
+            node_name: Option<Vec<StringIndex>>,
+            node_value: Option<Vec<StringIndex>>,
+            backend_node_id: Option<Vec<super::dom::BackendNodeId>>,
+            attributes: Option<Vec<ArrayOfStrings>>,
+            text_value: Option<RareStringData>,
+            input_value: Option<RareStringData>,
+            input_checked: Option<RareBooleanData>,
+            option_selected: Option<RareBooleanData>,
+            content_document_index: Option<RareIntegerData>,
+            pseudo_type: Option<RareStringData>,
+            pseudo_identifier: Option<RareStringData>,
+            is_clickable: Option<RareBooleanData>,
+            current_source_url: Option<RareStringData>,
+            origin_url: Option<RareStringData>,
+        }
+        impl NodeTreeSnapshotBuilder {
+            pub fn parent_index(mut self, parent_index: impl Into<i64>) -> Self {
+                let v = self.parent_index.get_or_insert(Vec::new());
+                v.push(parent_index.into());
+                self
+            }
+            pub fn parent_indexs<I, S>(mut self, parent_indexs: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.parent_index.get_or_insert(Vec::new());
+                for val in parent_indexs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn node_type(mut self, node_type: impl Into<i64>) -> Self {
+                let v = self.node_type.get_or_insert(Vec::new());
+                v.push(node_type.into());
+                self
+            }
+            pub fn node_types<I, S>(mut self, node_types: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.node_type.get_or_insert(Vec::new());
+                for val in node_types {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn shadow_root_type(mut self, shadow_root_type: impl Into<RareStringData>) -> Self {
+                self.shadow_root_type = Some(shadow_root_type.into());
+                self
+            }
+            pub fn node_name(mut self, node_name: impl Into<StringIndex>) -> Self {
+                let v = self.node_name.get_or_insert(Vec::new());
+                v.push(node_name.into());
+                self
+            }
+            pub fn node_names<I, S>(mut self, node_names: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<StringIndex>,
+            {
+                let v = self.node_name.get_or_insert(Vec::new());
+                for val in node_names {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn node_value(mut self, node_value: impl Into<StringIndex>) -> Self {
+                let v = self.node_value.get_or_insert(Vec::new());
+                v.push(node_value.into());
+                self
+            }
+            pub fn node_values<I, S>(mut self, node_values: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<StringIndex>,
+            {
+                let v = self.node_value.get_or_insert(Vec::new());
+                for val in node_values {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                let v = self.backend_node_id.get_or_insert(Vec::new());
+                v.push(backend_node_id.into());
+                self
+            }
+            pub fn backend_node_ids<I, S>(mut self, backend_node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::dom::BackendNodeId>,
+            {
+                let v = self.backend_node_id.get_or_insert(Vec::new());
+                for val in backend_node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn attribute(mut self, attribute: impl Into<ArrayOfStrings>) -> Self {
+                let v = self.attributes.get_or_insert(Vec::new());
+                v.push(attribute.into());
+                self
+            }
+            pub fn attributes<I, S>(mut self, attributes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ArrayOfStrings>,
+            {
+                let v = self.attributes.get_or_insert(Vec::new());
+                for val in attributes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn text_value(mut self, text_value: impl Into<RareStringData>) -> Self {
+                self.text_value = Some(text_value.into());
+                self
+            }
+            pub fn input_value(mut self, input_value: impl Into<RareStringData>) -> Self {
+                self.input_value = Some(input_value.into());
+                self
+            }
+            pub fn input_checked(mut self, input_checked: impl Into<RareBooleanData>) -> Self {
+                self.input_checked = Some(input_checked.into());
+                self
+            }
+            pub fn option_selected(mut self, option_selected: impl Into<RareBooleanData>) -> Self {
+                self.option_selected = Some(option_selected.into());
+                self
+            }
+            pub fn content_document_index(
+                mut self,
+                content_document_index: impl Into<RareIntegerData>,
+            ) -> Self {
+                self.content_document_index = Some(content_document_index.into());
+                self
+            }
+            pub fn pseudo_type(mut self, pseudo_type: impl Into<RareStringData>) -> Self {
+                self.pseudo_type = Some(pseudo_type.into());
+                self
+            }
+            pub fn pseudo_identifier(
+                mut self,
+                pseudo_identifier: impl Into<RareStringData>,
+            ) -> Self {
+                self.pseudo_identifier = Some(pseudo_identifier.into());
+                self
+            }
+            pub fn is_clickable(mut self, is_clickable: impl Into<RareBooleanData>) -> Self {
+                self.is_clickable = Some(is_clickable.into());
+                self
+            }
+            pub fn current_source_url(
+                mut self,
+                current_source_url: impl Into<RareStringData>,
+            ) -> Self {
+                self.current_source_url = Some(current_source_url.into());
+                self
+            }
+            pub fn origin_url(mut self, origin_url: impl Into<RareStringData>) -> Self {
+                self.origin_url = Some(origin_url.into());
+                self
+            }
+            pub fn build(self) -> NodeTreeSnapshot {
+                NodeTreeSnapshot {
+                    parent_index: self.parent_index,
+                    node_type: self.node_type,
+                    shadow_root_type: self.shadow_root_type,
+                    node_name: self.node_name,
+                    node_value: self.node_value,
+                    backend_node_id: self.backend_node_id,
+                    attributes: self.attributes,
+                    text_value: self.text_value,
+                    input_value: self.input_value,
+                    input_checked: self.input_checked,
+                    option_selected: self.option_selected,
+                    content_document_index: self.content_document_index,
+                    pseudo_type: self.pseudo_type,
+                    pseudo_identifier: self.pseudo_identifier,
+                    is_clickable: self.is_clickable,
+                    current_source_url: self.current_source_url,
+                    origin_url: self.origin_url,
+                }
+            }
+        }
+        impl NodeTreeSnapshot {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.NodeTreeSnapshot";
+        }
+        #[doc = "Table of details of an element in the DOM tree with a LayoutObject.\n[LayoutTreeSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-LayoutTreeSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LayoutTreeSnapshot {
+            #[doc = "Index of the corresponding node in the `NodeTreeSnapshot` array returned by `captureSnapshot`."]
+            #[serde(rename = "nodeIndex")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_index: Vec<i64>,
+            #[doc = "Array of indexes specifying computed style strings, filtered according to the `computedStyles` parameter passed to `captureSnapshot`."]
+            #[serde(rename = "styles")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub styles: Vec<ArrayOfStrings>,
+            #[doc = "The absolute position bounding box."]
+            #[serde(rename = "bounds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub bounds: Vec<Rectangle>,
+            #[doc = "Contents of the LayoutText, if any."]
+            #[serde(rename = "text")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub text: Vec<StringIndex>,
+            #[doc = "Stacking context information."]
+            #[serde(rename = "stackingContexts")]
+            pub stacking_contexts: RareBooleanData,
+            #[doc = "Global paint order index, which is determined by the stacking order of the nodes. Nodes\nthat are painted together will have the same index. Only provided if includePaintOrder in\ncaptureSnapshot was true."]
+            #[serde(rename = "paintOrders")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub paint_orders: Option<Vec<i64>>,
+            #[doc = "The offset rect of nodes. Only available when includeDOMRects is set to true"]
+            #[serde(rename = "offsetRects")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub offset_rects: Option<Vec<Rectangle>>,
+            #[doc = "The scroll rect of nodes. Only available when includeDOMRects is set to true"]
+            #[serde(rename = "scrollRects")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scroll_rects: Option<Vec<Rectangle>>,
+            #[doc = "The client rect of nodes. Only available when includeDOMRects is set to true"]
+            #[serde(rename = "clientRects")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub client_rects: Option<Vec<Rectangle>>,
+            #[doc = "The list of background colors that are blended with colors of overlapping elements."]
+            #[serde(rename = "blendedBackgroundColors")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub blended_background_colors: Option<Vec<StringIndex>>,
+            #[doc = "The list of computed text opacities."]
+            #[serde(rename = "textColorOpacities")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub text_color_opacities: Option<Vec<f64>>,
+        }
+        impl LayoutTreeSnapshot {
+            pub fn builder() -> LayoutTreeSnapshotBuilder {
+                LayoutTreeSnapshotBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LayoutTreeSnapshotBuilder {
+            node_index: Option<Vec<i64>>,
+            styles: Option<Vec<ArrayOfStrings>>,
+            bounds: Option<Vec<Rectangle>>,
+            text: Option<Vec<StringIndex>>,
+            stacking_contexts: Option<RareBooleanData>,
+            paint_orders: Option<Vec<i64>>,
+            offset_rects: Option<Vec<Rectangle>>,
+            scroll_rects: Option<Vec<Rectangle>>,
+            client_rects: Option<Vec<Rectangle>>,
+            blended_background_colors: Option<Vec<StringIndex>>,
+            text_color_opacities: Option<Vec<f64>>,
+        }
+        impl LayoutTreeSnapshotBuilder {
+            pub fn node_index(mut self, node_index: impl Into<i64>) -> Self {
+                let v = self.node_index.get_or_insert(Vec::new());
+                v.push(node_index.into());
+                self
+            }
+            pub fn node_indexs<I, S>(mut self, node_indexs: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.node_index.get_or_insert(Vec::new());
+                for val in node_indexs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn style(mut self, style: impl Into<ArrayOfStrings>) -> Self {
+                let v = self.styles.get_or_insert(Vec::new());
+                v.push(style.into());
+                self
+            }
+            pub fn styles<I, S>(mut self, styles: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ArrayOfStrings>,
+            {
+                let v = self.styles.get_or_insert(Vec::new());
+                for val in styles {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn bound(mut self, bound: impl Into<Rectangle>) -> Self {
+                let v = self.bounds.get_or_insert(Vec::new());
+                v.push(bound.into());
+                self
+            }
+            pub fn bounds<I, S>(mut self, bounds: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Rectangle>,
+            {
+                let v = self.bounds.get_or_insert(Vec::new());
+                for val in bounds {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn text(mut self, text: impl Into<StringIndex>) -> Self {
+                let v = self.text.get_or_insert(Vec::new());
+                v.push(text.into());
+                self
+            }
+            pub fn texts<I, S>(mut self, texts: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<StringIndex>,
+            {
+                let v = self.text.get_or_insert(Vec::new());
+                for val in texts {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn stacking_contexts(
+                mut self,
+                stacking_contexts: impl Into<RareBooleanData>,
+            ) -> Self {
+                self.stacking_contexts = Some(stacking_contexts.into());
+                self
+            }
+            pub fn paint_order(mut self, paint_order: impl Into<i64>) -> Self {
+                let v = self.paint_orders.get_or_insert(Vec::new());
+                v.push(paint_order.into());
+                self
+            }
+            pub fn paint_orders<I, S>(mut self, paint_orders: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.paint_orders.get_or_insert(Vec::new());
+                for val in paint_orders {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn offset_rect(mut self, offset_rect: impl Into<Rectangle>) -> Self {
+                let v = self.offset_rects.get_or_insert(Vec::new());
+                v.push(offset_rect.into());
+                self
+            }
+            pub fn offset_rects<I, S>(mut self, offset_rects: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Rectangle>,
+            {
+                let v = self.offset_rects.get_or_insert(Vec::new());
+                for val in offset_rects {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn scroll_rect(mut self, scroll_rect: impl Into<Rectangle>) -> Self {
+                let v = self.scroll_rects.get_or_insert(Vec::new());
+                v.push(scroll_rect.into());
+                self
+            }
+            pub fn scroll_rects<I, S>(mut self, scroll_rects: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Rectangle>,
+            {
+                let v = self.scroll_rects.get_or_insert(Vec::new());
+                for val in scroll_rects {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn client_rect(mut self, client_rect: impl Into<Rectangle>) -> Self {
+                let v = self.client_rects.get_or_insert(Vec::new());
+                v.push(client_rect.into());
+                self
+            }
+            pub fn client_rects<I, S>(mut self, client_rects: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Rectangle>,
+            {
+                let v = self.client_rects.get_or_insert(Vec::new());
+                for val in client_rects {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn blended_background_color(
+                mut self,
+                blended_background_color: impl Into<StringIndex>,
+            ) -> Self {
+                let v = self.blended_background_colors.get_or_insert(Vec::new());
+                v.push(blended_background_color.into());
+                self
+            }
+            pub fn blended_background_colors<I, S>(mut self, blended_background_colors: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<StringIndex>,
+            {
+                let v = self.blended_background_colors.get_or_insert(Vec::new());
+                for val in blended_background_colors {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn text_color_opacitie(mut self, text_color_opacitie: impl Into<f64>) -> Self {
+                let v = self.text_color_opacities.get_or_insert(Vec::new());
+                v.push(text_color_opacitie.into());
+                self
+            }
+            pub fn text_color_opacities<I, S>(mut self, text_color_opacities: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<f64>,
+            {
+                let v = self.text_color_opacities.get_or_insert(Vec::new());
+                for val in text_color_opacities {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<LayoutTreeSnapshot, String> {
+                Ok(LayoutTreeSnapshot {
+                    node_index: self.node_index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_index))
+                    })?,
+                    styles: self.styles.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(styles))
+                    })?,
+                    bounds: self.bounds.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bounds))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    stacking_contexts: self.stacking_contexts.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(stacking_contexts)
+                        )
+                    })?,
+                    paint_orders: self.paint_orders,
+                    offset_rects: self.offset_rects,
+                    scroll_rects: self.scroll_rects,
+                    client_rects: self.client_rects,
+                    blended_background_colors: self.blended_background_colors,
+                    text_color_opacities: self.text_color_opacities,
+                })
+            }
+        }
+        impl LayoutTreeSnapshot {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.LayoutTreeSnapshot";
+        }
+        #[doc = "Table of details of the post layout rendered text positions. The exact layout should not be regarded as\nstable and may change between versions.\n[TextBoxSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#type-TextBoxSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TextBoxSnapshot {
+            #[doc = "Index of the layout tree node that owns this box collection."]
+            #[serde(rename = "layoutIndex")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub layout_index: Vec<i64>,
+            #[doc = "The absolute position bounding box."]
+            #[serde(rename = "bounds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub bounds: Vec<Rectangle>,
+            #[doc = "The starting index in characters, for this post layout textbox substring. Characters that\nwould be represented as a surrogate pair in UTF-16 have length 2."]
+            #[serde(rename = "start")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub start: Vec<i64>,
+            #[doc = "The number of characters in this post layout textbox substring. Characters that would be\nrepresented as a surrogate pair in UTF-16 have length 2."]
+            #[serde(rename = "length")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub length: Vec<i64>,
+        }
+        impl TextBoxSnapshot {
+            pub fn new(
+                layout_index: Vec<i64>,
+                bounds: Vec<Rectangle>,
+                start: Vec<i64>,
+                length: Vec<i64>,
+            ) -> Self {
+                Self {
+                    layout_index,
+                    bounds,
+                    start,
+                    length,
+                }
+            }
+        }
+        impl TextBoxSnapshot {
+            pub fn builder() -> TextBoxSnapshotBuilder {
+                TextBoxSnapshotBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TextBoxSnapshotBuilder {
+            layout_index: Option<Vec<i64>>,
+            bounds: Option<Vec<Rectangle>>,
+            start: Option<Vec<i64>>,
+            length: Option<Vec<i64>>,
+        }
+        impl TextBoxSnapshotBuilder {
+            pub fn layout_index(mut self, layout_index: impl Into<i64>) -> Self {
+                let v = self.layout_index.get_or_insert(Vec::new());
+                v.push(layout_index.into());
+                self
+            }
+            pub fn layout_indexs<I, S>(mut self, layout_indexs: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.layout_index.get_or_insert(Vec::new());
+                for val in layout_indexs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn bound(mut self, bound: impl Into<Rectangle>) -> Self {
+                let v = self.bounds.get_or_insert(Vec::new());
+                v.push(bound.into());
+                self
+            }
+            pub fn bounds<I, S>(mut self, bounds: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Rectangle>,
+            {
+                let v = self.bounds.get_or_insert(Vec::new());
+                for val in bounds {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn start(mut self, start: impl Into<i64>) -> Self {
+                let v = self.start.get_or_insert(Vec::new());
+                v.push(start.into());
+                self
+            }
+            pub fn starts<I, S>(mut self, starts: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.start.get_or_insert(Vec::new());
+                for val in starts {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn length(mut self, length: impl Into<i64>) -> Self {
+                let v = self.length.get_or_insert(Vec::new());
+                v.push(length.into());
+                self
+            }
+            pub fn lengths<I, S>(mut self, lengths: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.length.get_or_insert(Vec::new());
+                for val in lengths {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<TextBoxSnapshot, String> {
+                Ok(TextBoxSnapshot {
+                    layout_index: self.layout_index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(layout_index))
+                    })?,
+                    bounds: self.bounds.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bounds))
+                    })?,
+                    start: self.start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start))
+                    })?,
+                    length: self.length.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(length))
+                    })?,
+                })
+            }
+        }
+        impl TextBoxSnapshot {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.TextBoxSnapshot";
+        }
+        #[doc = "Disables DOM snapshot agent for the given page.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables DOM snapshot agent for the given page.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables DOM snapshot agent for the given page.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables DOM snapshot agent for the given page.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Returns a document snapshot, including the full DOM tree of the root node (including iframes,\ntemplate contents, and imported documents) in a flattened array, as well as layout and\nwhite-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is\nflattened.\n[captureSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#method-captureSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CaptureSnapshotParams {
+            #[doc = "Whitelist of computed styles to return."]
+            #[serde(rename = "computedStyles")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub computed_styles: Vec<String>,
+            #[doc = "Whether to include layout object paint orders into the snapshot."]
+            #[serde(rename = "includePaintOrder")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_paint_order: Option<bool>,
+            #[doc = "Whether to include DOM rectangles (offsetRects, clientRects, scrollRects) into the snapshot"]
+            #[serde(rename = "includeDOMRects")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_dom_rects: Option<bool>,
+            #[doc = "Whether to include blended background colors in the snapshot (default: false).\nBlended background color is achieved by blending background colors of all elements\nthat overlap with the current element."]
+            #[serde(rename = "includeBlendedBackgroundColors")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_blended_background_colors: Option<bool>,
+            #[doc = "Whether to include text color opacity in the snapshot (default: false).\nAn element might have the opacity property set that affects the text color of the element.\nThe final text color opacity is computed based on the opacity of all overlapping elements."]
+            #[serde(rename = "includeTextColorOpacities")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_text_color_opacities: Option<bool>,
+        }
+        impl CaptureSnapshotParams {
+            pub fn new(computed_styles: Vec<String>) -> Self {
+                Self {
+                    computed_styles,
+                    include_paint_order: None,
+                    include_dom_rects: None,
+                    include_blended_background_colors: None,
+                    include_text_color_opacities: None,
+                }
+            }
+        }
+        impl CaptureSnapshotParams {
+            pub fn builder() -> CaptureSnapshotParamsBuilder {
+                CaptureSnapshotParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CaptureSnapshotParamsBuilder {
+            computed_styles: Option<Vec<String>>,
+            include_paint_order: Option<bool>,
+            include_dom_rects: Option<bool>,
+            include_blended_background_colors: Option<bool>,
+            include_text_color_opacities: Option<bool>,
+        }
+        impl CaptureSnapshotParamsBuilder {
+            pub fn computed_style(mut self, computed_style: impl Into<String>) -> Self {
+                let v = self.computed_styles.get_or_insert(Vec::new());
+                v.push(computed_style.into());
+                self
+            }
+            pub fn computed_styles<I, S>(mut self, computed_styles: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.computed_styles.get_or_insert(Vec::new());
+                for val in computed_styles {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn include_paint_order(mut self, include_paint_order: impl Into<bool>) -> Self {
+                self.include_paint_order = Some(include_paint_order.into());
+                self
+            }
+            pub fn include_dom_rects(mut self, include_dom_rects: impl Into<bool>) -> Self {
+                self.include_dom_rects = Some(include_dom_rects.into());
+                self
+            }
+            pub fn include_blended_background_colors(
+                mut self,
+                include_blended_background_colors: impl Into<bool>,
+            ) -> Self {
+                self.include_blended_background_colors =
+                    Some(include_blended_background_colors.into());
+                self
+            }
+            pub fn include_text_color_opacities(
+                mut self,
+                include_text_color_opacities: impl Into<bool>,
+            ) -> Self {
+                self.include_text_color_opacities = Some(include_text_color_opacities.into());
+                self
+            }
+            pub fn build(self) -> Result<CaptureSnapshotParams, String> {
+                Ok(CaptureSnapshotParams {
+                    computed_styles: self.computed_styles.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(computed_styles))
+                    })?,
+                    include_paint_order: self.include_paint_order,
+                    include_dom_rects: self.include_dom_rects,
+                    include_blended_background_colors: self.include_blended_background_colors,
+                    include_text_color_opacities: self.include_text_color_opacities,
+                })
+            }
+        }
+        impl CaptureSnapshotParams {
+            pub const IDENTIFIER: &'static str = "DOMSnapshot.captureSnapshot";
+        }
+        impl chromiumoxide_types::Method for CaptureSnapshotParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CaptureSnapshotParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns a document snapshot, including the full DOM tree of the root node (including iframes,\ntemplate contents, and imported documents) in a flattened array, as well as layout and\nwhite-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is\nflattened.\n[captureSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/#method-captureSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CaptureSnapshotReturns {
+            #[doc = "The nodes in the DOM tree. The DOMNode at index 0 corresponds to the root document."]
+            #[serde(rename = "documents")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub documents: Vec<DocumentSnapshot>,
+            #[doc = "Shared string table that all string properties refer to with indexes."]
+            #[serde(rename = "strings")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub strings: Vec<String>,
+        }
+        impl CaptureSnapshotReturns {
+            pub fn new(documents: Vec<DocumentSnapshot>, strings: Vec<String>) -> Self {
+                Self { documents, strings }
+            }
+        }
+        impl CaptureSnapshotReturns {
+            pub fn builder() -> CaptureSnapshotReturnsBuilder {
+                CaptureSnapshotReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CaptureSnapshotReturnsBuilder {
+            documents: Option<Vec<DocumentSnapshot>>,
+            strings: Option<Vec<String>>,
+        }
+        impl CaptureSnapshotReturnsBuilder {
+            pub fn document(mut self, document: impl Into<DocumentSnapshot>) -> Self {
+                let v = self.documents.get_or_insert(Vec::new());
+                v.push(document.into());
+                self
+            }
+            pub fn documents<I, S>(mut self, documents: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<DocumentSnapshot>,
+            {
+                let v = self.documents.get_or_insert(Vec::new());
+                for val in documents {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn string(mut self, string: impl Into<String>) -> Self {
+                let v = self.strings.get_or_insert(Vec::new());
+                v.push(string.into());
+                self
+            }
+            pub fn strings<I, S>(mut self, strings: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.strings.get_or_insert(Vec::new());
+                for val in strings {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<CaptureSnapshotReturns, String> {
+                Ok(CaptureSnapshotReturns {
+                    documents: self.documents.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(documents))
+                    })?,
+                    strings: self.strings.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(strings))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CaptureSnapshotParams {
+            type Response = CaptureSnapshotReturns;
+        }
+    }
+    #[doc = "Query and modify DOM storage."]
+    pub mod dom_storage {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct SerializedStorageKey(String);
+        impl SerializedStorageKey {
+            pub fn new(val: impl Into<String>) -> Self {
+                SerializedStorageKey(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for SerializedStorageKey {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<SerializedStorageKey> for String {
+            fn from(el: SerializedStorageKey) -> String {
+                el.0
+            }
+        }
+        impl From<String> for SerializedStorageKey {
+            fn from(expr: String) -> Self {
+                SerializedStorageKey(expr)
+            }
+        }
+        impl SerializedStorageKey {
+            pub const IDENTIFIER: &'static str = "DOMStorage.SerializedStorageKey";
+        }
+        #[doc = "DOM Storage identifier.\n[StorageId](https://chromedevtools.github.io/devtools-protocol/tot/DOMStorage/#type-StorageId)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StorageId {
+            #[doc = "Security origin for the storage."]
+            #[serde(rename = "securityOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_origin: Option<String>,
+            #[doc = "Represents a key by which DOM Storage keys its CachedStorageAreas"]
+            #[serde(rename = "storageKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_key: Option<SerializedStorageKey>,
+            #[doc = "Whether the storage is local storage (not session storage)."]
+            #[serde(rename = "isLocalStorage")]
+            pub is_local_storage: bool,
+        }
+        impl StorageId {
+            pub fn new(is_local_storage: impl Into<bool>) -> Self {
+                Self {
+                    is_local_storage: is_local_storage.into(),
+                    security_origin: None,
+                    storage_key: None,
+                }
+            }
+        }
+        impl StorageId {
+            pub fn builder() -> StorageIdBuilder {
+                StorageIdBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StorageIdBuilder {
+            security_origin: Option<String>,
+            storage_key: Option<SerializedStorageKey>,
+            is_local_storage: Option<bool>,
+        }
+        impl StorageIdBuilder {
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<SerializedStorageKey>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn is_local_storage(mut self, is_local_storage: impl Into<bool>) -> Self {
+                self.is_local_storage = Some(is_local_storage.into());
+                self
+            }
+            pub fn build(self) -> Result<StorageId, String> {
+                Ok(StorageId {
+                    security_origin: self.security_origin,
+                    storage_key: self.storage_key,
+                    is_local_storage: self.is_local_storage.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(is_local_storage)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl StorageId {
+            pub const IDENTIFIER: &'static str = "DOMStorage.StorageId";
+        }
+        #[doc = "DOM Storage item.\n[Item](https://chromedevtools.github.io/devtools-protocol/tot/DOMStorage/#type-Item)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct Item(Vec<String>);
+        impl Item {
+            pub fn new(val: impl Into<Vec<String>>) -> Self {
+                Item(val.into())
+            }
+            pub fn inner(&self) -> &Vec<String> {
+                &self.0
+            }
+        }
+        impl Item {
+            pub const IDENTIFIER: &'static str = "DOMStorage.Item";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClearParams {
+            #[serde(rename = "storageId")]
+            pub storage_id: StorageId,
+        }
+        impl ClearParams {
+            pub fn new(storage_id: impl Into<StorageId>) -> Self {
+                Self {
+                    storage_id: storage_id.into(),
+                }
+            }
+        }
+        impl ClearParams {
+            pub fn builder() -> ClearParamsBuilder {
+                ClearParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearParamsBuilder {
+            storage_id: Option<StorageId>,
+        }
+        impl ClearParamsBuilder {
+            pub fn storage_id(mut self, storage_id: impl Into<StorageId>) -> Self {
+                self.storage_id = Some(storage_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ClearParams, String> {
+                Ok(ClearParams {
+                    storage_id: self.storage_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_id))
+                    })?,
+                })
+            }
+        }
+        impl ClearParams {
+            pub const IDENTIFIER: &'static str = "DOMStorage.clear";
+        }
+        impl chromiumoxide_types::Method for ClearParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearReturns {}
+        impl chromiumoxide_types::Command for ClearParams {
+            type Response = ClearReturns;
+        }
+        #[doc = "Disables storage tracking, prevents storage events from being sent to the client.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/DOMStorage/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "DOMStorage.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables storage tracking, prevents storage events from being sent to the client.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/DOMStorage/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables storage tracking, storage events will now be delivered to the client.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/DOMStorage/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "DOMStorage.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables storage tracking, storage events will now be delivered to the client.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/DOMStorage/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetDomStorageItemsParams {
+            #[serde(rename = "storageId")]
+            pub storage_id: StorageId,
+        }
+        impl GetDomStorageItemsParams {
+            pub fn new(storage_id: impl Into<StorageId>) -> Self {
+                Self {
+                    storage_id: storage_id.into(),
+                }
+            }
+        }
+        impl GetDomStorageItemsParams {
+            pub fn builder() -> GetDomStorageItemsParamsBuilder {
+                GetDomStorageItemsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDomStorageItemsParamsBuilder {
+            storage_id: Option<StorageId>,
+        }
+        impl GetDomStorageItemsParamsBuilder {
+            pub fn storage_id(mut self, storage_id: impl Into<StorageId>) -> Self {
+                self.storage_id = Some(storage_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetDomStorageItemsParams, String> {
+                Ok(GetDomStorageItemsParams {
+                    storage_id: self.storage_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_id))
+                    })?,
+                })
+            }
+        }
+        impl GetDomStorageItemsParams {
+            pub const IDENTIFIER: &'static str = "DOMStorage.getDOMStorageItems";
+        }
+        impl chromiumoxide_types::Method for GetDomStorageItemsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetDomStorageItemsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetDomStorageItemsReturns {
+            #[serde(rename = "entries")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub entries: Vec<Item>,
+        }
+        impl GetDomStorageItemsReturns {
+            pub fn new(entries: Vec<Item>) -> Self {
+                Self { entries }
+            }
+        }
+        impl GetDomStorageItemsReturns {
+            pub fn builder() -> GetDomStorageItemsReturnsBuilder {
+                GetDomStorageItemsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDomStorageItemsReturnsBuilder {
+            entries: Option<Vec<Item>>,
+        }
+        impl GetDomStorageItemsReturnsBuilder {
+            pub fn entrie(mut self, entrie: impl Into<Item>) -> Self {
+                let v = self.entries.get_or_insert(Vec::new());
+                v.push(entrie.into());
+                self
+            }
+            pub fn entries<I, S>(mut self, entries: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Item>,
+            {
+                let v = self.entries.get_or_insert(Vec::new());
+                for val in entries {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetDomStorageItemsReturns, String> {
+                Ok(GetDomStorageItemsReturns {
+                    entries: self.entries.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(entries))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetDomStorageItemsParams {
+            type Response = GetDomStorageItemsReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveDomStorageItemParams {
+            #[serde(rename = "storageId")]
+            pub storage_id: StorageId,
+            #[serde(rename = "key")]
+            pub key: String,
+        }
+        impl RemoveDomStorageItemParams {
+            pub fn new(storage_id: impl Into<StorageId>, key: impl Into<String>) -> Self {
+                Self {
+                    storage_id: storage_id.into(),
+                    key: key.into(),
+                }
+            }
+        }
+        impl RemoveDomStorageItemParams {
+            pub fn builder() -> RemoveDomStorageItemParamsBuilder {
+                RemoveDomStorageItemParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveDomStorageItemParamsBuilder {
+            storage_id: Option<StorageId>,
+            key: Option<String>,
+        }
+        impl RemoveDomStorageItemParamsBuilder {
+            pub fn storage_id(mut self, storage_id: impl Into<StorageId>) -> Self {
+                self.storage_id = Some(storage_id.into());
+                self
+            }
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveDomStorageItemParams, String> {
+                Ok(RemoveDomStorageItemParams {
+                    storage_id: self.storage_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_id))
+                    })?,
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                })
+            }
+        }
+        impl RemoveDomStorageItemParams {
+            pub const IDENTIFIER: &'static str = "DOMStorage.removeDOMStorageItem";
+        }
+        impl chromiumoxide_types::Method for RemoveDomStorageItemParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveDomStorageItemParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveDomStorageItemReturns {}
+        impl chromiumoxide_types::Command for RemoveDomStorageItemParams {
+            type Response = RemoveDomStorageItemReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDomStorageItemParams {
+            #[serde(rename = "storageId")]
+            pub storage_id: StorageId,
+            #[serde(rename = "key")]
+            pub key: String,
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl SetDomStorageItemParams {
+            pub fn new(
+                storage_id: impl Into<StorageId>,
+                key: impl Into<String>,
+                value: impl Into<String>,
+            ) -> Self {
+                Self {
+                    storage_id: storage_id.into(),
+                    key: key.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl SetDomStorageItemParams {
+            pub fn builder() -> SetDomStorageItemParamsBuilder {
+                SetDomStorageItemParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDomStorageItemParamsBuilder {
+            storage_id: Option<StorageId>,
+            key: Option<String>,
+            value: Option<String>,
+        }
+        impl SetDomStorageItemParamsBuilder {
+            pub fn storage_id(mut self, storage_id: impl Into<StorageId>) -> Self {
+                self.storage_id = Some(storage_id.into());
+                self
+            }
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<SetDomStorageItemParams, String> {
+                Ok(SetDomStorageItemParams {
+                    storage_id: self.storage_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_id))
+                    })?,
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl SetDomStorageItemParams {
+            pub const IDENTIFIER: &'static str = "DOMStorage.setDOMStorageItem";
+        }
+        impl chromiumoxide_types::Method for SetDomStorageItemParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDomStorageItemParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDomStorageItemReturns {}
+        impl chromiumoxide_types::Command for SetDomStorageItemParams {
+            type Response = SetDomStorageItemReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDomStorageItemAdded {
+            #[serde(rename = "storageId")]
+            pub storage_id: StorageId,
+            #[serde(rename = "key")]
+            pub key: String,
+            #[serde(rename = "newValue")]
+            pub new_value: String,
+        }
+        impl EventDomStorageItemAdded {
+            pub const IDENTIFIER: &'static str = "DOMStorage.domStorageItemAdded";
+        }
+        impl chromiumoxide_types::Method for EventDomStorageItemAdded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDomStorageItemAdded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDomStorageItemRemoved {
+            #[serde(rename = "storageId")]
+            pub storage_id: StorageId,
+            #[serde(rename = "key")]
+            pub key: String,
+        }
+        impl EventDomStorageItemRemoved {
+            pub const IDENTIFIER: &'static str = "DOMStorage.domStorageItemRemoved";
+        }
+        impl chromiumoxide_types::Method for EventDomStorageItemRemoved {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDomStorageItemRemoved {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDomStorageItemUpdated {
+            #[serde(rename = "storageId")]
+            pub storage_id: StorageId,
+            #[serde(rename = "key")]
+            pub key: String,
+            #[serde(rename = "oldValue")]
+            pub old_value: String,
+            #[serde(rename = "newValue")]
+            pub new_value: String,
+        }
+        impl EventDomStorageItemUpdated {
+            pub const IDENTIFIER: &'static str = "DOMStorage.domStorageItemUpdated";
+        }
+        impl chromiumoxide_types::Method for EventDomStorageItemUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDomStorageItemUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDomStorageItemsCleared {
+            #[serde(rename = "storageId")]
+            pub storage_id: StorageId,
+        }
+        impl EventDomStorageItemsCleared {
+            pub const IDENTIFIER: &'static str = "DOMStorage.domStorageItemsCleared";
+        }
+        impl chromiumoxide_types::Method for EventDomStorageItemsCleared {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDomStorageItemsCleared {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod device_access {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Device request id.\n[RequestId](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#type-RequestId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct RequestId(String);
+        impl RequestId {
+            pub fn new(val: impl Into<String>) -> Self {
+                RequestId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for RequestId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<RequestId> for String {
+            fn from(el: RequestId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for RequestId {
+            fn from(expr: String) -> Self {
+                RequestId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for RequestId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl RequestId {
+            pub const IDENTIFIER: &'static str = "DeviceAccess.RequestId";
+        }
+        #[doc = "A device id.\n[DeviceId](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#type-DeviceId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct DeviceId(String);
+        impl DeviceId {
+            pub fn new(val: impl Into<String>) -> Self {
+                DeviceId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for DeviceId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<DeviceId> for String {
+            fn from(el: DeviceId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for DeviceId {
+            fn from(expr: String) -> Self {
+                DeviceId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for DeviceId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl DeviceId {
+            pub const IDENTIFIER: &'static str = "DeviceAccess.DeviceId";
+        }
+        #[doc = "Device information displayed in a user prompt to select a device.\n[PromptDevice](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#type-PromptDevice)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PromptDevice {
+            #[serde(rename = "id")]
+            pub id: DeviceId,
+            #[doc = "Display name as it appears in a device request user prompt."]
+            #[serde(rename = "name")]
+            pub name: String,
+        }
+        impl PromptDevice {
+            pub fn new(id: impl Into<DeviceId>, name: impl Into<String>) -> Self {
+                Self {
+                    id: id.into(),
+                    name: name.into(),
+                }
+            }
+        }
+        impl PromptDevice {
+            pub fn builder() -> PromptDeviceBuilder {
+                PromptDeviceBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PromptDeviceBuilder {
+            id: Option<DeviceId>,
+            name: Option<String>,
+        }
+        impl PromptDeviceBuilder {
+            pub fn id(mut self, id: impl Into<DeviceId>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn build(self) -> Result<PromptDevice, String> {
+                Ok(PromptDevice {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                })
+            }
+        }
+        impl PromptDevice {
+            pub const IDENTIFIER: &'static str = "DeviceAccess.PromptDevice";
+        }
+        #[doc = "Enable events in this domain.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "DeviceAccess.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enable events in this domain.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Disable events in this domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "DeviceAccess.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disable events in this domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Select a device in response to a DeviceAccess.deviceRequestPrompted event.\n[selectPrompt](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#method-selectPrompt)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SelectPromptParams {
+            #[serde(rename = "id")]
+            pub id: RequestId,
+            #[serde(rename = "deviceId")]
+            pub device_id: DeviceId,
+        }
+        impl SelectPromptParams {
+            pub fn new(id: impl Into<RequestId>, device_id: impl Into<DeviceId>) -> Self {
+                Self {
+                    id: id.into(),
+                    device_id: device_id.into(),
+                }
+            }
+        }
+        impl SelectPromptParams {
+            pub fn builder() -> SelectPromptParamsBuilder {
+                SelectPromptParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SelectPromptParamsBuilder {
+            id: Option<RequestId>,
+            device_id: Option<DeviceId>,
+        }
+        impl SelectPromptParamsBuilder {
+            pub fn id(mut self, id: impl Into<RequestId>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn device_id(mut self, device_id: impl Into<DeviceId>) -> Self {
+                self.device_id = Some(device_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SelectPromptParams, String> {
+                Ok(SelectPromptParams {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    device_id: self.device_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(device_id))
+                    })?,
+                })
+            }
+        }
+        impl SelectPromptParams {
+            pub const IDENTIFIER: &'static str = "DeviceAccess.selectPrompt";
+        }
+        impl chromiumoxide_types::Method for SelectPromptParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SelectPromptParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Select a device in response to a DeviceAccess.deviceRequestPrompted event.\n[selectPrompt](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#method-selectPrompt)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SelectPromptReturns {}
+        impl chromiumoxide_types::Command for SelectPromptParams {
+            type Response = SelectPromptReturns;
+        }
+        #[doc = "Cancel a prompt in response to a DeviceAccess.deviceRequestPrompted event.\n[cancelPrompt](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#method-cancelPrompt)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CancelPromptParams {
+            #[serde(rename = "id")]
+            pub id: RequestId,
+        }
+        impl CancelPromptParams {
+            pub fn new(id: impl Into<RequestId>) -> Self {
+                Self { id: id.into() }
+            }
+        }
+        impl CancelPromptParams {
+            pub fn builder() -> CancelPromptParamsBuilder {
+                CancelPromptParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CancelPromptParamsBuilder {
+            id: Option<RequestId>,
+        }
+        impl CancelPromptParamsBuilder {
+            pub fn id(mut self, id: impl Into<RequestId>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn build(self) -> Result<CancelPromptParams, String> {
+                Ok(CancelPromptParams {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                })
+            }
+        }
+        impl CancelPromptParams {
+            pub const IDENTIFIER: &'static str = "DeviceAccess.cancelPrompt";
+        }
+        impl chromiumoxide_types::Method for CancelPromptParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CancelPromptParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Cancel a prompt in response to a DeviceAccess.deviceRequestPrompted event.\n[cancelPrompt](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#method-cancelPrompt)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CancelPromptReturns {}
+        impl chromiumoxide_types::Command for CancelPromptParams {
+            type Response = CancelPromptReturns;
+        }
+        #[doc = "A device request opened a user prompt to select a device. Respond with the\nselectPrompt or cancelPrompt command.\n[deviceRequestPrompted](https://chromedevtools.github.io/devtools-protocol/tot/DeviceAccess/#event-deviceRequestPrompted)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDeviceRequestPrompted {
+            #[serde(rename = "id")]
+            pub id: RequestId,
+            #[serde(rename = "devices")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub devices: Vec<PromptDevice>,
+        }
+        impl EventDeviceRequestPrompted {
+            pub const IDENTIFIER: &'static str = "DeviceAccess.deviceRequestPrompted";
+        }
+        impl chromiumoxide_types::Method for EventDeviceRequestPrompted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDeviceRequestPrompted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod device_orientation {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Clears the overridden Device Orientation.\n[clearDeviceOrientationOverride](https://chromedevtools.github.io/devtools-protocol/tot/DeviceOrientation/#method-clearDeviceOrientationOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearDeviceOrientationOverrideParams {}
+        impl ClearDeviceOrientationOverrideParams {
+            pub const IDENTIFIER: &'static str = "DeviceOrientation.clearDeviceOrientationOverride";
+        }
+        impl chromiumoxide_types::Method for ClearDeviceOrientationOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearDeviceOrientationOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears the overridden Device Orientation.\n[clearDeviceOrientationOverride](https://chromedevtools.github.io/devtools-protocol/tot/DeviceOrientation/#method-clearDeviceOrientationOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearDeviceOrientationOverrideReturns {}
+        impl chromiumoxide_types::Command for ClearDeviceOrientationOverrideParams {
+            type Response = ClearDeviceOrientationOverrideReturns;
+        }
+        #[doc = "Overrides the Device Orientation.\n[setDeviceOrientationOverride](https://chromedevtools.github.io/devtools-protocol/tot/DeviceOrientation/#method-setDeviceOrientationOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDeviceOrientationOverrideParams {
+            #[doc = "Mock alpha"]
+            #[serde(rename = "alpha")]
+            pub alpha: f64,
+            #[doc = "Mock beta"]
+            #[serde(rename = "beta")]
+            pub beta: f64,
+            #[doc = "Mock gamma"]
+            #[serde(rename = "gamma")]
+            pub gamma: f64,
+        }
+        impl SetDeviceOrientationOverrideParams {
+            pub fn new(alpha: impl Into<f64>, beta: impl Into<f64>, gamma: impl Into<f64>) -> Self {
+                Self {
+                    alpha: alpha.into(),
+                    beta: beta.into(),
+                    gamma: gamma.into(),
+                }
+            }
+        }
+        impl SetDeviceOrientationOverrideParams {
+            pub fn builder() -> SetDeviceOrientationOverrideParamsBuilder {
+                SetDeviceOrientationOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDeviceOrientationOverrideParamsBuilder {
+            alpha: Option<f64>,
+            beta: Option<f64>,
+            gamma: Option<f64>,
+        }
+        impl SetDeviceOrientationOverrideParamsBuilder {
+            pub fn alpha(mut self, alpha: impl Into<f64>) -> Self {
+                self.alpha = Some(alpha.into());
+                self
+            }
+            pub fn beta(mut self, beta: impl Into<f64>) -> Self {
+                self.beta = Some(beta.into());
+                self
+            }
+            pub fn gamma(mut self, gamma: impl Into<f64>) -> Self {
+                self.gamma = Some(gamma.into());
+                self
+            }
+            pub fn build(self) -> Result<SetDeviceOrientationOverrideParams, String> {
+                Ok(SetDeviceOrientationOverrideParams {
+                    alpha: self.alpha.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(alpha))
+                    })?,
+                    beta: self.beta.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(beta))
+                    })?,
+                    gamma: self.gamma.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(gamma))
+                    })?,
+                })
+            }
+        }
+        impl SetDeviceOrientationOverrideParams {
+            pub const IDENTIFIER: &'static str = "DeviceOrientation.setDeviceOrientationOverride";
+        }
+        impl chromiumoxide_types::Method for SetDeviceOrientationOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDeviceOrientationOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Overrides the Device Orientation.\n[setDeviceOrientationOverride](https://chromedevtools.github.io/devtools-protocol/tot/DeviceOrientation/#method-setDeviceOrientationOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDeviceOrientationOverrideReturns {}
+        impl chromiumoxide_types::Command for SetDeviceOrientationOverrideParams {
+            type Response = SetDeviceOrientationOverrideReturns;
+        }
+    }
+    #[doc = "This domain emulates different environments for the page."]
+    pub mod emulation {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SafeAreaInsets {
+            #[doc = "Overrides safe-area-inset-top."]
+            #[serde(rename = "top")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub top: Option<i64>,
+            #[doc = "Overrides safe-area-max-inset-top."]
+            #[serde(rename = "topMax")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub top_max: Option<i64>,
+            #[doc = "Overrides safe-area-inset-left."]
+            #[serde(rename = "left")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub left: Option<i64>,
+            #[doc = "Overrides safe-area-max-inset-left."]
+            #[serde(rename = "leftMax")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub left_max: Option<i64>,
+            #[doc = "Overrides safe-area-inset-bottom."]
+            #[serde(rename = "bottom")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub bottom: Option<i64>,
+            #[doc = "Overrides safe-area-max-inset-bottom."]
+            #[serde(rename = "bottomMax")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub bottom_max: Option<i64>,
+            #[doc = "Overrides safe-area-inset-right."]
+            #[serde(rename = "right")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub right: Option<i64>,
+            #[doc = "Overrides safe-area-max-inset-right."]
+            #[serde(rename = "rightMax")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub right_max: Option<i64>,
+        }
+        impl SafeAreaInsets {
+            pub fn builder() -> SafeAreaInsetsBuilder {
+                SafeAreaInsetsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SafeAreaInsetsBuilder {
+            top: Option<i64>,
+            top_max: Option<i64>,
+            left: Option<i64>,
+            left_max: Option<i64>,
+            bottom: Option<i64>,
+            bottom_max: Option<i64>,
+            right: Option<i64>,
+            right_max: Option<i64>,
+        }
+        impl SafeAreaInsetsBuilder {
+            pub fn top(mut self, top: impl Into<i64>) -> Self {
+                self.top = Some(top.into());
+                self
+            }
+            pub fn top_max(mut self, top_max: impl Into<i64>) -> Self {
+                self.top_max = Some(top_max.into());
+                self
+            }
+            pub fn left(mut self, left: impl Into<i64>) -> Self {
+                self.left = Some(left.into());
+                self
+            }
+            pub fn left_max(mut self, left_max: impl Into<i64>) -> Self {
+                self.left_max = Some(left_max.into());
+                self
+            }
+            pub fn bottom(mut self, bottom: impl Into<i64>) -> Self {
+                self.bottom = Some(bottom.into());
+                self
+            }
+            pub fn bottom_max(mut self, bottom_max: impl Into<i64>) -> Self {
+                self.bottom_max = Some(bottom_max.into());
+                self
+            }
+            pub fn right(mut self, right: impl Into<i64>) -> Self {
+                self.right = Some(right.into());
+                self
+            }
+            pub fn right_max(mut self, right_max: impl Into<i64>) -> Self {
+                self.right_max = Some(right_max.into());
+                self
+            }
+            pub fn build(self) -> SafeAreaInsets {
+                SafeAreaInsets {
+                    top: self.top,
+                    top_max: self.top_max,
+                    left: self.left,
+                    left_max: self.left_max,
+                    bottom: self.bottom,
+                    bottom_max: self.bottom_max,
+                    right: self.right,
+                    right_max: self.right_max,
+                }
+            }
+        }
+        impl SafeAreaInsets {
+            pub const IDENTIFIER: &'static str = "Emulation.SafeAreaInsets";
+        }
+        #[doc = "Screen orientation.\n[ScreenOrientation](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#type-ScreenOrientation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScreenOrientation {
+            #[doc = "Orientation type."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: ScreenOrientationType,
+            #[doc = "Orientation angle."]
+            #[serde(rename = "angle")]
+            pub angle: i64,
+        }
+        #[doc = "Orientation type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ScreenOrientationType {
+            #[serde(rename = "portraitPrimary")]
+            PortraitPrimary,
+            #[serde(rename = "portraitSecondary")]
+            PortraitSecondary,
+            #[serde(rename = "landscapePrimary")]
+            LandscapePrimary,
+            #[serde(rename = "landscapeSecondary")]
+            LandscapeSecondary,
+        }
+        impl AsRef<str> for ScreenOrientationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ScreenOrientationType::PortraitPrimary => "portraitPrimary",
+                    ScreenOrientationType::PortraitSecondary => "portraitSecondary",
+                    ScreenOrientationType::LandscapePrimary => "landscapePrimary",
+                    ScreenOrientationType::LandscapeSecondary => "landscapeSecondary",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ScreenOrientationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "portraitPrimary" | "PortraitPrimary" | "portraitprimary" => {
+                        Ok(ScreenOrientationType::PortraitPrimary)
+                    }
+                    "portraitSecondary" | "PortraitSecondary" | "portraitsecondary" => {
+                        Ok(ScreenOrientationType::PortraitSecondary)
+                    }
+                    "landscapePrimary" | "LandscapePrimary" | "landscapeprimary" => {
+                        Ok(ScreenOrientationType::LandscapePrimary)
+                    }
+                    "landscapeSecondary" | "LandscapeSecondary" | "landscapesecondary" => {
+                        Ok(ScreenOrientationType::LandscapeSecondary)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl ScreenOrientation {
+            pub fn new(r#type: impl Into<ScreenOrientationType>, angle: impl Into<i64>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    angle: angle.into(),
+                }
+            }
+        }
+        impl ScreenOrientation {
+            pub fn builder() -> ScreenOrientationBuilder {
+                ScreenOrientationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScreenOrientationBuilder {
+            r#type: Option<ScreenOrientationType>,
+            angle: Option<i64>,
+        }
+        impl ScreenOrientationBuilder {
+            pub fn r#type(mut self, r#type: impl Into<ScreenOrientationType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn angle(mut self, angle: impl Into<i64>) -> Self {
+                self.angle = Some(angle.into());
+                self
+            }
+            pub fn build(self) -> Result<ScreenOrientation, String> {
+                Ok(ScreenOrientation {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    angle: self.angle.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(angle))
+                    })?,
+                })
+            }
+        }
+        impl ScreenOrientation {
+            pub const IDENTIFIER: &'static str = "Emulation.ScreenOrientation";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DisplayFeature {
+            #[doc = "Orientation of a display feature in relation to screen"]
+            #[serde(rename = "orientation")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub orientation: DisplayFeatureOrientation,
+            #[doc = "The offset from the screen origin in either the x (for vertical\norientation) or y (for horizontal orientation) direction."]
+            #[serde(rename = "offset")]
+            pub offset: i64,
+            #[doc = "A display feature may mask content such that it is not physically\ndisplayed - this length along with the offset describes this area.\nA display feature that only splits content will have a 0 mask_length."]
+            #[serde(rename = "maskLength")]
+            pub mask_length: i64,
+        }
+        #[doc = "Orientation of a display feature in relation to screen"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DisplayFeatureOrientation {
+            #[serde(rename = "vertical")]
+            Vertical,
+            #[serde(rename = "horizontal")]
+            Horizontal,
+        }
+        impl AsRef<str> for DisplayFeatureOrientation {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DisplayFeatureOrientation::Vertical => "vertical",
+                    DisplayFeatureOrientation::Horizontal => "horizontal",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DisplayFeatureOrientation {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "vertical" | "Vertical" => Ok(DisplayFeatureOrientation::Vertical),
+                    "horizontal" | "Horizontal" => Ok(DisplayFeatureOrientation::Horizontal),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl DisplayFeature {
+            pub fn new(
+                orientation: impl Into<DisplayFeatureOrientation>,
+                offset: impl Into<i64>,
+                mask_length: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    orientation: orientation.into(),
+                    offset: offset.into(),
+                    mask_length: mask_length.into(),
+                }
+            }
+        }
+        impl DisplayFeature {
+            pub fn builder() -> DisplayFeatureBuilder {
+                DisplayFeatureBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DisplayFeatureBuilder {
+            orientation: Option<DisplayFeatureOrientation>,
+            offset: Option<i64>,
+            mask_length: Option<i64>,
+        }
+        impl DisplayFeatureBuilder {
+            pub fn orientation(
+                mut self,
+                orientation: impl Into<DisplayFeatureOrientation>,
+            ) -> Self {
+                self.orientation = Some(orientation.into());
+                self
+            }
+            pub fn offset(mut self, offset: impl Into<i64>) -> Self {
+                self.offset = Some(offset.into());
+                self
+            }
+            pub fn mask_length(mut self, mask_length: impl Into<i64>) -> Self {
+                self.mask_length = Some(mask_length.into());
+                self
+            }
+            pub fn build(self) -> Result<DisplayFeature, String> {
+                Ok(DisplayFeature {
+                    orientation: self.orientation.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(orientation))
+                    })?,
+                    offset: self.offset.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(offset))
+                    })?,
+                    mask_length: self.mask_length.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mask_length))
+                    })?,
+                })
+            }
+        }
+        impl DisplayFeature {
+            pub const IDENTIFIER: &'static str = "Emulation.DisplayFeature";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DevicePosture {
+            #[doc = "Current posture of the device"]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DevicePostureType,
+        }
+        #[doc = "Current posture of the device"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DevicePostureType {
+            #[serde(rename = "continuous")]
+            Continuous,
+            #[serde(rename = "folded")]
+            Folded,
+        }
+        impl AsRef<str> for DevicePostureType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DevicePostureType::Continuous => "continuous",
+                    DevicePostureType::Folded => "folded",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DevicePostureType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "continuous" | "Continuous" => Ok(DevicePostureType::Continuous),
+                    "folded" | "Folded" => Ok(DevicePostureType::Folded),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl DevicePosture {
+            pub fn new(r#type: impl Into<DevicePostureType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                }
+            }
+        }
+        impl DevicePosture {
+            pub fn builder() -> DevicePostureBuilder {
+                DevicePostureBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DevicePostureBuilder {
+            r#type: Option<DevicePostureType>,
+        }
+        impl DevicePostureBuilder {
+            pub fn r#type(mut self, r#type: impl Into<DevicePostureType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<DevicePosture, String> {
+                Ok(DevicePosture {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                })
+            }
+        }
+        impl DevicePosture {
+            pub const IDENTIFIER: &'static str = "Emulation.DevicePosture";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct MediaFeature {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl MediaFeature {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl MediaFeature {
+            pub fn builder() -> MediaFeatureBuilder {
+                MediaFeatureBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct MediaFeatureBuilder {
+            name: Option<String>,
+            value: Option<String>,
+        }
+        impl MediaFeatureBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<MediaFeature, String> {
+                Ok(MediaFeature {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl MediaFeature {
+            pub const IDENTIFIER: &'static str = "Emulation.MediaFeature";
+        }
+        #[doc = "advance: If the scheduler runs out of immediate work, the virtual time base may fast forward to\nallow the next delayed task (if any) to run; pause: The virtual time base may not advance;\npauseIfNetworkFetchesPending: The virtual time base may not advance if there are any pending\nresource fetches."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum VirtualTimePolicy {
+            #[serde(rename = "advance")]
+            Advance,
+            #[serde(rename = "pause")]
+            Pause,
+            #[serde(rename = "pauseIfNetworkFetchesPending")]
+            PauseIfNetworkFetchesPending,
+        }
+        impl AsRef<str> for VirtualTimePolicy {
+            fn as_ref(&self) -> &str {
+                match self {
+                    VirtualTimePolicy::Advance => "advance",
+                    VirtualTimePolicy::Pause => "pause",
+                    VirtualTimePolicy::PauseIfNetworkFetchesPending => {
+                        "pauseIfNetworkFetchesPending"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for VirtualTimePolicy {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "advance" | "Advance" => Ok(VirtualTimePolicy::Advance),
+                    "pause" | "Pause" => Ok(VirtualTimePolicy::Pause),
+                    "pauseIfNetworkFetchesPending"
+                    | "PauseIfNetworkFetchesPending"
+                    | "pauseifnetworkfetchespending" => {
+                        Ok(VirtualTimePolicy::PauseIfNetworkFetchesPending)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Used to specify User Agent Client Hints to emulate. See https://wicg.github.io/ua-client-hints\n[UserAgentBrandVersion](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#type-UserAgentBrandVersion)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UserAgentBrandVersion {
+            #[serde(rename = "brand")]
+            pub brand: String,
+            #[serde(rename = "version")]
+            pub version: String,
+        }
+        impl UserAgentBrandVersion {
+            pub fn new(brand: impl Into<String>, version: impl Into<String>) -> Self {
+                Self {
+                    brand: brand.into(),
+                    version: version.into(),
+                }
+            }
+        }
+        impl UserAgentBrandVersion {
+            pub fn builder() -> UserAgentBrandVersionBuilder {
+                UserAgentBrandVersionBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UserAgentBrandVersionBuilder {
+            brand: Option<String>,
+            version: Option<String>,
+        }
+        impl UserAgentBrandVersionBuilder {
+            pub fn brand(mut self, brand: impl Into<String>) -> Self {
+                self.brand = Some(brand.into());
+                self
+            }
+            pub fn version(mut self, version: impl Into<String>) -> Self {
+                self.version = Some(version.into());
+                self
+            }
+            pub fn build(self) -> Result<UserAgentBrandVersion, String> {
+                Ok(UserAgentBrandVersion {
+                    brand: self.brand.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(brand))
+                    })?,
+                    version: self.version.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(version))
+                    })?,
+                })
+            }
+        }
+        impl UserAgentBrandVersion {
+            pub const IDENTIFIER: &'static str = "Emulation.UserAgentBrandVersion";
+        }
+        #[doc = "Used to specify User Agent Client Hints to emulate. See https://wicg.github.io/ua-client-hints\nMissing optional values will be filled in by the target with what it would normally use.\n[UserAgentMetadata](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#type-UserAgentMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UserAgentMetadata {
+            #[doc = "Brands appearing in Sec-CH-UA."]
+            #[serde(rename = "brands")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub brands: Option<Vec<UserAgentBrandVersion>>,
+            #[doc = "Brands appearing in Sec-CH-UA-Full-Version-List."]
+            #[serde(rename = "fullVersionList")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub full_version_list: Option<Vec<UserAgentBrandVersion>>,
+            #[serde(rename = "platform")]
+            pub platform: String,
+            #[serde(rename = "platformVersion")]
+            pub platform_version: String,
+            #[serde(rename = "architecture")]
+            pub architecture: String,
+            #[serde(rename = "model")]
+            pub model: String,
+            #[serde(rename = "mobile")]
+            pub mobile: bool,
+            #[serde(rename = "bitness")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub bitness: Option<String>,
+            #[serde(rename = "wow64")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub wow64: Option<bool>,
+            #[doc = "Used to specify User Agent form-factor values.\nSee https://wicg.github.io/ua-client-hints/#sec-ch-ua-form-factors"]
+            #[serde(rename = "formFactors")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub form_factors: Option<Vec<String>>,
+        }
+        impl UserAgentMetadata {
+            pub fn builder() -> UserAgentMetadataBuilder {
+                UserAgentMetadataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UserAgentMetadataBuilder {
+            brands: Option<Vec<UserAgentBrandVersion>>,
+            full_version_list: Option<Vec<UserAgentBrandVersion>>,
+            platform: Option<String>,
+            platform_version: Option<String>,
+            architecture: Option<String>,
+            model: Option<String>,
+            mobile: Option<bool>,
+            bitness: Option<String>,
+            wow64: Option<bool>,
+            form_factors: Option<Vec<String>>,
+        }
+        impl UserAgentMetadataBuilder {
+            pub fn brand(mut self, brand: impl Into<UserAgentBrandVersion>) -> Self {
+                let v = self.brands.get_or_insert(Vec::new());
+                v.push(brand.into());
+                self
+            }
+            pub fn brands<I, S>(mut self, brands: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<UserAgentBrandVersion>,
+            {
+                let v = self.brands.get_or_insert(Vec::new());
+                for val in brands {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn full_version_list(
+                mut self,
+                full_version_list: impl Into<UserAgentBrandVersion>,
+            ) -> Self {
+                let v = self.full_version_list.get_or_insert(Vec::new());
+                v.push(full_version_list.into());
+                self
+            }
+            pub fn full_version_lists<I, S>(mut self, full_version_lists: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<UserAgentBrandVersion>,
+            {
+                let v = self.full_version_list.get_or_insert(Vec::new());
+                for val in full_version_lists {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn platform(mut self, platform: impl Into<String>) -> Self {
+                self.platform = Some(platform.into());
+                self
+            }
+            pub fn platform_version(mut self, platform_version: impl Into<String>) -> Self {
+                self.platform_version = Some(platform_version.into());
+                self
+            }
+            pub fn architecture(mut self, architecture: impl Into<String>) -> Self {
+                self.architecture = Some(architecture.into());
+                self
+            }
+            pub fn model(mut self, model: impl Into<String>) -> Self {
+                self.model = Some(model.into());
+                self
+            }
+            pub fn mobile(mut self, mobile: impl Into<bool>) -> Self {
+                self.mobile = Some(mobile.into());
+                self
+            }
+            pub fn bitness(mut self, bitness: impl Into<String>) -> Self {
+                self.bitness = Some(bitness.into());
+                self
+            }
+            pub fn wow64(mut self, wow64: impl Into<bool>) -> Self {
+                self.wow64 = Some(wow64.into());
+                self
+            }
+            pub fn form_factor(mut self, form_factor: impl Into<String>) -> Self {
+                let v = self.form_factors.get_or_insert(Vec::new());
+                v.push(form_factor.into());
+                self
+            }
+            pub fn form_factors<I, S>(mut self, form_factors: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.form_factors.get_or_insert(Vec::new());
+                for val in form_factors {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<UserAgentMetadata, String> {
+                Ok(UserAgentMetadata {
+                    brands: self.brands,
+                    full_version_list: self.full_version_list,
+                    platform: self.platform.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(platform))
+                    })?,
+                    platform_version: self.platform_version.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(platform_version)
+                        )
+                    })?,
+                    architecture: self.architecture.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(architecture))
+                    })?,
+                    model: self.model.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(model))
+                    })?,
+                    mobile: self.mobile.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mobile))
+                    })?,
+                    bitness: self.bitness,
+                    wow64: self.wow64,
+                    form_factors: self.form_factors,
+                })
+            }
+        }
+        impl UserAgentMetadata {
+            pub const IDENTIFIER: &'static str = "Emulation.UserAgentMetadata";
+        }
+        #[doc = "Used to specify sensor types to emulate.\nSee https://w3c.github.io/sensors/#automation for more information."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SensorType {
+            #[serde(rename = "absolute-orientation")]
+            AbsoluteOrientation,
+            #[serde(rename = "accelerometer")]
+            Accelerometer,
+            #[serde(rename = "ambient-light")]
+            AmbientLight,
+            #[serde(rename = "gravity")]
+            Gravity,
+            #[serde(rename = "gyroscope")]
+            Gyroscope,
+            #[serde(rename = "linear-acceleration")]
+            LinearAcceleration,
+            #[serde(rename = "magnetometer")]
+            Magnetometer,
+            #[serde(rename = "relative-orientation")]
+            RelativeOrientation,
+        }
+        impl AsRef<str> for SensorType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SensorType::AbsoluteOrientation => "absolute-orientation",
+                    SensorType::Accelerometer => "accelerometer",
+                    SensorType::AmbientLight => "ambient-light",
+                    SensorType::Gravity => "gravity",
+                    SensorType::Gyroscope => "gyroscope",
+                    SensorType::LinearAcceleration => "linear-acceleration",
+                    SensorType::Magnetometer => "magnetometer",
+                    SensorType::RelativeOrientation => "relative-orientation",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SensorType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "absolute-orientation" | "AbsoluteOrientation" => {
+                        Ok(SensorType::AbsoluteOrientation)
+                    }
+                    "accelerometer" | "Accelerometer" => Ok(SensorType::Accelerometer),
+                    "ambient-light" | "AmbientLight" => Ok(SensorType::AmbientLight),
+                    "gravity" | "Gravity" => Ok(SensorType::Gravity),
+                    "gyroscope" | "Gyroscope" => Ok(SensorType::Gyroscope),
+                    "linear-acceleration" | "LinearAcceleration" => {
+                        Ok(SensorType::LinearAcceleration)
+                    }
+                    "magnetometer" | "Magnetometer" => Ok(SensorType::Magnetometer),
+                    "relative-orientation" | "RelativeOrientation" => {
+                        Ok(SensorType::RelativeOrientation)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SensorMetadata {
+            #[serde(rename = "available")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub available: Option<bool>,
+            #[serde(rename = "minimumFrequency")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub minimum_frequency: Option<f64>,
+            #[serde(rename = "maximumFrequency")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub maximum_frequency: Option<f64>,
+        }
+        impl SensorMetadata {
+            pub fn builder() -> SensorMetadataBuilder {
+                SensorMetadataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SensorMetadataBuilder {
+            available: Option<bool>,
+            minimum_frequency: Option<f64>,
+            maximum_frequency: Option<f64>,
+        }
+        impl SensorMetadataBuilder {
+            pub fn available(mut self, available: impl Into<bool>) -> Self {
+                self.available = Some(available.into());
+                self
+            }
+            pub fn minimum_frequency(mut self, minimum_frequency: impl Into<f64>) -> Self {
+                self.minimum_frequency = Some(minimum_frequency.into());
+                self
+            }
+            pub fn maximum_frequency(mut self, maximum_frequency: impl Into<f64>) -> Self {
+                self.maximum_frequency = Some(maximum_frequency.into());
+                self
+            }
+            pub fn build(self) -> SensorMetadata {
+                SensorMetadata {
+                    available: self.available,
+                    minimum_frequency: self.minimum_frequency,
+                    maximum_frequency: self.maximum_frequency,
+                }
+            }
+        }
+        impl SensorMetadata {
+            pub const IDENTIFIER: &'static str = "Emulation.SensorMetadata";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SensorReadingSingle {
+            #[serde(rename = "value")]
+            pub value: f64,
+        }
+        impl SensorReadingSingle {
+            pub fn new(value: impl Into<f64>) -> Self {
+                Self {
+                    value: value.into(),
+                }
+            }
+        }
+        impl SensorReadingSingle {
+            pub fn builder() -> SensorReadingSingleBuilder {
+                SensorReadingSingleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SensorReadingSingleBuilder {
+            value: Option<f64>,
+        }
+        impl SensorReadingSingleBuilder {
+            pub fn value(mut self, value: impl Into<f64>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<SensorReadingSingle, String> {
+                Ok(SensorReadingSingle {
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl SensorReadingSingle {
+            pub const IDENTIFIER: &'static str = "Emulation.SensorReadingSingle";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SensorReadingXyz {
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[serde(rename = "z")]
+            pub z: f64,
+        }
+        impl SensorReadingXyz {
+            pub fn new(x: impl Into<f64>, y: impl Into<f64>, z: impl Into<f64>) -> Self {
+                Self {
+                    x: x.into(),
+                    y: y.into(),
+                    z: z.into(),
+                }
+            }
+        }
+        impl SensorReadingXyz {
+            pub fn builder() -> SensorReadingXyzBuilder {
+                SensorReadingXyzBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SensorReadingXyzBuilder {
+            x: Option<f64>,
+            y: Option<f64>,
+            z: Option<f64>,
+        }
+        impl SensorReadingXyzBuilder {
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn z(mut self, z: impl Into<f64>) -> Self {
+                self.z = Some(z.into());
+                self
+            }
+            pub fn build(self) -> Result<SensorReadingXyz, String> {
+                Ok(SensorReadingXyz {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    z: self
+                        .z
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(z)))?,
+                })
+            }
+        }
+        impl SensorReadingXyz {
+            pub const IDENTIFIER: &'static str = "Emulation.SensorReadingXYZ";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SensorReadingQuaternion {
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[serde(rename = "z")]
+            pub z: f64,
+            #[serde(rename = "w")]
+            pub w: f64,
+        }
+        impl SensorReadingQuaternion {
+            pub fn new(
+                x: impl Into<f64>,
+                y: impl Into<f64>,
+                z: impl Into<f64>,
+                w: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    x: x.into(),
+                    y: y.into(),
+                    z: z.into(),
+                    w: w.into(),
+                }
+            }
+        }
+        impl SensorReadingQuaternion {
+            pub fn builder() -> SensorReadingQuaternionBuilder {
+                SensorReadingQuaternionBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SensorReadingQuaternionBuilder {
+            x: Option<f64>,
+            y: Option<f64>,
+            z: Option<f64>,
+            w: Option<f64>,
+        }
+        impl SensorReadingQuaternionBuilder {
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn z(mut self, z: impl Into<f64>) -> Self {
+                self.z = Some(z.into());
+                self
+            }
+            pub fn w(mut self, w: impl Into<f64>) -> Self {
+                self.w = Some(w.into());
+                self
+            }
+            pub fn build(self) -> Result<SensorReadingQuaternion, String> {
+                Ok(SensorReadingQuaternion {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    z: self
+                        .z
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(z)))?,
+                    w: self
+                        .w
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(w)))?,
+                })
+            }
+        }
+        impl SensorReadingQuaternion {
+            pub const IDENTIFIER: &'static str = "Emulation.SensorReadingQuaternion";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SensorReading {
+            #[serde(rename = "single")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub single: Option<SensorReadingSingle>,
+            #[serde(rename = "xyz")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub xyz: Option<SensorReadingXyz>,
+            #[serde(rename = "quaternion")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub quaternion: Option<SensorReadingQuaternion>,
+        }
+        impl SensorReading {
+            pub fn builder() -> SensorReadingBuilder {
+                SensorReadingBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SensorReadingBuilder {
+            single: Option<SensorReadingSingle>,
+            xyz: Option<SensorReadingXyz>,
+            quaternion: Option<SensorReadingQuaternion>,
+        }
+        impl SensorReadingBuilder {
+            pub fn single(mut self, single: impl Into<SensorReadingSingle>) -> Self {
+                self.single = Some(single.into());
+                self
+            }
+            pub fn xyz(mut self, xyz: impl Into<SensorReadingXyz>) -> Self {
+                self.xyz = Some(xyz.into());
+                self
+            }
+            pub fn quaternion(mut self, quaternion: impl Into<SensorReadingQuaternion>) -> Self {
+                self.quaternion = Some(quaternion.into());
+                self
+            }
+            pub fn build(self) -> SensorReading {
+                SensorReading {
+                    single: self.single,
+                    xyz: self.xyz,
+                    quaternion: self.quaternion,
+                }
+            }
+        }
+        impl SensorReading {
+            pub const IDENTIFIER: &'static str = "Emulation.SensorReading";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PressureSource {
+            #[serde(rename = "cpu")]
+            Cpu,
+        }
+        impl AsRef<str> for PressureSource {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PressureSource::Cpu => "cpu",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PressureSource {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "cpu" | "Cpu" => Ok(PressureSource::Cpu),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PressureState {
+            #[serde(rename = "nominal")]
+            Nominal,
+            #[serde(rename = "fair")]
+            Fair,
+            #[serde(rename = "serious")]
+            Serious,
+            #[serde(rename = "critical")]
+            Critical,
+        }
+        impl AsRef<str> for PressureState {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PressureState::Nominal => "nominal",
+                    PressureState::Fair => "fair",
+                    PressureState::Serious => "serious",
+                    PressureState::Critical => "critical",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PressureState {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "nominal" | "Nominal" => Ok(PressureState::Nominal),
+                    "fair" | "Fair" => Ok(PressureState::Fair),
+                    "serious" | "Serious" => Ok(PressureState::Serious),
+                    "critical" | "Critical" => Ok(PressureState::Critical),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct PressureMetadata {
+            #[serde(rename = "available")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub available: Option<bool>,
+        }
+        impl PressureMetadata {
+            pub fn builder() -> PressureMetadataBuilder {
+                PressureMetadataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PressureMetadataBuilder {
+            available: Option<bool>,
+        }
+        impl PressureMetadataBuilder {
+            pub fn available(mut self, available: impl Into<bool>) -> Self {
+                self.available = Some(available.into());
+                self
+            }
+            pub fn build(self) -> PressureMetadata {
+                PressureMetadata {
+                    available: self.available,
+                }
+            }
+        }
+        impl PressureMetadata {
+            pub const IDENTIFIER: &'static str = "Emulation.PressureMetadata";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct WorkAreaInsets {
+            #[doc = "Work area top inset in pixels. Default is 0;"]
+            #[serde(rename = "top")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub top: Option<i64>,
+            #[doc = "Work area left inset in pixels. Default is 0;"]
+            #[serde(rename = "left")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub left: Option<i64>,
+            #[doc = "Work area bottom inset in pixels. Default is 0;"]
+            #[serde(rename = "bottom")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub bottom: Option<i64>,
+            #[doc = "Work area right inset in pixels. Default is 0;"]
+            #[serde(rename = "right")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub right: Option<i64>,
+        }
+        impl WorkAreaInsets {
+            pub fn builder() -> WorkAreaInsetsBuilder {
+                WorkAreaInsetsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct WorkAreaInsetsBuilder {
+            top: Option<i64>,
+            left: Option<i64>,
+            bottom: Option<i64>,
+            right: Option<i64>,
+        }
+        impl WorkAreaInsetsBuilder {
+            pub fn top(mut self, top: impl Into<i64>) -> Self {
+                self.top = Some(top.into());
+                self
+            }
+            pub fn left(mut self, left: impl Into<i64>) -> Self {
+                self.left = Some(left.into());
+                self
+            }
+            pub fn bottom(mut self, bottom: impl Into<i64>) -> Self {
+                self.bottom = Some(bottom.into());
+                self
+            }
+            pub fn right(mut self, right: impl Into<i64>) -> Self {
+                self.right = Some(right.into());
+                self
+            }
+            pub fn build(self) -> WorkAreaInsets {
+                WorkAreaInsets {
+                    top: self.top,
+                    left: self.left,
+                    bottom: self.bottom,
+                    right: self.right,
+                }
+            }
+        }
+        impl WorkAreaInsets {
+            pub const IDENTIFIER: &'static str = "Emulation.WorkAreaInsets";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct ScreenId(String);
+        impl ScreenId {
+            pub fn new(val: impl Into<String>) -> Self {
+                ScreenId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for ScreenId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<ScreenId> for String {
+            fn from(el: ScreenId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for ScreenId {
+            fn from(expr: String) -> Self {
+                ScreenId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for ScreenId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl ScreenId {
+            pub const IDENTIFIER: &'static str = "Emulation.ScreenId";
+        }
+        #[doc = "Screen information similar to the one returned by window.getScreenDetails() method,\nsee https://w3c.github.io/window-management/#screendetailed.\n[ScreenInfo](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#type-ScreenInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScreenInfo {
+            #[doc = "Offset of the left edge of the screen."]
+            #[serde(rename = "left")]
+            pub left: i64,
+            #[doc = "Offset of the top edge of the screen."]
+            #[serde(rename = "top")]
+            pub top: i64,
+            #[doc = "Width of the screen."]
+            #[serde(rename = "width")]
+            pub width: i64,
+            #[doc = "Height of the screen."]
+            #[serde(rename = "height")]
+            pub height: i64,
+            #[doc = "Offset of the left edge of the available screen area."]
+            #[serde(rename = "availLeft")]
+            pub avail_left: i64,
+            #[doc = "Offset of the top edge of the available screen area."]
+            #[serde(rename = "availTop")]
+            pub avail_top: i64,
+            #[doc = "Width of the available screen area."]
+            #[serde(rename = "availWidth")]
+            pub avail_width: i64,
+            #[doc = "Height of the available screen area."]
+            #[serde(rename = "availHeight")]
+            pub avail_height: i64,
+            #[doc = "Specifies the screen's device pixel ratio."]
+            #[serde(rename = "devicePixelRatio")]
+            pub device_pixel_ratio: f64,
+            #[doc = "Specifies the screen's orientation."]
+            #[serde(rename = "orientation")]
+            pub orientation: ScreenOrientation,
+            #[doc = "Specifies the screen's color depth in bits."]
+            #[serde(rename = "colorDepth")]
+            pub color_depth: i64,
+            #[doc = "Indicates whether the device has multiple screens."]
+            #[serde(rename = "isExtended")]
+            pub is_extended: bool,
+            #[doc = "Indicates whether the screen is internal to the device or external, attached to the device."]
+            #[serde(rename = "isInternal")]
+            pub is_internal: bool,
+            #[doc = "Indicates whether the screen is set as the the operating system primary screen."]
+            #[serde(rename = "isPrimary")]
+            pub is_primary: bool,
+            #[doc = "Specifies the descriptive label for the screen."]
+            #[serde(rename = "label")]
+            pub label: String,
+            #[doc = "Specifies the unique identifier of the screen."]
+            #[serde(rename = "id")]
+            pub id: ScreenId,
+        }
+        impl ScreenInfo {
+            pub fn builder() -> ScreenInfoBuilder {
+                ScreenInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScreenInfoBuilder {
+            left: Option<i64>,
+            top: Option<i64>,
+            width: Option<i64>,
+            height: Option<i64>,
+            avail_left: Option<i64>,
+            avail_top: Option<i64>,
+            avail_width: Option<i64>,
+            avail_height: Option<i64>,
+            device_pixel_ratio: Option<f64>,
+            orientation: Option<ScreenOrientation>,
+            color_depth: Option<i64>,
+            is_extended: Option<bool>,
+            is_internal: Option<bool>,
+            is_primary: Option<bool>,
+            label: Option<String>,
+            id: Option<ScreenId>,
+        }
+        impl ScreenInfoBuilder {
+            pub fn left(mut self, left: impl Into<i64>) -> Self {
+                self.left = Some(left.into());
+                self
+            }
+            pub fn top(mut self, top: impl Into<i64>) -> Self {
+                self.top = Some(top.into());
+                self
+            }
+            pub fn width(mut self, width: impl Into<i64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<i64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn avail_left(mut self, avail_left: impl Into<i64>) -> Self {
+                self.avail_left = Some(avail_left.into());
+                self
+            }
+            pub fn avail_top(mut self, avail_top: impl Into<i64>) -> Self {
+                self.avail_top = Some(avail_top.into());
+                self
+            }
+            pub fn avail_width(mut self, avail_width: impl Into<i64>) -> Self {
+                self.avail_width = Some(avail_width.into());
+                self
+            }
+            pub fn avail_height(mut self, avail_height: impl Into<i64>) -> Self {
+                self.avail_height = Some(avail_height.into());
+                self
+            }
+            pub fn device_pixel_ratio(mut self, device_pixel_ratio: impl Into<f64>) -> Self {
+                self.device_pixel_ratio = Some(device_pixel_ratio.into());
+                self
+            }
+            pub fn orientation(mut self, orientation: impl Into<ScreenOrientation>) -> Self {
+                self.orientation = Some(orientation.into());
+                self
+            }
+            pub fn color_depth(mut self, color_depth: impl Into<i64>) -> Self {
+                self.color_depth = Some(color_depth.into());
+                self
+            }
+            pub fn is_extended(mut self, is_extended: impl Into<bool>) -> Self {
+                self.is_extended = Some(is_extended.into());
+                self
+            }
+            pub fn is_internal(mut self, is_internal: impl Into<bool>) -> Self {
+                self.is_internal = Some(is_internal.into());
+                self
+            }
+            pub fn is_primary(mut self, is_primary: impl Into<bool>) -> Self {
+                self.is_primary = Some(is_primary.into());
+                self
+            }
+            pub fn label(mut self, label: impl Into<String>) -> Self {
+                self.label = Some(label.into());
+                self
+            }
+            pub fn id(mut self, id: impl Into<ScreenId>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn build(self) -> Result<ScreenInfo, String> {
+                Ok(ScreenInfo {
+                    left: self.left.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(left))
+                    })?,
+                    top: self
+                        .top
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(top)))?,
+                    width: self.width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(width))
+                    })?,
+                    height: self.height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(height))
+                    })?,
+                    avail_left: self.avail_left.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(avail_left))
+                    })?,
+                    avail_top: self.avail_top.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(avail_top))
+                    })?,
+                    avail_width: self.avail_width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(avail_width))
+                    })?,
+                    avail_height: self.avail_height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(avail_height))
+                    })?,
+                    device_pixel_ratio: self.device_pixel_ratio.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(device_pixel_ratio)
+                        )
+                    })?,
+                    orientation: self.orientation.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(orientation))
+                    })?,
+                    color_depth: self.color_depth.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(color_depth))
+                    })?,
+                    is_extended: self.is_extended.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_extended))
+                    })?,
+                    is_internal: self.is_internal.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_internal))
+                    })?,
+                    is_primary: self.is_primary.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_primary))
+                    })?,
+                    label: self.label.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(label))
+                    })?,
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                })
+            }
+        }
+        impl ScreenInfo {
+            pub const IDENTIFIER: &'static str = "Emulation.ScreenInfo";
+        }
+        #[doc = "Enum of image types that can be disabled."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DisabledImageType {
+            #[serde(rename = "avif")]
+            Avif,
+            #[serde(rename = "webp")]
+            Webp,
+        }
+        impl AsRef<str> for DisabledImageType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DisabledImageType::Avif => "avif",
+                    DisabledImageType::Webp => "webp",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DisabledImageType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "avif" | "Avif" => Ok(DisabledImageType::Avif),
+                    "webp" | "Webp" => Ok(DisabledImageType::Webp),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Clears the overridden device metrics.\n[clearDeviceMetricsOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-clearDeviceMetricsOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearDeviceMetricsOverrideParams {}
+        impl ClearDeviceMetricsOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.clearDeviceMetricsOverride";
+        }
+        impl chromiumoxide_types::Method for ClearDeviceMetricsOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearDeviceMetricsOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears the overridden device metrics.\n[clearDeviceMetricsOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-clearDeviceMetricsOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearDeviceMetricsOverrideReturns {}
+        impl chromiumoxide_types::Command for ClearDeviceMetricsOverrideParams {
+            type Response = ClearDeviceMetricsOverrideReturns;
+        }
+        #[doc = "Clears the overridden Geolocation Position and Error.\n[clearGeolocationOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-clearGeolocationOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearGeolocationOverrideParams {}
+        impl ClearGeolocationOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.clearGeolocationOverride";
+        }
+        impl chromiumoxide_types::Method for ClearGeolocationOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearGeolocationOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears the overridden Geolocation Position and Error.\n[clearGeolocationOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-clearGeolocationOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearGeolocationOverrideReturns {}
+        impl chromiumoxide_types::Command for ClearGeolocationOverrideParams {
+            type Response = ClearGeolocationOverrideReturns;
+        }
+        #[doc = "Requests that page scale factor is reset to initial values.\n[resetPageScaleFactor](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-resetPageScaleFactor)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResetPageScaleFactorParams {}
+        impl ResetPageScaleFactorParams {
+            pub const IDENTIFIER: &'static str = "Emulation.resetPageScaleFactor";
+        }
+        impl chromiumoxide_types::Method for ResetPageScaleFactorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ResetPageScaleFactorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests that page scale factor is reset to initial values.\n[resetPageScaleFactor](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-resetPageScaleFactor)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResetPageScaleFactorReturns {}
+        impl chromiumoxide_types::Command for ResetPageScaleFactorParams {
+            type Response = ResetPageScaleFactorReturns;
+        }
+        #[doc = "Enables or disables simulating a focused and active page.\n[setFocusEmulationEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setFocusEmulationEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetFocusEmulationEnabledParams {
+            #[doc = "Whether to enable to disable focus emulation."]
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetFocusEmulationEnabledParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetFocusEmulationEnabledParams {
+            pub fn builder() -> SetFocusEmulationEnabledParamsBuilder {
+                SetFocusEmulationEnabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetFocusEmulationEnabledParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetFocusEmulationEnabledParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetFocusEmulationEnabledParams, String> {
+                Ok(SetFocusEmulationEnabledParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetFocusEmulationEnabledParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setFocusEmulationEnabled";
+        }
+        impl chromiumoxide_types::Method for SetFocusEmulationEnabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetFocusEmulationEnabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables or disables simulating a focused and active page.\n[setFocusEmulationEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setFocusEmulationEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetFocusEmulationEnabledReturns {}
+        impl chromiumoxide_types::Command for SetFocusEmulationEnabledParams {
+            type Response = SetFocusEmulationEnabledReturns;
+        }
+        #[doc = "Automatically render all web contents using a dark theme.\n[setAutoDarkModeOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setAutoDarkModeOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAutoDarkModeOverrideParams {
+            #[doc = "Whether to enable or disable automatic dark mode.\nIf not specified, any existing override will be cleared."]
+            #[serde(rename = "enabled")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub enabled: Option<bool>,
+        }
+        impl SetAutoDarkModeOverrideParams {
+            pub fn builder() -> SetAutoDarkModeOverrideParamsBuilder {
+                SetAutoDarkModeOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAutoDarkModeOverrideParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetAutoDarkModeOverrideParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> SetAutoDarkModeOverrideParams {
+                SetAutoDarkModeOverrideParams {
+                    enabled: self.enabled,
+                }
+            }
+        }
+        impl SetAutoDarkModeOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setAutoDarkModeOverride";
+        }
+        impl chromiumoxide_types::Method for SetAutoDarkModeOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAutoDarkModeOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Automatically render all web contents using a dark theme.\n[setAutoDarkModeOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setAutoDarkModeOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAutoDarkModeOverrideReturns {}
+        impl chromiumoxide_types::Command for SetAutoDarkModeOverrideParams {
+            type Response = SetAutoDarkModeOverrideReturns;
+        }
+        #[doc = "Enables CPU throttling to emulate slow CPUs.\n[setCPUThrottlingRate](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setCPUThrottlingRate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetCpuThrottlingRateParams {
+            #[doc = "Throttling rate as a slowdown factor (1 is no throttle, 2 is 2x slowdown, etc)."]
+            #[serde(rename = "rate")]
+            pub rate: f64,
+        }
+        impl SetCpuThrottlingRateParams {
+            pub fn new(rate: impl Into<f64>) -> Self {
+                Self { rate: rate.into() }
+            }
+        }
+        impl SetCpuThrottlingRateParams {
+            pub fn builder() -> SetCpuThrottlingRateParamsBuilder {
+                SetCpuThrottlingRateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetCpuThrottlingRateParamsBuilder {
+            rate: Option<f64>,
+        }
+        impl SetCpuThrottlingRateParamsBuilder {
+            pub fn rate(mut self, rate: impl Into<f64>) -> Self {
+                self.rate = Some(rate.into());
+                self
+            }
+            pub fn build(self) -> Result<SetCpuThrottlingRateParams, String> {
+                Ok(SetCpuThrottlingRateParams {
+                    rate: self.rate.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rate))
+                    })?,
+                })
+            }
+        }
+        impl SetCpuThrottlingRateParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setCPUThrottlingRate";
+        }
+        impl chromiumoxide_types::Method for SetCpuThrottlingRateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetCpuThrottlingRateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables CPU throttling to emulate slow CPUs.\n[setCPUThrottlingRate](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setCPUThrottlingRate)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetCpuThrottlingRateReturns {}
+        impl chromiumoxide_types::Command for SetCpuThrottlingRateParams {
+            type Response = SetCpuThrottlingRateReturns;
+        }
+        #[doc = "Sets or clears an override of the default background color of the frame. This override is used\nif the content does not specify one.\n[setDefaultBackgroundColorOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setDefaultBackgroundColorOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDefaultBackgroundColorOverrideParams {
+            #[doc = "RGBA of the default background color. If not specified, any existing override will be\ncleared."]
+            #[serde(rename = "color")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub color: Option<super::dom::Rgba>,
+        }
+        impl SetDefaultBackgroundColorOverrideParams {
+            pub fn builder() -> SetDefaultBackgroundColorOverrideParamsBuilder {
+                SetDefaultBackgroundColorOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDefaultBackgroundColorOverrideParamsBuilder {
+            color: Option<super::dom::Rgba>,
+        }
+        impl SetDefaultBackgroundColorOverrideParamsBuilder {
+            pub fn color(mut self, color: impl Into<super::dom::Rgba>) -> Self {
+                self.color = Some(color.into());
+                self
+            }
+            pub fn build(self) -> SetDefaultBackgroundColorOverrideParams {
+                SetDefaultBackgroundColorOverrideParams { color: self.color }
+            }
+        }
+        impl SetDefaultBackgroundColorOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setDefaultBackgroundColorOverride";
+        }
+        impl chromiumoxide_types::Method for SetDefaultBackgroundColorOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDefaultBackgroundColorOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets or clears an override of the default background color of the frame. This override is used\nif the content does not specify one.\n[setDefaultBackgroundColorOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setDefaultBackgroundColorOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDefaultBackgroundColorOverrideReturns {}
+        impl chromiumoxide_types::Command for SetDefaultBackgroundColorOverrideParams {
+            type Response = SetDefaultBackgroundColorOverrideReturns;
+        }
+        #[doc = "Overrides the values for env(safe-area-inset-*) and env(safe-area-max-inset-*). Unset values will cause the\nrespective variables to be undefined, even if previously overridden.\n[setSafeAreaInsetsOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setSafeAreaInsetsOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSafeAreaInsetsOverrideParams {
+            #[serde(rename = "insets")]
+            pub insets: SafeAreaInsets,
+        }
+        impl SetSafeAreaInsetsOverrideParams {
+            pub fn new(insets: impl Into<SafeAreaInsets>) -> Self {
+                Self {
+                    insets: insets.into(),
+                }
+            }
+        }
+        impl SetSafeAreaInsetsOverrideParams {
+            pub fn builder() -> SetSafeAreaInsetsOverrideParamsBuilder {
+                SetSafeAreaInsetsOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSafeAreaInsetsOverrideParamsBuilder {
+            insets: Option<SafeAreaInsets>,
+        }
+        impl SetSafeAreaInsetsOverrideParamsBuilder {
+            pub fn insets(mut self, insets: impl Into<SafeAreaInsets>) -> Self {
+                self.insets = Some(insets.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSafeAreaInsetsOverrideParams, String> {
+                Ok(SetSafeAreaInsetsOverrideParams {
+                    insets: self.insets.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(insets))
+                    })?,
+                })
+            }
+        }
+        impl SetSafeAreaInsetsOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setSafeAreaInsetsOverride";
+        }
+        impl chromiumoxide_types::Method for SetSafeAreaInsetsOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSafeAreaInsetsOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Overrides the values for env(safe-area-inset-*) and env(safe-area-max-inset-*). Unset values will cause the\nrespective variables to be undefined, even if previously overridden.\n[setSafeAreaInsetsOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setSafeAreaInsetsOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSafeAreaInsetsOverrideReturns {}
+        impl chromiumoxide_types::Command for SetSafeAreaInsetsOverrideParams {
+            type Response = SetSafeAreaInsetsOverrideReturns;
+        }
+        #[doc = "Overrides the values of device screen dimensions (window.screen.width, window.screen.height,\nwindow.innerWidth, window.innerHeight, and \"device-width\"/\"device-height\"-related CSS media\nquery results).\n[setDeviceMetricsOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setDeviceMetricsOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDeviceMetricsOverrideParams {
+            #[doc = "Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override."]
+            #[serde(rename = "width")]
+            pub width: i64,
+            #[doc = "Overriding height value in pixels (minimum 0, maximum 10000000). 0 disables the override."]
+            #[serde(rename = "height")]
+            pub height: i64,
+            #[doc = "Overriding device scale factor value. 0 disables the override."]
+            #[serde(rename = "deviceScaleFactor")]
+            pub device_scale_factor: f64,
+            #[doc = "Whether to emulate mobile device. This includes viewport meta tag, overlay scrollbars, text\nautosizing and more."]
+            #[serde(rename = "mobile")]
+            pub mobile: bool,
+            #[doc = "Scale to apply to resulting view image."]
+            #[serde(rename = "scale")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scale: Option<f64>,
+            #[doc = "Overriding screen width value in pixels (minimum 0, maximum 10000000)."]
+            #[serde(rename = "screenWidth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub screen_width: Option<i64>,
+            #[doc = "Overriding screen height value in pixels (minimum 0, maximum 10000000)."]
+            #[serde(rename = "screenHeight")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub screen_height: Option<i64>,
+            #[doc = "Overriding view X position on screen in pixels (minimum 0, maximum 10000000)."]
+            #[serde(rename = "positionX")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub position_x: Option<i64>,
+            #[doc = "Overriding view Y position on screen in pixels (minimum 0, maximum 10000000)."]
+            #[serde(rename = "positionY")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub position_y: Option<i64>,
+            #[doc = "Do not set visible view size, rely upon explicit setVisibleSize call."]
+            #[serde(rename = "dontSetVisibleSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub dont_set_visible_size: Option<bool>,
+            #[doc = "Screen orientation override."]
+            #[serde(rename = "screenOrientation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub screen_orientation: Option<ScreenOrientation>,
+            #[doc = "If set, the visible area of the page will be overridden to this viewport. This viewport\nchange is not observed by the page, e.g. viewport-relative elements do not change positions."]
+            #[serde(rename = "viewport")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub viewport: Option<super::page::Viewport>,
+        }
+        impl SetDeviceMetricsOverrideParams {
+            pub fn new(
+                width: impl Into<i64>,
+                height: impl Into<i64>,
+                device_scale_factor: impl Into<f64>,
+                mobile: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    width: width.into(),
+                    height: height.into(),
+                    device_scale_factor: device_scale_factor.into(),
+                    mobile: mobile.into(),
+                    scale: None,
+                    screen_width: None,
+                    screen_height: None,
+                    position_x: None,
+                    position_y: None,
+                    dont_set_visible_size: None,
+                    screen_orientation: None,
+                    viewport: None,
+                }
+            }
+        }
+        impl SetDeviceMetricsOverrideParams {
+            pub fn builder() -> SetDeviceMetricsOverrideParamsBuilder {
+                SetDeviceMetricsOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDeviceMetricsOverrideParamsBuilder {
+            width: Option<i64>,
+            height: Option<i64>,
+            device_scale_factor: Option<f64>,
+            mobile: Option<bool>,
+            scale: Option<f64>,
+            screen_width: Option<i64>,
+            screen_height: Option<i64>,
+            position_x: Option<i64>,
+            position_y: Option<i64>,
+            dont_set_visible_size: Option<bool>,
+            screen_orientation: Option<ScreenOrientation>,
+            viewport: Option<super::page::Viewport>,
+        }
+        impl SetDeviceMetricsOverrideParamsBuilder {
+            pub fn width(mut self, width: impl Into<i64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<i64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn device_scale_factor(mut self, device_scale_factor: impl Into<f64>) -> Self {
+                self.device_scale_factor = Some(device_scale_factor.into());
+                self
+            }
+            pub fn mobile(mut self, mobile: impl Into<bool>) -> Self {
+                self.mobile = Some(mobile.into());
+                self
+            }
+            pub fn scale(mut self, scale: impl Into<f64>) -> Self {
+                self.scale = Some(scale.into());
+                self
+            }
+            pub fn screen_width(mut self, screen_width: impl Into<i64>) -> Self {
+                self.screen_width = Some(screen_width.into());
+                self
+            }
+            pub fn screen_height(mut self, screen_height: impl Into<i64>) -> Self {
+                self.screen_height = Some(screen_height.into());
+                self
+            }
+            pub fn position_x(mut self, position_x: impl Into<i64>) -> Self {
+                self.position_x = Some(position_x.into());
+                self
+            }
+            pub fn position_y(mut self, position_y: impl Into<i64>) -> Self {
+                self.position_y = Some(position_y.into());
+                self
+            }
+            pub fn dont_set_visible_size(mut self, dont_set_visible_size: impl Into<bool>) -> Self {
+                self.dont_set_visible_size = Some(dont_set_visible_size.into());
+                self
+            }
+            pub fn screen_orientation(
+                mut self,
+                screen_orientation: impl Into<ScreenOrientation>,
+            ) -> Self {
+                self.screen_orientation = Some(screen_orientation.into());
+                self
+            }
+            pub fn viewport(mut self, viewport: impl Into<super::page::Viewport>) -> Self {
+                self.viewport = Some(viewport.into());
+                self
+            }
+            pub fn build(self) -> Result<SetDeviceMetricsOverrideParams, String> {
+                Ok(SetDeviceMetricsOverrideParams {
+                    width: self.width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(width))
+                    })?,
+                    height: self.height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(height))
+                    })?,
+                    device_scale_factor: self.device_scale_factor.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(device_scale_factor)
+                        )
+                    })?,
+                    mobile: self.mobile.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mobile))
+                    })?,
+                    scale: self.scale,
+                    screen_width: self.screen_width,
+                    screen_height: self.screen_height,
+                    position_x: self.position_x,
+                    position_y: self.position_y,
+                    dont_set_visible_size: self.dont_set_visible_size,
+                    screen_orientation: self.screen_orientation,
+                    viewport: self.viewport,
+                })
+            }
+        }
+        impl SetDeviceMetricsOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setDeviceMetricsOverride";
+        }
+        impl chromiumoxide_types::Method for SetDeviceMetricsOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDeviceMetricsOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Overrides the values of device screen dimensions (window.screen.width, window.screen.height,\nwindow.innerWidth, window.innerHeight, and \"device-width\"/\"device-height\"-related CSS media\nquery results).\n[setDeviceMetricsOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setDeviceMetricsOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDeviceMetricsOverrideReturns {}
+        impl chromiumoxide_types::Command for SetDeviceMetricsOverrideParams {
+            type Response = SetDeviceMetricsOverrideReturns;
+        }
+        #[doc = "Start reporting the given posture value to the Device Posture API.\nThis override can also be set in setDeviceMetricsOverride().\n[setDevicePostureOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setDevicePostureOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDevicePostureOverrideParams {
+            #[serde(rename = "posture")]
+            pub posture: DevicePosture,
+        }
+        impl SetDevicePostureOverrideParams {
+            pub fn new(posture: impl Into<DevicePosture>) -> Self {
+                Self {
+                    posture: posture.into(),
+                }
+            }
+        }
+        impl SetDevicePostureOverrideParams {
+            pub fn builder() -> SetDevicePostureOverrideParamsBuilder {
+                SetDevicePostureOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDevicePostureOverrideParamsBuilder {
+            posture: Option<DevicePosture>,
+        }
+        impl SetDevicePostureOverrideParamsBuilder {
+            pub fn posture(mut self, posture: impl Into<DevicePosture>) -> Self {
+                self.posture = Some(posture.into());
+                self
+            }
+            pub fn build(self) -> Result<SetDevicePostureOverrideParams, String> {
+                Ok(SetDevicePostureOverrideParams {
+                    posture: self.posture.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(posture))
+                    })?,
+                })
+            }
+        }
+        impl SetDevicePostureOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setDevicePostureOverride";
+        }
+        impl chromiumoxide_types::Method for SetDevicePostureOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDevicePostureOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Start reporting the given posture value to the Device Posture API.\nThis override can also be set in setDeviceMetricsOverride().\n[setDevicePostureOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setDevicePostureOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDevicePostureOverrideReturns {}
+        impl chromiumoxide_types::Command for SetDevicePostureOverrideParams {
+            type Response = SetDevicePostureOverrideReturns;
+        }
+        #[doc = "Clears a device posture override set with either setDeviceMetricsOverride()\nor setDevicePostureOverride() and starts using posture information from the\nplatform again.\nDoes nothing if no override is set.\n[clearDevicePostureOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-clearDevicePostureOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearDevicePostureOverrideParams {}
+        impl ClearDevicePostureOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.clearDevicePostureOverride";
+        }
+        impl chromiumoxide_types::Method for ClearDevicePostureOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearDevicePostureOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears a device posture override set with either setDeviceMetricsOverride()\nor setDevicePostureOverride() and starts using posture information from the\nplatform again.\nDoes nothing if no override is set.\n[clearDevicePostureOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-clearDevicePostureOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearDevicePostureOverrideReturns {}
+        impl chromiumoxide_types::Command for ClearDevicePostureOverrideParams {
+            type Response = ClearDevicePostureOverrideReturns;
+        }
+        #[doc = "Start using the given display features to pupulate the Viewport Segments API.\nThis override can also be set in setDeviceMetricsOverride().\n[setDisplayFeaturesOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setDisplayFeaturesOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDisplayFeaturesOverrideParams {
+            #[serde(rename = "features")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub features: Vec<DisplayFeature>,
+        }
+        impl SetDisplayFeaturesOverrideParams {
+            pub fn new(features: Vec<DisplayFeature>) -> Self {
+                Self { features }
+            }
+        }
+        impl SetDisplayFeaturesOverrideParams {
+            pub fn builder() -> SetDisplayFeaturesOverrideParamsBuilder {
+                SetDisplayFeaturesOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDisplayFeaturesOverrideParamsBuilder {
+            features: Option<Vec<DisplayFeature>>,
+        }
+        impl SetDisplayFeaturesOverrideParamsBuilder {
+            pub fn feature(mut self, feature: impl Into<DisplayFeature>) -> Self {
+                let v = self.features.get_or_insert(Vec::new());
+                v.push(feature.into());
+                self
+            }
+            pub fn features<I, S>(mut self, features: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<DisplayFeature>,
+            {
+                let v = self.features.get_or_insert(Vec::new());
+                for val in features {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetDisplayFeaturesOverrideParams, String> {
+                Ok(SetDisplayFeaturesOverrideParams {
+                    features: self.features.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(features))
+                    })?,
+                })
+            }
+        }
+        impl SetDisplayFeaturesOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setDisplayFeaturesOverride";
+        }
+        impl chromiumoxide_types::Method for SetDisplayFeaturesOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDisplayFeaturesOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Start using the given display features to pupulate the Viewport Segments API.\nThis override can also be set in setDeviceMetricsOverride().\n[setDisplayFeaturesOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setDisplayFeaturesOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDisplayFeaturesOverrideReturns {}
+        impl chromiumoxide_types::Command for SetDisplayFeaturesOverrideParams {
+            type Response = SetDisplayFeaturesOverrideReturns;
+        }
+        #[doc = "Clears the display features override set with either setDeviceMetricsOverride()\nor setDisplayFeaturesOverride() and starts using display features from the\nplatform again.\nDoes nothing if no override is set.\n[clearDisplayFeaturesOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-clearDisplayFeaturesOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearDisplayFeaturesOverrideParams {}
+        impl ClearDisplayFeaturesOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.clearDisplayFeaturesOverride";
+        }
+        impl chromiumoxide_types::Method for ClearDisplayFeaturesOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearDisplayFeaturesOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears the display features override set with either setDeviceMetricsOverride()\nor setDisplayFeaturesOverride() and starts using display features from the\nplatform again.\nDoes nothing if no override is set.\n[clearDisplayFeaturesOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-clearDisplayFeaturesOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearDisplayFeaturesOverrideReturns {}
+        impl chromiumoxide_types::Command for ClearDisplayFeaturesOverrideParams {
+            type Response = ClearDisplayFeaturesOverrideReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetScrollbarsHiddenParams {
+            #[doc = "Whether scrollbars should be always hidden."]
+            #[serde(rename = "hidden")]
+            pub hidden: bool,
+        }
+        impl SetScrollbarsHiddenParams {
+            pub fn new(hidden: impl Into<bool>) -> Self {
+                Self {
+                    hidden: hidden.into(),
+                }
+            }
+        }
+        impl SetScrollbarsHiddenParams {
+            pub fn builder() -> SetScrollbarsHiddenParamsBuilder {
+                SetScrollbarsHiddenParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetScrollbarsHiddenParamsBuilder {
+            hidden: Option<bool>,
+        }
+        impl SetScrollbarsHiddenParamsBuilder {
+            pub fn hidden(mut self, hidden: impl Into<bool>) -> Self {
+                self.hidden = Some(hidden.into());
+                self
+            }
+            pub fn build(self) -> Result<SetScrollbarsHiddenParams, String> {
+                Ok(SetScrollbarsHiddenParams {
+                    hidden: self.hidden.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(hidden))
+                    })?,
+                })
+            }
+        }
+        impl SetScrollbarsHiddenParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setScrollbarsHidden";
+        }
+        impl chromiumoxide_types::Method for SetScrollbarsHiddenParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetScrollbarsHiddenParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetScrollbarsHiddenReturns {}
+        impl chromiumoxide_types::Command for SetScrollbarsHiddenParams {
+            type Response = SetScrollbarsHiddenReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDocumentCookieDisabledParams {
+            #[doc = "Whether document.coookie API should be disabled."]
+            #[serde(rename = "disabled")]
+            pub disabled: bool,
+        }
+        impl SetDocumentCookieDisabledParams {
+            pub fn new(disabled: impl Into<bool>) -> Self {
+                Self {
+                    disabled: disabled.into(),
+                }
+            }
+        }
+        impl SetDocumentCookieDisabledParams {
+            pub fn builder() -> SetDocumentCookieDisabledParamsBuilder {
+                SetDocumentCookieDisabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDocumentCookieDisabledParamsBuilder {
+            disabled: Option<bool>,
+        }
+        impl SetDocumentCookieDisabledParamsBuilder {
+            pub fn disabled(mut self, disabled: impl Into<bool>) -> Self {
+                self.disabled = Some(disabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetDocumentCookieDisabledParams, String> {
+                Ok(SetDocumentCookieDisabledParams {
+                    disabled: self.disabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(disabled))
+                    })?,
+                })
+            }
+        }
+        impl SetDocumentCookieDisabledParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setDocumentCookieDisabled";
+        }
+        impl chromiumoxide_types::Method for SetDocumentCookieDisabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDocumentCookieDisabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDocumentCookieDisabledReturns {}
+        impl chromiumoxide_types::Command for SetDocumentCookieDisabledParams {
+            type Response = SetDocumentCookieDisabledReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetEmitTouchEventsForMouseParams {
+            #[doc = "Whether touch emulation based on mouse input should be enabled."]
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+            #[doc = "Touch/gesture events configuration. Default: current platform."]
+            #[serde(rename = "configuration")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub configuration: Option<SetEmitTouchEventsForMouseConfiguration>,
+        }
+        #[doc = "Touch/gesture events configuration. Default: current platform."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SetEmitTouchEventsForMouseConfiguration {
+            #[serde(rename = "mobile")]
+            Mobile,
+            #[serde(rename = "desktop")]
+            Desktop,
+        }
+        impl AsRef<str> for SetEmitTouchEventsForMouseConfiguration {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SetEmitTouchEventsForMouseConfiguration::Mobile => "mobile",
+                    SetEmitTouchEventsForMouseConfiguration::Desktop => "desktop",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SetEmitTouchEventsForMouseConfiguration {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "mobile" | "Mobile" => Ok(SetEmitTouchEventsForMouseConfiguration::Mobile),
+                    "desktop" | "Desktop" => Ok(SetEmitTouchEventsForMouseConfiguration::Desktop),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl SetEmitTouchEventsForMouseParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                    configuration: None,
+                }
+            }
+        }
+        impl SetEmitTouchEventsForMouseParams {
+            pub fn builder() -> SetEmitTouchEventsForMouseParamsBuilder {
+                SetEmitTouchEventsForMouseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetEmitTouchEventsForMouseParamsBuilder {
+            enabled: Option<bool>,
+            configuration: Option<SetEmitTouchEventsForMouseConfiguration>,
+        }
+        impl SetEmitTouchEventsForMouseParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn configuration(
+                mut self,
+                configuration: impl Into<SetEmitTouchEventsForMouseConfiguration>,
+            ) -> Self {
+                self.configuration = Some(configuration.into());
+                self
+            }
+            pub fn build(self) -> Result<SetEmitTouchEventsForMouseParams, String> {
+                Ok(SetEmitTouchEventsForMouseParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                    configuration: self.configuration,
+                })
+            }
+        }
+        impl SetEmitTouchEventsForMouseParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setEmitTouchEventsForMouse";
+        }
+        impl chromiumoxide_types::Method for SetEmitTouchEventsForMouseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetEmitTouchEventsForMouseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetEmitTouchEventsForMouseReturns {}
+        impl chromiumoxide_types::Command for SetEmitTouchEventsForMouseParams {
+            type Response = SetEmitTouchEventsForMouseReturns;
+        }
+        #[doc = "Emulates the given media type or media feature for CSS media queries.\n[setEmulatedMedia](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setEmulatedMedia)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetEmulatedMediaParams {
+            #[doc = "Media type to emulate. Empty string disables the override."]
+            #[serde(rename = "media")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub media: Option<String>,
+            #[doc = "Media features to emulate."]
+            #[serde(rename = "features")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub features: Option<Vec<MediaFeature>>,
+        }
+        impl SetEmulatedMediaParams {
+            pub fn builder() -> SetEmulatedMediaParamsBuilder {
+                SetEmulatedMediaParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetEmulatedMediaParamsBuilder {
+            media: Option<String>,
+            features: Option<Vec<MediaFeature>>,
+        }
+        impl SetEmulatedMediaParamsBuilder {
+            pub fn media(mut self, media: impl Into<String>) -> Self {
+                self.media = Some(media.into());
+                self
+            }
+            pub fn feature(mut self, feature: impl Into<MediaFeature>) -> Self {
+                let v = self.features.get_or_insert(Vec::new());
+                v.push(feature.into());
+                self
+            }
+            pub fn features<I, S>(mut self, features: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<MediaFeature>,
+            {
+                let v = self.features.get_or_insert(Vec::new());
+                for val in features {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> SetEmulatedMediaParams {
+                SetEmulatedMediaParams {
+                    media: self.media,
+                    features: self.features,
+                }
+            }
+        }
+        impl SetEmulatedMediaParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setEmulatedMedia";
+        }
+        impl chromiumoxide_types::Method for SetEmulatedMediaParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetEmulatedMediaParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Emulates the given media type or media feature for CSS media queries.\n[setEmulatedMedia](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setEmulatedMedia)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetEmulatedMediaReturns {}
+        impl chromiumoxide_types::Command for SetEmulatedMediaParams {
+            type Response = SetEmulatedMediaReturns;
+        }
+        #[doc = "Emulates the given vision deficiency.\n[setEmulatedVisionDeficiency](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setEmulatedVisionDeficiency)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetEmulatedVisionDeficiencyParams {
+            #[doc = "Vision deficiency to emulate. Order: best-effort emulations come first, followed by any\nphysiologically accurate emulations for medically recognized color vision deficiencies."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: SetEmulatedVisionDeficiencyType,
+        }
+        #[doc = "Vision deficiency to emulate. Order: best-effort emulations come first, followed by any\nphysiologically accurate emulations for medically recognized color vision deficiencies."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SetEmulatedVisionDeficiencyType {
+            #[serde(rename = "none")]
+            None,
+            #[serde(rename = "blurredVision")]
+            BlurredVision,
+            #[serde(rename = "reducedContrast")]
+            ReducedContrast,
+            #[serde(rename = "achromatopsia")]
+            Achromatopsia,
+            #[serde(rename = "deuteranopia")]
+            Deuteranopia,
+            #[serde(rename = "protanopia")]
+            Protanopia,
+            #[serde(rename = "tritanopia")]
+            Tritanopia,
+        }
+        impl AsRef<str> for SetEmulatedVisionDeficiencyType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SetEmulatedVisionDeficiencyType::None => "none",
+                    SetEmulatedVisionDeficiencyType::BlurredVision => "blurredVision",
+                    SetEmulatedVisionDeficiencyType::ReducedContrast => "reducedContrast",
+                    SetEmulatedVisionDeficiencyType::Achromatopsia => "achromatopsia",
+                    SetEmulatedVisionDeficiencyType::Deuteranopia => "deuteranopia",
+                    SetEmulatedVisionDeficiencyType::Protanopia => "protanopia",
+                    SetEmulatedVisionDeficiencyType::Tritanopia => "tritanopia",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SetEmulatedVisionDeficiencyType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "none" | "None" => Ok(SetEmulatedVisionDeficiencyType::None),
+                    "blurredVision" | "BlurredVision" | "blurredvision" => {
+                        Ok(SetEmulatedVisionDeficiencyType::BlurredVision)
+                    }
+                    "reducedContrast" | "ReducedContrast" | "reducedcontrast" => {
+                        Ok(SetEmulatedVisionDeficiencyType::ReducedContrast)
+                    }
+                    "achromatopsia" | "Achromatopsia" => {
+                        Ok(SetEmulatedVisionDeficiencyType::Achromatopsia)
+                    }
+                    "deuteranopia" | "Deuteranopia" => {
+                        Ok(SetEmulatedVisionDeficiencyType::Deuteranopia)
+                    }
+                    "protanopia" | "Protanopia" => Ok(SetEmulatedVisionDeficiencyType::Protanopia),
+                    "tritanopia" | "Tritanopia" => Ok(SetEmulatedVisionDeficiencyType::Tritanopia),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl SetEmulatedVisionDeficiencyParams {
+            pub fn new(r#type: impl Into<SetEmulatedVisionDeficiencyType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                }
+            }
+        }
+        impl SetEmulatedVisionDeficiencyParams {
+            pub fn builder() -> SetEmulatedVisionDeficiencyParamsBuilder {
+                SetEmulatedVisionDeficiencyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetEmulatedVisionDeficiencyParamsBuilder {
+            r#type: Option<SetEmulatedVisionDeficiencyType>,
+        }
+        impl SetEmulatedVisionDeficiencyParamsBuilder {
+            pub fn r#type(mut self, r#type: impl Into<SetEmulatedVisionDeficiencyType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<SetEmulatedVisionDeficiencyParams, String> {
+                Ok(SetEmulatedVisionDeficiencyParams {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                })
+            }
+        }
+        impl SetEmulatedVisionDeficiencyParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setEmulatedVisionDeficiency";
+        }
+        impl chromiumoxide_types::Method for SetEmulatedVisionDeficiencyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetEmulatedVisionDeficiencyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Emulates the given vision deficiency.\n[setEmulatedVisionDeficiency](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setEmulatedVisionDeficiency)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetEmulatedVisionDeficiencyReturns {}
+        impl chromiumoxide_types::Command for SetEmulatedVisionDeficiencyParams {
+            type Response = SetEmulatedVisionDeficiencyReturns;
+        }
+        #[doc = "Emulates the given OS text scale.\n[setEmulatedOSTextScale](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setEmulatedOSTextScale)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetEmulatedOsTextScaleParams {
+            #[serde(rename = "scale")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scale: Option<f64>,
+        }
+        impl SetEmulatedOsTextScaleParams {
+            pub fn builder() -> SetEmulatedOsTextScaleParamsBuilder {
+                SetEmulatedOsTextScaleParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetEmulatedOsTextScaleParamsBuilder {
+            scale: Option<f64>,
+        }
+        impl SetEmulatedOsTextScaleParamsBuilder {
+            pub fn scale(mut self, scale: impl Into<f64>) -> Self {
+                self.scale = Some(scale.into());
+                self
+            }
+            pub fn build(self) -> SetEmulatedOsTextScaleParams {
+                SetEmulatedOsTextScaleParams { scale: self.scale }
+            }
+        }
+        impl SetEmulatedOsTextScaleParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setEmulatedOSTextScale";
+        }
+        impl chromiumoxide_types::Method for SetEmulatedOsTextScaleParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetEmulatedOsTextScaleParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Emulates the given OS text scale.\n[setEmulatedOSTextScale](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setEmulatedOSTextScale)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetEmulatedOsTextScaleReturns {}
+        impl chromiumoxide_types::Command for SetEmulatedOsTextScaleParams {
+            type Response = SetEmulatedOsTextScaleReturns;
+        }
+        #[doc = "Overrides the Geolocation Position or Error. Omitting latitude, longitude or\naccuracy emulates position unavailable.\n[setGeolocationOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setGeolocationOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetGeolocationOverrideParams {
+            #[doc = "Mock latitude"]
+            #[serde(rename = "latitude")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub latitude: Option<f64>,
+            #[doc = "Mock longitude"]
+            #[serde(rename = "longitude")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub longitude: Option<f64>,
+            #[doc = "Mock accuracy"]
+            #[serde(rename = "accuracy")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub accuracy: Option<f64>,
+            #[doc = "Mock altitude"]
+            #[serde(rename = "altitude")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub altitude: Option<f64>,
+            #[doc = "Mock altitudeAccuracy"]
+            #[serde(rename = "altitudeAccuracy")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub altitude_accuracy: Option<f64>,
+            #[doc = "Mock heading"]
+            #[serde(rename = "heading")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub heading: Option<f64>,
+            #[doc = "Mock speed"]
+            #[serde(rename = "speed")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub speed: Option<f64>,
+        }
+        impl SetGeolocationOverrideParams {
+            pub fn builder() -> SetGeolocationOverrideParamsBuilder {
+                SetGeolocationOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetGeolocationOverrideParamsBuilder {
+            latitude: Option<f64>,
+            longitude: Option<f64>,
+            accuracy: Option<f64>,
+            altitude: Option<f64>,
+            altitude_accuracy: Option<f64>,
+            heading: Option<f64>,
+            speed: Option<f64>,
+        }
+        impl SetGeolocationOverrideParamsBuilder {
+            pub fn latitude(mut self, latitude: impl Into<f64>) -> Self {
+                self.latitude = Some(latitude.into());
+                self
+            }
+            pub fn longitude(mut self, longitude: impl Into<f64>) -> Self {
+                self.longitude = Some(longitude.into());
+                self
+            }
+            pub fn accuracy(mut self, accuracy: impl Into<f64>) -> Self {
+                self.accuracy = Some(accuracy.into());
+                self
+            }
+            pub fn altitude(mut self, altitude: impl Into<f64>) -> Self {
+                self.altitude = Some(altitude.into());
+                self
+            }
+            pub fn altitude_accuracy(mut self, altitude_accuracy: impl Into<f64>) -> Self {
+                self.altitude_accuracy = Some(altitude_accuracy.into());
+                self
+            }
+            pub fn heading(mut self, heading: impl Into<f64>) -> Self {
+                self.heading = Some(heading.into());
+                self
+            }
+            pub fn speed(mut self, speed: impl Into<f64>) -> Self {
+                self.speed = Some(speed.into());
+                self
+            }
+            pub fn build(self) -> SetGeolocationOverrideParams {
+                SetGeolocationOverrideParams {
+                    latitude: self.latitude,
+                    longitude: self.longitude,
+                    accuracy: self.accuracy,
+                    altitude: self.altitude,
+                    altitude_accuracy: self.altitude_accuracy,
+                    heading: self.heading,
+                    speed: self.speed,
+                }
+            }
+        }
+        impl SetGeolocationOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setGeolocationOverride";
+        }
+        impl chromiumoxide_types::Method for SetGeolocationOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetGeolocationOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Overrides the Geolocation Position or Error. Omitting latitude, longitude or\naccuracy emulates position unavailable.\n[setGeolocationOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setGeolocationOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetGeolocationOverrideReturns {}
+        impl chromiumoxide_types::Command for SetGeolocationOverrideParams {
+            type Response = SetGeolocationOverrideReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetOverriddenSensorInformationParams {
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: SensorType,
+        }
+        impl GetOverriddenSensorInformationParams {
+            pub fn new(r#type: impl Into<SensorType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                }
+            }
+        }
+        impl GetOverriddenSensorInformationParams {
+            pub fn builder() -> GetOverriddenSensorInformationParamsBuilder {
+                GetOverriddenSensorInformationParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetOverriddenSensorInformationParamsBuilder {
+            r#type: Option<SensorType>,
+        }
+        impl GetOverriddenSensorInformationParamsBuilder {
+            pub fn r#type(mut self, r#type: impl Into<SensorType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<GetOverriddenSensorInformationParams, String> {
+                Ok(GetOverriddenSensorInformationParams {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                })
+            }
+        }
+        impl GetOverriddenSensorInformationParams {
+            pub const IDENTIFIER: &'static str = "Emulation.getOverriddenSensorInformation";
+        }
+        impl chromiumoxide_types::Method for GetOverriddenSensorInformationParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetOverriddenSensorInformationParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetOverriddenSensorInformationReturns {
+            #[serde(rename = "requestedSamplingFrequency")]
+            pub requested_sampling_frequency: f64,
+        }
+        impl GetOverriddenSensorInformationReturns {
+            pub fn new(requested_sampling_frequency: impl Into<f64>) -> Self {
+                Self {
+                    requested_sampling_frequency: requested_sampling_frequency.into(),
+                }
+            }
+        }
+        impl GetOverriddenSensorInformationReturns {
+            pub fn builder() -> GetOverriddenSensorInformationReturnsBuilder {
+                GetOverriddenSensorInformationReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetOverriddenSensorInformationReturnsBuilder {
+            requested_sampling_frequency: Option<f64>,
+        }
+        impl GetOverriddenSensorInformationReturnsBuilder {
+            pub fn requested_sampling_frequency(
+                mut self,
+                requested_sampling_frequency: impl Into<f64>,
+            ) -> Self {
+                self.requested_sampling_frequency = Some(requested_sampling_frequency.into());
+                self
+            }
+            pub fn build(self) -> Result<GetOverriddenSensorInformationReturns, String> {
+                Ok(GetOverriddenSensorInformationReturns {
+                    requested_sampling_frequency: self.requested_sampling_frequency.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(requested_sampling_frequency)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetOverriddenSensorInformationParams {
+            type Response = GetOverriddenSensorInformationReturns;
+        }
+        #[doc = "Overrides a platform sensor of a given type. If |enabled| is true, calls to\nSensor.start() will use a virtual sensor as backend rather than fetching\ndata from a real hardware sensor. Otherwise, existing virtual\nsensor-backend Sensor objects will fire an error event and new calls to\nSensor.start() will attempt to use a real sensor instead.\n[setSensorOverrideEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setSensorOverrideEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSensorOverrideEnabledParams {
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: SensorType,
+            #[serde(rename = "metadata")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub metadata: Option<SensorMetadata>,
+        }
+        impl SetSensorOverrideEnabledParams {
+            pub fn new(enabled: impl Into<bool>, r#type: impl Into<SensorType>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                    r#type: r#type.into(),
+                    metadata: None,
+                }
+            }
+        }
+        impl SetSensorOverrideEnabledParams {
+            pub fn builder() -> SetSensorOverrideEnabledParamsBuilder {
+                SetSensorOverrideEnabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSensorOverrideEnabledParamsBuilder {
+            enabled: Option<bool>,
+            r#type: Option<SensorType>,
+            metadata: Option<SensorMetadata>,
+        }
+        impl SetSensorOverrideEnabledParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<SensorType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn metadata(mut self, metadata: impl Into<SensorMetadata>) -> Self {
+                self.metadata = Some(metadata.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSensorOverrideEnabledParams, String> {
+                Ok(SetSensorOverrideEnabledParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    metadata: self.metadata,
+                })
+            }
+        }
+        impl SetSensorOverrideEnabledParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setSensorOverrideEnabled";
+        }
+        impl chromiumoxide_types::Method for SetSensorOverrideEnabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSensorOverrideEnabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Overrides a platform sensor of a given type. If |enabled| is true, calls to\nSensor.start() will use a virtual sensor as backend rather than fetching\ndata from a real hardware sensor. Otherwise, existing virtual\nsensor-backend Sensor objects will fire an error event and new calls to\nSensor.start() will attempt to use a real sensor instead.\n[setSensorOverrideEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setSensorOverrideEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSensorOverrideEnabledReturns {}
+        impl chromiumoxide_types::Command for SetSensorOverrideEnabledParams {
+            type Response = SetSensorOverrideEnabledReturns;
+        }
+        #[doc = "Updates the sensor readings reported by a sensor type previously overridden\nby setSensorOverrideEnabled.\n[setSensorOverrideReadings](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setSensorOverrideReadings)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSensorOverrideReadingsParams {
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: SensorType,
+            #[serde(rename = "reading")]
+            pub reading: SensorReading,
+        }
+        impl SetSensorOverrideReadingsParams {
+            pub fn new(r#type: impl Into<SensorType>, reading: impl Into<SensorReading>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    reading: reading.into(),
+                }
+            }
+        }
+        impl SetSensorOverrideReadingsParams {
+            pub fn builder() -> SetSensorOverrideReadingsParamsBuilder {
+                SetSensorOverrideReadingsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSensorOverrideReadingsParamsBuilder {
+            r#type: Option<SensorType>,
+            reading: Option<SensorReading>,
+        }
+        impl SetSensorOverrideReadingsParamsBuilder {
+            pub fn r#type(mut self, r#type: impl Into<SensorType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn reading(mut self, reading: impl Into<SensorReading>) -> Self {
+                self.reading = Some(reading.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSensorOverrideReadingsParams, String> {
+                Ok(SetSensorOverrideReadingsParams {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    reading: self.reading.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(reading))
+                    })?,
+                })
+            }
+        }
+        impl SetSensorOverrideReadingsParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setSensorOverrideReadings";
+        }
+        impl chromiumoxide_types::Method for SetSensorOverrideReadingsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSensorOverrideReadingsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Updates the sensor readings reported by a sensor type previously overridden\nby setSensorOverrideEnabled.\n[setSensorOverrideReadings](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setSensorOverrideReadings)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSensorOverrideReadingsReturns {}
+        impl chromiumoxide_types::Command for SetSensorOverrideReadingsParams {
+            type Response = SetSensorOverrideReadingsReturns;
+        }
+        #[doc = "Overrides a pressure source of a given type, as used by the Compute\nPressure API, so that updates to PressureObserver.observe() are provided\nvia setPressureStateOverride instead of being retrieved from\nplatform-provided telemetry data.\n[setPressureSourceOverrideEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setPressureSourceOverrideEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPressureSourceOverrideEnabledParams {
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+            #[serde(rename = "source")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub source: PressureSource,
+            #[serde(rename = "metadata")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub metadata: Option<PressureMetadata>,
+        }
+        impl SetPressureSourceOverrideEnabledParams {
+            pub fn new(enabled: impl Into<bool>, source: impl Into<PressureSource>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                    source: source.into(),
+                    metadata: None,
+                }
+            }
+        }
+        impl SetPressureSourceOverrideEnabledParams {
+            pub fn builder() -> SetPressureSourceOverrideEnabledParamsBuilder {
+                SetPressureSourceOverrideEnabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPressureSourceOverrideEnabledParamsBuilder {
+            enabled: Option<bool>,
+            source: Option<PressureSource>,
+            metadata: Option<PressureMetadata>,
+        }
+        impl SetPressureSourceOverrideEnabledParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn source(mut self, source: impl Into<PressureSource>) -> Self {
+                self.source = Some(source.into());
+                self
+            }
+            pub fn metadata(mut self, metadata: impl Into<PressureMetadata>) -> Self {
+                self.metadata = Some(metadata.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPressureSourceOverrideEnabledParams, String> {
+                Ok(SetPressureSourceOverrideEnabledParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                    source: self.source.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source))
+                    })?,
+                    metadata: self.metadata,
+                })
+            }
+        }
+        impl SetPressureSourceOverrideEnabledParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setPressureSourceOverrideEnabled";
+        }
+        impl chromiumoxide_types::Method for SetPressureSourceOverrideEnabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPressureSourceOverrideEnabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Overrides a pressure source of a given type, as used by the Compute\nPressure API, so that updates to PressureObserver.observe() are provided\nvia setPressureStateOverride instead of being retrieved from\nplatform-provided telemetry data.\n[setPressureSourceOverrideEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setPressureSourceOverrideEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPressureSourceOverrideEnabledReturns {}
+        impl chromiumoxide_types::Command for SetPressureSourceOverrideEnabledParams {
+            type Response = SetPressureSourceOverrideEnabledReturns;
+        }
+        #[doc = "TODO: OBSOLETE: To remove when setPressureDataOverride is merged.\nProvides a given pressure state that will be processed and eventually be\ndelivered to PressureObserver users. |source| must have been previously\noverridden by setPressureSourceOverrideEnabled.\n[setPressureStateOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setPressureStateOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPressureStateOverrideParams {
+            #[serde(rename = "source")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub source: PressureSource,
+            #[serde(rename = "state")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub state: PressureState,
+        }
+        impl SetPressureStateOverrideParams {
+            pub fn new(source: impl Into<PressureSource>, state: impl Into<PressureState>) -> Self {
+                Self {
+                    source: source.into(),
+                    state: state.into(),
+                }
+            }
+        }
+        impl SetPressureStateOverrideParams {
+            pub fn builder() -> SetPressureStateOverrideParamsBuilder {
+                SetPressureStateOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPressureStateOverrideParamsBuilder {
+            source: Option<PressureSource>,
+            state: Option<PressureState>,
+        }
+        impl SetPressureStateOverrideParamsBuilder {
+            pub fn source(mut self, source: impl Into<PressureSource>) -> Self {
+                self.source = Some(source.into());
+                self
+            }
+            pub fn state(mut self, state: impl Into<PressureState>) -> Self {
+                self.state = Some(state.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPressureStateOverrideParams, String> {
+                Ok(SetPressureStateOverrideParams {
+                    source: self.source.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source))
+                    })?,
+                    state: self.state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(state))
+                    })?,
+                })
+            }
+        }
+        impl SetPressureStateOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setPressureStateOverride";
+        }
+        impl chromiumoxide_types::Method for SetPressureStateOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPressureStateOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "TODO: OBSOLETE: To remove when setPressureDataOverride is merged.\nProvides a given pressure state that will be processed and eventually be\ndelivered to PressureObserver users. |source| must have been previously\noverridden by setPressureSourceOverrideEnabled.\n[setPressureStateOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setPressureStateOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPressureStateOverrideReturns {}
+        impl chromiumoxide_types::Command for SetPressureStateOverrideParams {
+            type Response = SetPressureStateOverrideReturns;
+        }
+        #[doc = "Provides a given pressure data set that will be processed and eventually be\ndelivered to PressureObserver users. |source| must have been previously\noverridden by setPressureSourceOverrideEnabled.\n[setPressureDataOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setPressureDataOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPressureDataOverrideParams {
+            #[serde(rename = "source")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub source: PressureSource,
+            #[serde(rename = "state")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub state: PressureState,
+            #[serde(rename = "ownContributionEstimate")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub own_contribution_estimate: Option<f64>,
+        }
+        impl SetPressureDataOverrideParams {
+            pub fn new(source: impl Into<PressureSource>, state: impl Into<PressureState>) -> Self {
+                Self {
+                    source: source.into(),
+                    state: state.into(),
+                    own_contribution_estimate: None,
+                }
+            }
+        }
+        impl SetPressureDataOverrideParams {
+            pub fn builder() -> SetPressureDataOverrideParamsBuilder {
+                SetPressureDataOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPressureDataOverrideParamsBuilder {
+            source: Option<PressureSource>,
+            state: Option<PressureState>,
+            own_contribution_estimate: Option<f64>,
+        }
+        impl SetPressureDataOverrideParamsBuilder {
+            pub fn source(mut self, source: impl Into<PressureSource>) -> Self {
+                self.source = Some(source.into());
+                self
+            }
+            pub fn state(mut self, state: impl Into<PressureState>) -> Self {
+                self.state = Some(state.into());
+                self
+            }
+            pub fn own_contribution_estimate(
+                mut self,
+                own_contribution_estimate: impl Into<f64>,
+            ) -> Self {
+                self.own_contribution_estimate = Some(own_contribution_estimate.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPressureDataOverrideParams, String> {
+                Ok(SetPressureDataOverrideParams {
+                    source: self.source.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source))
+                    })?,
+                    state: self.state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(state))
+                    })?,
+                    own_contribution_estimate: self.own_contribution_estimate,
+                })
+            }
+        }
+        impl SetPressureDataOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setPressureDataOverride";
+        }
+        impl chromiumoxide_types::Method for SetPressureDataOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPressureDataOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Provides a given pressure data set that will be processed and eventually be\ndelivered to PressureObserver users. |source| must have been previously\noverridden by setPressureSourceOverrideEnabled.\n[setPressureDataOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setPressureDataOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPressureDataOverrideReturns {}
+        impl chromiumoxide_types::Command for SetPressureDataOverrideParams {
+            type Response = SetPressureDataOverrideReturns;
+        }
+        #[doc = "Overrides the Idle state.\n[setIdleOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setIdleOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetIdleOverrideParams {
+            #[doc = "Mock isUserActive"]
+            #[serde(rename = "isUserActive")]
+            pub is_user_active: bool,
+            #[doc = "Mock isScreenUnlocked"]
+            #[serde(rename = "isScreenUnlocked")]
+            pub is_screen_unlocked: bool,
+        }
+        impl SetIdleOverrideParams {
+            pub fn new(
+                is_user_active: impl Into<bool>,
+                is_screen_unlocked: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    is_user_active: is_user_active.into(),
+                    is_screen_unlocked: is_screen_unlocked.into(),
+                }
+            }
+        }
+        impl SetIdleOverrideParams {
+            pub fn builder() -> SetIdleOverrideParamsBuilder {
+                SetIdleOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetIdleOverrideParamsBuilder {
+            is_user_active: Option<bool>,
+            is_screen_unlocked: Option<bool>,
+        }
+        impl SetIdleOverrideParamsBuilder {
+            pub fn is_user_active(mut self, is_user_active: impl Into<bool>) -> Self {
+                self.is_user_active = Some(is_user_active.into());
+                self
+            }
+            pub fn is_screen_unlocked(mut self, is_screen_unlocked: impl Into<bool>) -> Self {
+                self.is_screen_unlocked = Some(is_screen_unlocked.into());
+                self
+            }
+            pub fn build(self) -> Result<SetIdleOverrideParams, String> {
+                Ok(SetIdleOverrideParams {
+                    is_user_active: self.is_user_active.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_user_active))
+                    })?,
+                    is_screen_unlocked: self.is_screen_unlocked.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(is_screen_unlocked)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl SetIdleOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setIdleOverride";
+        }
+        impl chromiumoxide_types::Method for SetIdleOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetIdleOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Overrides the Idle state.\n[setIdleOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setIdleOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetIdleOverrideReturns {}
+        impl chromiumoxide_types::Command for SetIdleOverrideParams {
+            type Response = SetIdleOverrideReturns;
+        }
+        #[doc = "Clears Idle state overrides.\n[clearIdleOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-clearIdleOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearIdleOverrideParams {}
+        impl ClearIdleOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.clearIdleOverride";
+        }
+        impl chromiumoxide_types::Method for ClearIdleOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearIdleOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears Idle state overrides.\n[clearIdleOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-clearIdleOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearIdleOverrideReturns {}
+        impl chromiumoxide_types::Command for ClearIdleOverrideParams {
+            type Response = ClearIdleOverrideReturns;
+        }
+        #[doc = "Sets a specified page scale factor.\n[setPageScaleFactor](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setPageScaleFactor)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPageScaleFactorParams {
+            #[doc = "Page scale factor."]
+            #[serde(rename = "pageScaleFactor")]
+            pub page_scale_factor: f64,
+        }
+        impl SetPageScaleFactorParams {
+            pub fn new(page_scale_factor: impl Into<f64>) -> Self {
+                Self {
+                    page_scale_factor: page_scale_factor.into(),
+                }
+            }
+        }
+        impl SetPageScaleFactorParams {
+            pub fn builder() -> SetPageScaleFactorParamsBuilder {
+                SetPageScaleFactorParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPageScaleFactorParamsBuilder {
+            page_scale_factor: Option<f64>,
+        }
+        impl SetPageScaleFactorParamsBuilder {
+            pub fn page_scale_factor(mut self, page_scale_factor: impl Into<f64>) -> Self {
+                self.page_scale_factor = Some(page_scale_factor.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPageScaleFactorParams, String> {
+                Ok(SetPageScaleFactorParams {
+                    page_scale_factor: self.page_scale_factor.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(page_scale_factor)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl SetPageScaleFactorParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setPageScaleFactor";
+        }
+        impl chromiumoxide_types::Method for SetPageScaleFactorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPageScaleFactorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets a specified page scale factor.\n[setPageScaleFactor](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setPageScaleFactor)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPageScaleFactorReturns {}
+        impl chromiumoxide_types::Command for SetPageScaleFactorParams {
+            type Response = SetPageScaleFactorReturns;
+        }
+        #[doc = "Switches script execution in the page.\n[setScriptExecutionDisabled](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setScriptExecutionDisabled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetScriptExecutionDisabledParams {
+            #[doc = "Whether script execution should be disabled in the page."]
+            #[serde(rename = "value")]
+            pub value: bool,
+        }
+        impl SetScriptExecutionDisabledParams {
+            pub fn new(value: impl Into<bool>) -> Self {
+                Self {
+                    value: value.into(),
+                }
+            }
+        }
+        impl SetScriptExecutionDisabledParams {
+            pub fn builder() -> SetScriptExecutionDisabledParamsBuilder {
+                SetScriptExecutionDisabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetScriptExecutionDisabledParamsBuilder {
+            value: Option<bool>,
+        }
+        impl SetScriptExecutionDisabledParamsBuilder {
+            pub fn value(mut self, value: impl Into<bool>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<SetScriptExecutionDisabledParams, String> {
+                Ok(SetScriptExecutionDisabledParams {
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl SetScriptExecutionDisabledParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setScriptExecutionDisabled";
+        }
+        impl chromiumoxide_types::Method for SetScriptExecutionDisabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetScriptExecutionDisabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Switches script execution in the page.\n[setScriptExecutionDisabled](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setScriptExecutionDisabled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetScriptExecutionDisabledReturns {}
+        impl chromiumoxide_types::Command for SetScriptExecutionDisabledParams {
+            type Response = SetScriptExecutionDisabledReturns;
+        }
+        #[doc = "Enables touch on platforms which do not support them.\n[setTouchEmulationEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setTouchEmulationEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetTouchEmulationEnabledParams {
+            #[doc = "Whether the touch event emulation should be enabled."]
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+            #[doc = "Maximum touch points supported. Defaults to one."]
+            #[serde(rename = "maxTouchPoints")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_touch_points: Option<i64>,
+        }
+        impl SetTouchEmulationEnabledParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                    max_touch_points: None,
+                }
+            }
+        }
+        impl SetTouchEmulationEnabledParams {
+            pub fn builder() -> SetTouchEmulationEnabledParamsBuilder {
+                SetTouchEmulationEnabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetTouchEmulationEnabledParamsBuilder {
+            enabled: Option<bool>,
+            max_touch_points: Option<i64>,
+        }
+        impl SetTouchEmulationEnabledParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn max_touch_points(mut self, max_touch_points: impl Into<i64>) -> Self {
+                self.max_touch_points = Some(max_touch_points.into());
+                self
+            }
+            pub fn build(self) -> Result<SetTouchEmulationEnabledParams, String> {
+                Ok(SetTouchEmulationEnabledParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                    max_touch_points: self.max_touch_points,
+                })
+            }
+        }
+        impl SetTouchEmulationEnabledParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setTouchEmulationEnabled";
+        }
+        impl chromiumoxide_types::Method for SetTouchEmulationEnabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetTouchEmulationEnabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables touch on platforms which do not support them.\n[setTouchEmulationEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setTouchEmulationEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetTouchEmulationEnabledReturns {}
+        impl chromiumoxide_types::Command for SetTouchEmulationEnabledParams {
+            type Response = SetTouchEmulationEnabledReturns;
+        }
+        #[doc = "Turns on virtual time for all frames (replacing real-time with a synthetic time source) and sets\nthe current virtual time policy.  Note this supersedes any previous time budget.\n[setVirtualTimePolicy](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setVirtualTimePolicy)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetVirtualTimePolicyParams {
+            #[serde(rename = "policy")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub policy: VirtualTimePolicy,
+            #[doc = "If set, after this many virtual milliseconds have elapsed virtual time will be paused and a\nvirtualTimeBudgetExpired event is sent."]
+            #[serde(rename = "budget")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub budget: Option<f64>,
+            #[doc = "If set this specifies the maximum number of tasks that can be run before virtual is forced\nforwards to prevent deadlock."]
+            #[serde(rename = "maxVirtualTimeTaskStarvationCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_virtual_time_task_starvation_count: Option<i64>,
+            #[doc = "If set, base::Time::Now will be overridden to initially return this value."]
+            #[serde(rename = "initialVirtualTime")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub initial_virtual_time: Option<super::network::TimeSinceEpoch>,
+        }
+        impl SetVirtualTimePolicyParams {
+            pub fn new(policy: impl Into<VirtualTimePolicy>) -> Self {
+                Self {
+                    policy: policy.into(),
+                    budget: None,
+                    max_virtual_time_task_starvation_count: None,
+                    initial_virtual_time: None,
+                }
+            }
+        }
+        impl SetVirtualTimePolicyParams {
+            pub fn builder() -> SetVirtualTimePolicyParamsBuilder {
+                SetVirtualTimePolicyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetVirtualTimePolicyParamsBuilder {
+            policy: Option<VirtualTimePolicy>,
+            budget: Option<f64>,
+            max_virtual_time_task_starvation_count: Option<i64>,
+            initial_virtual_time: Option<super::network::TimeSinceEpoch>,
+        }
+        impl SetVirtualTimePolicyParamsBuilder {
+            pub fn policy(mut self, policy: impl Into<VirtualTimePolicy>) -> Self {
+                self.policy = Some(policy.into());
+                self
+            }
+            pub fn budget(mut self, budget: impl Into<f64>) -> Self {
+                self.budget = Some(budget.into());
+                self
+            }
+            pub fn max_virtual_time_task_starvation_count(
+                mut self,
+                max_virtual_time_task_starvation_count: impl Into<i64>,
+            ) -> Self {
+                self.max_virtual_time_task_starvation_count =
+                    Some(max_virtual_time_task_starvation_count.into());
+                self
+            }
+            pub fn initial_virtual_time(
+                mut self,
+                initial_virtual_time: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.initial_virtual_time = Some(initial_virtual_time.into());
+                self
+            }
+            pub fn build(self) -> Result<SetVirtualTimePolicyParams, String> {
+                Ok(SetVirtualTimePolicyParams {
+                    policy: self.policy.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(policy))
+                    })?,
+                    budget: self.budget,
+                    max_virtual_time_task_starvation_count: self
+                        .max_virtual_time_task_starvation_count,
+                    initial_virtual_time: self.initial_virtual_time,
+                })
+            }
+        }
+        impl SetVirtualTimePolicyParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setVirtualTimePolicy";
+        }
+        impl chromiumoxide_types::Method for SetVirtualTimePolicyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetVirtualTimePolicyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Turns on virtual time for all frames (replacing real-time with a synthetic time source) and sets\nthe current virtual time policy.  Note this supersedes any previous time budget.\n[setVirtualTimePolicy](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setVirtualTimePolicy)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetVirtualTimePolicyReturns {
+            #[doc = "Absolute timestamp at which virtual time was first enabled (up time in milliseconds)."]
+            #[serde(rename = "virtualTimeTicksBase")]
+            pub virtual_time_ticks_base: f64,
+        }
+        impl SetVirtualTimePolicyReturns {
+            pub fn new(virtual_time_ticks_base: impl Into<f64>) -> Self {
+                Self {
+                    virtual_time_ticks_base: virtual_time_ticks_base.into(),
+                }
+            }
+        }
+        impl SetVirtualTimePolicyReturns {
+            pub fn builder() -> SetVirtualTimePolicyReturnsBuilder {
+                SetVirtualTimePolicyReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetVirtualTimePolicyReturnsBuilder {
+            virtual_time_ticks_base: Option<f64>,
+        }
+        impl SetVirtualTimePolicyReturnsBuilder {
+            pub fn virtual_time_ticks_base(
+                mut self,
+                virtual_time_ticks_base: impl Into<f64>,
+            ) -> Self {
+                self.virtual_time_ticks_base = Some(virtual_time_ticks_base.into());
+                self
+            }
+            pub fn build(self) -> Result<SetVirtualTimePolicyReturns, String> {
+                Ok(SetVirtualTimePolicyReturns {
+                    virtual_time_ticks_base: self.virtual_time_ticks_base.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(virtual_time_ticks_base)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SetVirtualTimePolicyParams {
+            type Response = SetVirtualTimePolicyReturns;
+        }
+        #[doc = "Overrides default host system locale with the specified one.\n[setLocaleOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setLocaleOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetLocaleOverrideParams {
+            #[doc = "ICU style C locale (e.g. \"en_US\"). If not specified or empty, disables the override and\nrestores default host system locale."]
+            #[serde(rename = "locale")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub locale: Option<String>,
+        }
+        impl SetLocaleOverrideParams {
+            pub fn builder() -> SetLocaleOverrideParamsBuilder {
+                SetLocaleOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetLocaleOverrideParamsBuilder {
+            locale: Option<String>,
+        }
+        impl SetLocaleOverrideParamsBuilder {
+            pub fn locale(mut self, locale: impl Into<String>) -> Self {
+                self.locale = Some(locale.into());
+                self
+            }
+            pub fn build(self) -> SetLocaleOverrideParams {
+                SetLocaleOverrideParams {
+                    locale: self.locale,
+                }
+            }
+        }
+        impl SetLocaleOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setLocaleOverride";
+        }
+        impl chromiumoxide_types::Method for SetLocaleOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetLocaleOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Overrides default host system locale with the specified one.\n[setLocaleOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setLocaleOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetLocaleOverrideReturns {}
+        impl chromiumoxide_types::Command for SetLocaleOverrideParams {
+            type Response = SetLocaleOverrideReturns;
+        }
+        #[doc = "Overrides default host system timezone with the specified one.\n[setTimezoneOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setTimezoneOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetTimezoneOverrideParams {
+            #[doc = "The timezone identifier. List of supported timezones:\nhttps://source.chromium.org/chromium/chromium/deps/icu.git/+/faee8bc70570192d82d2978a71e2a615788597d1:source/data/misc/metaZones.txt\nIf empty, disables the override and restores default host system timezone."]
+            #[serde(rename = "timezoneId")]
+            pub timezone_id: String,
+        }
+        impl SetTimezoneOverrideParams {
+            pub fn new(timezone_id: impl Into<String>) -> Self {
+                Self {
+                    timezone_id: timezone_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for SetTimezoneOverrideParams {
+            fn from(url: T) -> Self {
+                SetTimezoneOverrideParams::new(url)
+            }
+        }
+        impl SetTimezoneOverrideParams {
+            pub fn builder() -> SetTimezoneOverrideParamsBuilder {
+                SetTimezoneOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetTimezoneOverrideParamsBuilder {
+            timezone_id: Option<String>,
+        }
+        impl SetTimezoneOverrideParamsBuilder {
+            pub fn timezone_id(mut self, timezone_id: impl Into<String>) -> Self {
+                self.timezone_id = Some(timezone_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SetTimezoneOverrideParams, String> {
+                Ok(SetTimezoneOverrideParams {
+                    timezone_id: self.timezone_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(timezone_id))
+                    })?,
+                })
+            }
+        }
+        impl SetTimezoneOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setTimezoneOverride";
+        }
+        impl chromiumoxide_types::Method for SetTimezoneOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetTimezoneOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Overrides default host system timezone with the specified one.\n[setTimezoneOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setTimezoneOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetTimezoneOverrideReturns {}
+        impl chromiumoxide_types::Command for SetTimezoneOverrideParams {
+            type Response = SetTimezoneOverrideReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDisabledImageTypesParams {
+            #[doc = "Image types to disable."]
+            #[serde(rename = "imageTypes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub image_types: Vec<DisabledImageType>,
+        }
+        impl SetDisabledImageTypesParams {
+            pub fn new(image_types: Vec<DisabledImageType>) -> Self {
+                Self { image_types }
+            }
+        }
+        impl SetDisabledImageTypesParams {
+            pub fn builder() -> SetDisabledImageTypesParamsBuilder {
+                SetDisabledImageTypesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDisabledImageTypesParamsBuilder {
+            image_types: Option<Vec<DisabledImageType>>,
+        }
+        impl SetDisabledImageTypesParamsBuilder {
+            pub fn image_type(mut self, image_type: impl Into<DisabledImageType>) -> Self {
+                let v = self.image_types.get_or_insert(Vec::new());
+                v.push(image_type.into());
+                self
+            }
+            pub fn image_types<I, S>(mut self, image_types: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<DisabledImageType>,
+            {
+                let v = self.image_types.get_or_insert(Vec::new());
+                for val in image_types {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetDisabledImageTypesParams, String> {
+                Ok(SetDisabledImageTypesParams {
+                    image_types: self.image_types.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(image_types))
+                    })?,
+                })
+            }
+        }
+        impl SetDisabledImageTypesParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setDisabledImageTypes";
+        }
+        impl chromiumoxide_types::Method for SetDisabledImageTypesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDisabledImageTypesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDisabledImageTypesReturns {}
+        impl chromiumoxide_types::Command for SetDisabledImageTypesParams {
+            type Response = SetDisabledImageTypesReturns;
+        }
+        #[doc = "Override the value of navigator.connection.saveData\n[setDataSaverOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setDataSaverOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDataSaverOverrideParams {
+            #[doc = "Override value. Omitting the parameter disables the override."]
+            #[serde(rename = "dataSaverEnabled")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub data_saver_enabled: Option<bool>,
+        }
+        impl SetDataSaverOverrideParams {
+            pub fn builder() -> SetDataSaverOverrideParamsBuilder {
+                SetDataSaverOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDataSaverOverrideParamsBuilder {
+            data_saver_enabled: Option<bool>,
+        }
+        impl SetDataSaverOverrideParamsBuilder {
+            pub fn data_saver_enabled(mut self, data_saver_enabled: impl Into<bool>) -> Self {
+                self.data_saver_enabled = Some(data_saver_enabled.into());
+                self
+            }
+            pub fn build(self) -> SetDataSaverOverrideParams {
+                SetDataSaverOverrideParams {
+                    data_saver_enabled: self.data_saver_enabled,
+                }
+            }
+        }
+        impl SetDataSaverOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setDataSaverOverride";
+        }
+        impl chromiumoxide_types::Method for SetDataSaverOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDataSaverOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Override the value of navigator.connection.saveData\n[setDataSaverOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setDataSaverOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDataSaverOverrideReturns {}
+        impl chromiumoxide_types::Command for SetDataSaverOverrideParams {
+            type Response = SetDataSaverOverrideReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetHardwareConcurrencyOverrideParams {
+            #[doc = "Hardware concurrency to report"]
+            #[serde(rename = "hardwareConcurrency")]
+            pub hardware_concurrency: i64,
+        }
+        impl SetHardwareConcurrencyOverrideParams {
+            pub fn new(hardware_concurrency: impl Into<i64>) -> Self {
+                Self {
+                    hardware_concurrency: hardware_concurrency.into(),
+                }
+            }
+        }
+        impl SetHardwareConcurrencyOverrideParams {
+            pub fn builder() -> SetHardwareConcurrencyOverrideParamsBuilder {
+                SetHardwareConcurrencyOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetHardwareConcurrencyOverrideParamsBuilder {
+            hardware_concurrency: Option<i64>,
+        }
+        impl SetHardwareConcurrencyOverrideParamsBuilder {
+            pub fn hardware_concurrency(mut self, hardware_concurrency: impl Into<i64>) -> Self {
+                self.hardware_concurrency = Some(hardware_concurrency.into());
+                self
+            }
+            pub fn build(self) -> Result<SetHardwareConcurrencyOverrideParams, String> {
+                Ok(SetHardwareConcurrencyOverrideParams {
+                    hardware_concurrency: self.hardware_concurrency.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(hardware_concurrency)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl SetHardwareConcurrencyOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setHardwareConcurrencyOverride";
+        }
+        impl chromiumoxide_types::Method for SetHardwareConcurrencyOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetHardwareConcurrencyOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetHardwareConcurrencyOverrideReturns {}
+        impl chromiumoxide_types::Command for SetHardwareConcurrencyOverrideParams {
+            type Response = SetHardwareConcurrencyOverrideReturns;
+        }
+        #[doc = "Allows overriding user agent with the given string.\n`userAgentMetadata` must be set for Client Hint headers to be sent.\n[setUserAgentOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setUserAgentOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetUserAgentOverrideParams {
+            #[doc = "User agent to use."]
+            #[serde(rename = "userAgent")]
+            pub user_agent: String,
+            #[doc = "Browser language to emulate."]
+            #[serde(rename = "acceptLanguage")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub accept_language: Option<String>,
+            #[doc = "The platform navigator.platform should return."]
+            #[serde(rename = "platform")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub platform: Option<String>,
+            #[doc = "To be sent in Sec-CH-UA-* headers and returned in navigator.userAgentData"]
+            #[serde(rename = "userAgentMetadata")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub user_agent_metadata: Option<UserAgentMetadata>,
+        }
+        impl SetUserAgentOverrideParams {
+            pub fn new(user_agent: impl Into<String>) -> Self {
+                Self {
+                    user_agent: user_agent.into(),
+                    accept_language: None,
+                    platform: None,
+                    user_agent_metadata: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for SetUserAgentOverrideParams {
+            fn from(url: T) -> Self {
+                SetUserAgentOverrideParams::new(url)
+            }
+        }
+        impl SetUserAgentOverrideParams {
+            pub fn builder() -> SetUserAgentOverrideParamsBuilder {
+                SetUserAgentOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetUserAgentOverrideParamsBuilder {
+            user_agent: Option<String>,
+            accept_language: Option<String>,
+            platform: Option<String>,
+            user_agent_metadata: Option<UserAgentMetadata>,
+        }
+        impl SetUserAgentOverrideParamsBuilder {
+            pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
+                self.user_agent = Some(user_agent.into());
+                self
+            }
+            pub fn accept_language(mut self, accept_language: impl Into<String>) -> Self {
+                self.accept_language = Some(accept_language.into());
+                self
+            }
+            pub fn platform(mut self, platform: impl Into<String>) -> Self {
+                self.platform = Some(platform.into());
+                self
+            }
+            pub fn user_agent_metadata(
+                mut self,
+                user_agent_metadata: impl Into<UserAgentMetadata>,
+            ) -> Self {
+                self.user_agent_metadata = Some(user_agent_metadata.into());
+                self
+            }
+            pub fn build(self) -> Result<SetUserAgentOverrideParams, String> {
+                Ok(SetUserAgentOverrideParams {
+                    user_agent: self.user_agent.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(user_agent))
+                    })?,
+                    accept_language: self.accept_language,
+                    platform: self.platform,
+                    user_agent_metadata: self.user_agent_metadata,
+                })
+            }
+        }
+        impl SetUserAgentOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setUserAgentOverride";
+        }
+        impl chromiumoxide_types::Method for SetUserAgentOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetUserAgentOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Allows overriding user agent with the given string.\n`userAgentMetadata` must be set for Client Hint headers to be sent.\n[setUserAgentOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setUserAgentOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetUserAgentOverrideReturns {}
+        impl chromiumoxide_types::Command for SetUserAgentOverrideParams {
+            type Response = SetUserAgentOverrideReturns;
+        }
+        #[doc = "Allows overriding the automation flag.\n[setAutomationOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setAutomationOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAutomationOverrideParams {
+            #[doc = "Whether the override should be enabled."]
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetAutomationOverrideParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetAutomationOverrideParams {
+            pub fn builder() -> SetAutomationOverrideParamsBuilder {
+                SetAutomationOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAutomationOverrideParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetAutomationOverrideParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAutomationOverrideParams, String> {
+                Ok(SetAutomationOverrideParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetAutomationOverrideParams {
+            pub const IDENTIFIER: &'static str = "Emulation.setAutomationOverride";
+        }
+        impl chromiumoxide_types::Method for SetAutomationOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAutomationOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Allows overriding the automation flag.\n[setAutomationOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setAutomationOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAutomationOverrideReturns {}
+        impl chromiumoxide_types::Command for SetAutomationOverrideParams {
+            type Response = SetAutomationOverrideReturns;
+        }
+        #[doc = "Allows overriding the difference between the small and large viewport sizes, which determine the\nvalue of the `svh` and `lvh` unit, respectively. Only supported for top-level frames.\n[setSmallViewportHeightDifferenceOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setSmallViewportHeightDifferenceOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSmallViewportHeightDifferenceOverrideParams {
+            #[doc = "This will cause an element of size 100svh to be `difference` pixels smaller than an element\nof size 100lvh."]
+            #[serde(rename = "difference")]
+            pub difference: i64,
+        }
+        impl SetSmallViewportHeightDifferenceOverrideParams {
+            pub fn new(difference: impl Into<i64>) -> Self {
+                Self {
+                    difference: difference.into(),
+                }
+            }
+        }
+        impl SetSmallViewportHeightDifferenceOverrideParams {
+            pub fn builder() -> SetSmallViewportHeightDifferenceOverrideParamsBuilder {
+                SetSmallViewportHeightDifferenceOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSmallViewportHeightDifferenceOverrideParamsBuilder {
+            difference: Option<i64>,
+        }
+        impl SetSmallViewportHeightDifferenceOverrideParamsBuilder {
+            pub fn difference(mut self, difference: impl Into<i64>) -> Self {
+                self.difference = Some(difference.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSmallViewportHeightDifferenceOverrideParams, String> {
+                Ok(SetSmallViewportHeightDifferenceOverrideParams {
+                    difference: self.difference.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(difference))
+                    })?,
+                })
+            }
+        }
+        impl SetSmallViewportHeightDifferenceOverrideParams {
+            pub const IDENTIFIER: &'static str =
+                "Emulation.setSmallViewportHeightDifferenceOverride";
+        }
+        impl chromiumoxide_types::Method for SetSmallViewportHeightDifferenceOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSmallViewportHeightDifferenceOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Allows overriding the difference between the small and large viewport sizes, which determine the\nvalue of the `svh` and `lvh` unit, respectively. Only supported for top-level frames.\n[setSmallViewportHeightDifferenceOverride](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-setSmallViewportHeightDifferenceOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSmallViewportHeightDifferenceOverrideReturns {}
+        impl chromiumoxide_types::Command for SetSmallViewportHeightDifferenceOverrideParams {
+            type Response = SetSmallViewportHeightDifferenceOverrideReturns;
+        }
+        #[doc = "Returns device's screen configuration.\n[getScreenInfos](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-getScreenInfos)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetScreenInfosParams {}
+        impl GetScreenInfosParams {
+            pub const IDENTIFIER: &'static str = "Emulation.getScreenInfos";
+        }
+        impl chromiumoxide_types::Method for GetScreenInfosParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetScreenInfosParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns device's screen configuration.\n[getScreenInfos](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-getScreenInfos)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetScreenInfosReturns {
+            #[serde(rename = "screenInfos")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub screen_infos: Vec<ScreenInfo>,
+        }
+        impl GetScreenInfosReturns {
+            pub fn new(screen_infos: Vec<ScreenInfo>) -> Self {
+                Self { screen_infos }
+            }
+        }
+        impl GetScreenInfosReturns {
+            pub fn builder() -> GetScreenInfosReturnsBuilder {
+                GetScreenInfosReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetScreenInfosReturnsBuilder {
+            screen_infos: Option<Vec<ScreenInfo>>,
+        }
+        impl GetScreenInfosReturnsBuilder {
+            pub fn screen_info(mut self, screen_info: impl Into<ScreenInfo>) -> Self {
+                let v = self.screen_infos.get_or_insert(Vec::new());
+                v.push(screen_info.into());
+                self
+            }
+            pub fn screen_infos<I, S>(mut self, screen_infos: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ScreenInfo>,
+            {
+                let v = self.screen_infos.get_or_insert(Vec::new());
+                for val in screen_infos {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetScreenInfosReturns, String> {
+                Ok(GetScreenInfosReturns {
+                    screen_infos: self.screen_infos.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(screen_infos))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetScreenInfosParams {
+            type Response = GetScreenInfosReturns;
+        }
+        #[doc = "Add a new screen to the device. Only supported in headless mode.\n[addScreen](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-addScreen)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddScreenParams {
+            #[doc = "Offset of the left edge of the screen in pixels."]
+            #[serde(rename = "left")]
+            pub left: i64,
+            #[doc = "Offset of the top edge of the screen in pixels."]
+            #[serde(rename = "top")]
+            pub top: i64,
+            #[doc = "The width of the screen in pixels."]
+            #[serde(rename = "width")]
+            pub width: i64,
+            #[doc = "The height of the screen in pixels."]
+            #[serde(rename = "height")]
+            pub height: i64,
+            #[doc = "Specifies the screen's work area. Default is entire screen."]
+            #[serde(rename = "workAreaInsets")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub work_area_insets: Option<WorkAreaInsets>,
+            #[doc = "Specifies the screen's device pixel ratio. Default is 1."]
+            #[serde(rename = "devicePixelRatio")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub device_pixel_ratio: Option<f64>,
+            #[doc = "Specifies the screen's rotation angle. Available values are 0, 90, 180 and 270. Default is 0."]
+            #[serde(rename = "rotation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub rotation: Option<i64>,
+            #[doc = "Specifies the screen's color depth in bits. Default is 24."]
+            #[serde(rename = "colorDepth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub color_depth: Option<i64>,
+            #[doc = "Specifies the descriptive label for the screen. Default is none."]
+            #[serde(rename = "label")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub label: Option<String>,
+            #[doc = "Indicates whether the screen is internal to the device or external, attached to the device. Default is false."]
+            #[serde(rename = "isInternal")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_internal: Option<bool>,
+        }
+        impl AddScreenParams {
+            pub fn new(
+                left: impl Into<i64>,
+                top: impl Into<i64>,
+                width: impl Into<i64>,
+                height: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    left: left.into(),
+                    top: top.into(),
+                    width: width.into(),
+                    height: height.into(),
+                    work_area_insets: None,
+                    device_pixel_ratio: None,
+                    rotation: None,
+                    color_depth: None,
+                    label: None,
+                    is_internal: None,
+                }
+            }
+        }
+        impl AddScreenParams {
+            pub fn builder() -> AddScreenParamsBuilder {
+                AddScreenParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddScreenParamsBuilder {
+            left: Option<i64>,
+            top: Option<i64>,
+            width: Option<i64>,
+            height: Option<i64>,
+            work_area_insets: Option<WorkAreaInsets>,
+            device_pixel_ratio: Option<f64>,
+            rotation: Option<i64>,
+            color_depth: Option<i64>,
+            label: Option<String>,
+            is_internal: Option<bool>,
+        }
+        impl AddScreenParamsBuilder {
+            pub fn left(mut self, left: impl Into<i64>) -> Self {
+                self.left = Some(left.into());
+                self
+            }
+            pub fn top(mut self, top: impl Into<i64>) -> Self {
+                self.top = Some(top.into());
+                self
+            }
+            pub fn width(mut self, width: impl Into<i64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<i64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn work_area_insets(mut self, work_area_insets: impl Into<WorkAreaInsets>) -> Self {
+                self.work_area_insets = Some(work_area_insets.into());
+                self
+            }
+            pub fn device_pixel_ratio(mut self, device_pixel_ratio: impl Into<f64>) -> Self {
+                self.device_pixel_ratio = Some(device_pixel_ratio.into());
+                self
+            }
+            pub fn rotation(mut self, rotation: impl Into<i64>) -> Self {
+                self.rotation = Some(rotation.into());
+                self
+            }
+            pub fn color_depth(mut self, color_depth: impl Into<i64>) -> Self {
+                self.color_depth = Some(color_depth.into());
+                self
+            }
+            pub fn label(mut self, label: impl Into<String>) -> Self {
+                self.label = Some(label.into());
+                self
+            }
+            pub fn is_internal(mut self, is_internal: impl Into<bool>) -> Self {
+                self.is_internal = Some(is_internal.into());
+                self
+            }
+            pub fn build(self) -> Result<AddScreenParams, String> {
+                Ok(AddScreenParams {
+                    left: self.left.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(left))
+                    })?,
+                    top: self
+                        .top
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(top)))?,
+                    width: self.width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(width))
+                    })?,
+                    height: self.height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(height))
+                    })?,
+                    work_area_insets: self.work_area_insets,
+                    device_pixel_ratio: self.device_pixel_ratio,
+                    rotation: self.rotation,
+                    color_depth: self.color_depth,
+                    label: self.label,
+                    is_internal: self.is_internal,
+                })
+            }
+        }
+        impl AddScreenParams {
+            pub const IDENTIFIER: &'static str = "Emulation.addScreen";
+        }
+        impl chromiumoxide_types::Method for AddScreenParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddScreenParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Add a new screen to the device. Only supported in headless mode.\n[addScreen](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-addScreen)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddScreenReturns {
+            #[serde(rename = "screenInfo")]
+            pub screen_info: ScreenInfo,
+        }
+        impl AddScreenReturns {
+            pub fn new(screen_info: impl Into<ScreenInfo>) -> Self {
+                Self {
+                    screen_info: screen_info.into(),
+                }
+            }
+        }
+        impl AddScreenReturns {
+            pub fn builder() -> AddScreenReturnsBuilder {
+                AddScreenReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddScreenReturnsBuilder {
+            screen_info: Option<ScreenInfo>,
+        }
+        impl AddScreenReturnsBuilder {
+            pub fn screen_info(mut self, screen_info: impl Into<ScreenInfo>) -> Self {
+                self.screen_info = Some(screen_info.into());
+                self
+            }
+            pub fn build(self) -> Result<AddScreenReturns, String> {
+                Ok(AddScreenReturns {
+                    screen_info: self.screen_info.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(screen_info))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for AddScreenParams {
+            type Response = AddScreenReturns;
+        }
+        #[doc = "Remove screen from the device. Only supported in headless mode.\n[removeScreen](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-removeScreen)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveScreenParams {
+            #[serde(rename = "screenId")]
+            pub screen_id: ScreenId,
+        }
+        impl RemoveScreenParams {
+            pub fn new(screen_id: impl Into<ScreenId>) -> Self {
+                Self {
+                    screen_id: screen_id.into(),
+                }
+            }
+        }
+        impl RemoveScreenParams {
+            pub fn builder() -> RemoveScreenParamsBuilder {
+                RemoveScreenParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveScreenParamsBuilder {
+            screen_id: Option<ScreenId>,
+        }
+        impl RemoveScreenParamsBuilder {
+            pub fn screen_id(mut self, screen_id: impl Into<ScreenId>) -> Self {
+                self.screen_id = Some(screen_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveScreenParams, String> {
+                Ok(RemoveScreenParams {
+                    screen_id: self.screen_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(screen_id))
+                    })?,
+                })
+            }
+        }
+        impl RemoveScreenParams {
+            pub const IDENTIFIER: &'static str = "Emulation.removeScreen";
+        }
+        impl chromiumoxide_types::Method for RemoveScreenParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveScreenParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Remove screen from the device. Only supported in headless mode.\n[removeScreen](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#method-removeScreen)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveScreenReturns {}
+        impl chromiumoxide_types::Command for RemoveScreenParams {
+            type Response = RemoveScreenReturns;
+        }
+        #[doc = "Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.\n[virtualTimeBudgetExpired](https://chromedevtools.github.io/devtools-protocol/tot/Emulation/#event-virtualTimeBudgetExpired)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventVirtualTimeBudgetExpired {}
+        impl EventVirtualTimeBudgetExpired {
+            pub const IDENTIFIER: &'static str = "Emulation.virtualTimeBudgetExpired";
+        }
+        impl chromiumoxide_types::Method for EventVirtualTimeBudgetExpired {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventVirtualTimeBudgetExpired {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "EventBreakpoints permits setting JavaScript breakpoints on operations and events\noccurring in native code invoked from JavaScript. Once breakpoint is hit, it is\nreported through Debugger domain, similarly to regular breakpoints being hit."]
+    pub mod event_breakpoints {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Sets breakpoint on particular native event.\n[setInstrumentationBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/EventBreakpoints/#method-setInstrumentationBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetInstrumentationBreakpointParams {
+            #[doc = "Instrumentation name to stop on."]
+            #[serde(rename = "eventName")]
+            pub event_name: String,
+        }
+        impl SetInstrumentationBreakpointParams {
+            pub fn new(event_name: impl Into<String>) -> Self {
+                Self {
+                    event_name: event_name.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for SetInstrumentationBreakpointParams {
+            fn from(url: T) -> Self {
+                SetInstrumentationBreakpointParams::new(url)
+            }
+        }
+        impl SetInstrumentationBreakpointParams {
+            pub fn builder() -> SetInstrumentationBreakpointParamsBuilder {
+                SetInstrumentationBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetInstrumentationBreakpointParamsBuilder {
+            event_name: Option<String>,
+        }
+        impl SetInstrumentationBreakpointParamsBuilder {
+            pub fn event_name(mut self, event_name: impl Into<String>) -> Self {
+                self.event_name = Some(event_name.into());
+                self
+            }
+            pub fn build(self) -> Result<SetInstrumentationBreakpointParams, String> {
+                Ok(SetInstrumentationBreakpointParams {
+                    event_name: self.event_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(event_name))
+                    })?,
+                })
+            }
+        }
+        impl SetInstrumentationBreakpointParams {
+            pub const IDENTIFIER: &'static str = "EventBreakpoints.setInstrumentationBreakpoint";
+        }
+        impl chromiumoxide_types::Method for SetInstrumentationBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetInstrumentationBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets breakpoint on particular native event.\n[setInstrumentationBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/EventBreakpoints/#method-setInstrumentationBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetInstrumentationBreakpointReturns {}
+        impl chromiumoxide_types::Command for SetInstrumentationBreakpointParams {
+            type Response = SetInstrumentationBreakpointReturns;
+        }
+        #[doc = "Removes breakpoint on particular native event.\n[removeInstrumentationBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/EventBreakpoints/#method-removeInstrumentationBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveInstrumentationBreakpointParams {
+            #[doc = "Instrumentation name to stop on."]
+            #[serde(rename = "eventName")]
+            pub event_name: String,
+        }
+        impl RemoveInstrumentationBreakpointParams {
+            pub fn new(event_name: impl Into<String>) -> Self {
+                Self {
+                    event_name: event_name.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for RemoveInstrumentationBreakpointParams {
+            fn from(url: T) -> Self {
+                RemoveInstrumentationBreakpointParams::new(url)
+            }
+        }
+        impl RemoveInstrumentationBreakpointParams {
+            pub fn builder() -> RemoveInstrumentationBreakpointParamsBuilder {
+                RemoveInstrumentationBreakpointParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveInstrumentationBreakpointParamsBuilder {
+            event_name: Option<String>,
+        }
+        impl RemoveInstrumentationBreakpointParamsBuilder {
+            pub fn event_name(mut self, event_name: impl Into<String>) -> Self {
+                self.event_name = Some(event_name.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveInstrumentationBreakpointParams, String> {
+                Ok(RemoveInstrumentationBreakpointParams {
+                    event_name: self.event_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(event_name))
+                    })?,
+                })
+            }
+        }
+        impl RemoveInstrumentationBreakpointParams {
+            pub const IDENTIFIER: &'static str = "EventBreakpoints.removeInstrumentationBreakpoint";
+        }
+        impl chromiumoxide_types::Method for RemoveInstrumentationBreakpointParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveInstrumentationBreakpointParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes breakpoint on particular native event.\n[removeInstrumentationBreakpoint](https://chromedevtools.github.io/devtools-protocol/tot/EventBreakpoints/#method-removeInstrumentationBreakpoint)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveInstrumentationBreakpointReturns {}
+        impl chromiumoxide_types::Command for RemoveInstrumentationBreakpointParams {
+            type Response = RemoveInstrumentationBreakpointReturns;
+        }
+        #[doc = "Removes all breakpoints\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/EventBreakpoints/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "EventBreakpoints.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes all breakpoints\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/EventBreakpoints/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+    }
+    #[doc = "Defines commands and events for browser extensions."]
+    pub mod extensions {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Storage areas."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum StorageArea {
+            #[serde(rename = "session")]
+            Session,
+            #[serde(rename = "local")]
+            Local,
+            #[serde(rename = "sync")]
+            Sync,
+            #[serde(rename = "managed")]
+            Managed,
+        }
+        impl AsRef<str> for StorageArea {
+            fn as_ref(&self) -> &str {
+                match self {
+                    StorageArea::Session => "session",
+                    StorageArea::Local => "local",
+                    StorageArea::Sync => "sync",
+                    StorageArea::Managed => "managed",
+                }
+            }
+        }
+        impl ::std::str::FromStr for StorageArea {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "session" | "Session" => Ok(StorageArea::Session),
+                    "local" | "Local" => Ok(StorageArea::Local),
+                    "sync" | "Sync" => Ok(StorageArea::Sync),
+                    "managed" | "Managed" => Ok(StorageArea::Managed),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Installs an unpacked extension from the filesystem similar to\n--load-extension CLI flags. Returns extension ID once the extension\nhas been installed. Available if the client is connected using the\n--remote-debugging-pipe flag and the --enable-unsafe-extension-debugging\nflag is set.\n[loadUnpacked](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-loadUnpacked)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LoadUnpackedParams {
+            #[doc = "Absolute file path."]
+            #[serde(rename = "path")]
+            pub path: String,
+        }
+        impl LoadUnpackedParams {
+            pub fn new(path: impl Into<String>) -> Self {
+                Self { path: path.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for LoadUnpackedParams {
+            fn from(url: T) -> Self {
+                LoadUnpackedParams::new(url)
+            }
+        }
+        impl LoadUnpackedParams {
+            pub fn builder() -> LoadUnpackedParamsBuilder {
+                LoadUnpackedParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LoadUnpackedParamsBuilder {
+            path: Option<String>,
+        }
+        impl LoadUnpackedParamsBuilder {
+            pub fn path(mut self, path: impl Into<String>) -> Self {
+                self.path = Some(path.into());
+                self
+            }
+            pub fn build(self) -> Result<LoadUnpackedParams, String> {
+                Ok(LoadUnpackedParams {
+                    path: self.path.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(path))
+                    })?,
+                })
+            }
+        }
+        impl LoadUnpackedParams {
+            pub const IDENTIFIER: &'static str = "Extensions.loadUnpacked";
+        }
+        impl chromiumoxide_types::Method for LoadUnpackedParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for LoadUnpackedParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Installs an unpacked extension from the filesystem similar to\n--load-extension CLI flags. Returns extension ID once the extension\nhas been installed. Available if the client is connected using the\n--remote-debugging-pipe flag and the --enable-unsafe-extension-debugging\nflag is set.\n[loadUnpacked](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-loadUnpacked)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LoadUnpackedReturns {
+            #[doc = "Extension id."]
+            #[serde(rename = "id")]
+            pub id: String,
+        }
+        impl LoadUnpackedReturns {
+            pub fn new(id: impl Into<String>) -> Self {
+                Self { id: id.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for LoadUnpackedReturns {
+            fn from(url: T) -> Self {
+                LoadUnpackedReturns::new(url)
+            }
+        }
+        impl LoadUnpackedReturns {
+            pub fn builder() -> LoadUnpackedReturnsBuilder {
+                LoadUnpackedReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LoadUnpackedReturnsBuilder {
+            id: Option<String>,
+        }
+        impl LoadUnpackedReturnsBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn build(self) -> Result<LoadUnpackedReturns, String> {
+                Ok(LoadUnpackedReturns {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for LoadUnpackedParams {
+            type Response = LoadUnpackedReturns;
+        }
+        #[doc = "Uninstalls an unpacked extension (others not supported) from the profile.\nAvailable if the client is connected using the --remote-debugging-pipe flag\nand the --enable-unsafe-extension-debugging.\n[uninstall](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-uninstall)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UninstallParams {
+            #[doc = "Extension id."]
+            #[serde(rename = "id")]
+            pub id: String,
+        }
+        impl UninstallParams {
+            pub fn new(id: impl Into<String>) -> Self {
+                Self { id: id.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for UninstallParams {
+            fn from(url: T) -> Self {
+                UninstallParams::new(url)
+            }
+        }
+        impl UninstallParams {
+            pub fn builder() -> UninstallParamsBuilder {
+                UninstallParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UninstallParamsBuilder {
+            id: Option<String>,
+        }
+        impl UninstallParamsBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn build(self) -> Result<UninstallParams, String> {
+                Ok(UninstallParams {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                })
+            }
+        }
+        impl UninstallParams {
+            pub const IDENTIFIER: &'static str = "Extensions.uninstall";
+        }
+        impl chromiumoxide_types::Method for UninstallParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for UninstallParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Uninstalls an unpacked extension (others not supported) from the profile.\nAvailable if the client is connected using the --remote-debugging-pipe flag\nand the --enable-unsafe-extension-debugging.\n[uninstall](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-uninstall)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UninstallReturns {}
+        impl chromiumoxide_types::Command for UninstallParams {
+            type Response = UninstallReturns;
+        }
+        #[doc = "Gets data from extension storage in the given `storageArea`. If `keys` is\nspecified, these are used to filter the result.\n[getStorageItems](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-getStorageItems)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetStorageItemsParams {
+            #[doc = "ID of extension."]
+            #[serde(rename = "id")]
+            pub id: String,
+            #[doc = "StorageArea to retrieve data from."]
+            #[serde(rename = "storageArea")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub storage_area: StorageArea,
+            #[doc = "Keys to retrieve."]
+            #[serde(rename = "keys")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub keys: Option<Vec<String>>,
+        }
+        impl GetStorageItemsParams {
+            pub fn new(id: impl Into<String>, storage_area: impl Into<StorageArea>) -> Self {
+                Self {
+                    id: id.into(),
+                    storage_area: storage_area.into(),
+                    keys: None,
+                }
+            }
+        }
+        impl GetStorageItemsParams {
+            pub fn builder() -> GetStorageItemsParamsBuilder {
+                GetStorageItemsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetStorageItemsParamsBuilder {
+            id: Option<String>,
+            storage_area: Option<StorageArea>,
+            keys: Option<Vec<String>>,
+        }
+        impl GetStorageItemsParamsBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn storage_area(mut self, storage_area: impl Into<StorageArea>) -> Self {
+                self.storage_area = Some(storage_area.into());
+                self
+            }
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                let v = self.keys.get_or_insert(Vec::new());
+                v.push(key.into());
+                self
+            }
+            pub fn keys<I, S>(mut self, keys: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.keys.get_or_insert(Vec::new());
+                for val in keys {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetStorageItemsParams, String> {
+                Ok(GetStorageItemsParams {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    storage_area: self.storage_area.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_area))
+                    })?,
+                    keys: self.keys,
+                })
+            }
+        }
+        impl GetStorageItemsParams {
+            pub const IDENTIFIER: &'static str = "Extensions.getStorageItems";
+        }
+        impl chromiumoxide_types::Method for GetStorageItemsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetStorageItemsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets data from extension storage in the given `storageArea`. If `keys` is\nspecified, these are used to filter the result.\n[getStorageItems](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-getStorageItems)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetStorageItemsReturns {
+            #[serde(rename = "data")]
+            pub data: serde_json::Value,
+        }
+        impl GetStorageItemsReturns {
+            pub fn new(data: impl Into<serde_json::Value>) -> Self {
+                Self { data: data.into() }
+            }
+        }
+        impl GetStorageItemsReturns {
+            pub fn builder() -> GetStorageItemsReturnsBuilder {
+                GetStorageItemsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetStorageItemsReturnsBuilder {
+            data: Option<serde_json::Value>,
+        }
+        impl GetStorageItemsReturnsBuilder {
+            pub fn data(mut self, data: impl Into<serde_json::Value>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn build(self) -> Result<GetStorageItemsReturns, String> {
+                Ok(GetStorageItemsReturns {
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetStorageItemsParams {
+            type Response = GetStorageItemsReturns;
+        }
+        #[doc = "Removes `keys` from extension storage in the given `storageArea`.\n[removeStorageItems](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-removeStorageItems)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveStorageItemsParams {
+            #[doc = "ID of extension."]
+            #[serde(rename = "id")]
+            pub id: String,
+            #[doc = "StorageArea to remove data from."]
+            #[serde(rename = "storageArea")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub storage_area: StorageArea,
+            #[doc = "Keys to remove."]
+            #[serde(rename = "keys")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub keys: Vec<String>,
+        }
+        impl RemoveStorageItemsParams {
+            pub fn new(
+                id: impl Into<String>,
+                storage_area: impl Into<StorageArea>,
+                keys: Vec<String>,
+            ) -> Self {
+                Self {
+                    id: id.into(),
+                    storage_area: storage_area.into(),
+                    keys,
+                }
+            }
+        }
+        impl RemoveStorageItemsParams {
+            pub fn builder() -> RemoveStorageItemsParamsBuilder {
+                RemoveStorageItemsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveStorageItemsParamsBuilder {
+            id: Option<String>,
+            storage_area: Option<StorageArea>,
+            keys: Option<Vec<String>>,
+        }
+        impl RemoveStorageItemsParamsBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn storage_area(mut self, storage_area: impl Into<StorageArea>) -> Self {
+                self.storage_area = Some(storage_area.into());
+                self
+            }
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                let v = self.keys.get_or_insert(Vec::new());
+                v.push(key.into());
+                self
+            }
+            pub fn keys<I, S>(mut self, keys: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.keys.get_or_insert(Vec::new());
+                for val in keys {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<RemoveStorageItemsParams, String> {
+                Ok(RemoveStorageItemsParams {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    storage_area: self.storage_area.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_area))
+                    })?,
+                    keys: self.keys.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(keys))
+                    })?,
+                })
+            }
+        }
+        impl RemoveStorageItemsParams {
+            pub const IDENTIFIER: &'static str = "Extensions.removeStorageItems";
+        }
+        impl chromiumoxide_types::Method for RemoveStorageItemsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveStorageItemsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes `keys` from extension storage in the given `storageArea`.\n[removeStorageItems](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-removeStorageItems)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveStorageItemsReturns {}
+        impl chromiumoxide_types::Command for RemoveStorageItemsParams {
+            type Response = RemoveStorageItemsReturns;
+        }
+        #[doc = "Clears extension storage in the given `storageArea`.\n[clearStorageItems](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-clearStorageItems)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClearStorageItemsParams {
+            #[doc = "ID of extension."]
+            #[serde(rename = "id")]
+            pub id: String,
+            #[doc = "StorageArea to remove data from."]
+            #[serde(rename = "storageArea")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub storage_area: StorageArea,
+        }
+        impl ClearStorageItemsParams {
+            pub fn new(id: impl Into<String>, storage_area: impl Into<StorageArea>) -> Self {
+                Self {
+                    id: id.into(),
+                    storage_area: storage_area.into(),
+                }
+            }
+        }
+        impl ClearStorageItemsParams {
+            pub fn builder() -> ClearStorageItemsParamsBuilder {
+                ClearStorageItemsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearStorageItemsParamsBuilder {
+            id: Option<String>,
+            storage_area: Option<StorageArea>,
+        }
+        impl ClearStorageItemsParamsBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn storage_area(mut self, storage_area: impl Into<StorageArea>) -> Self {
+                self.storage_area = Some(storage_area.into());
+                self
+            }
+            pub fn build(self) -> Result<ClearStorageItemsParams, String> {
+                Ok(ClearStorageItemsParams {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    storage_area: self.storage_area.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_area))
+                    })?,
+                })
+            }
+        }
+        impl ClearStorageItemsParams {
+            pub const IDENTIFIER: &'static str = "Extensions.clearStorageItems";
+        }
+        impl chromiumoxide_types::Method for ClearStorageItemsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearStorageItemsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears extension storage in the given `storageArea`.\n[clearStorageItems](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-clearStorageItems)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearStorageItemsReturns {}
+        impl chromiumoxide_types::Command for ClearStorageItemsParams {
+            type Response = ClearStorageItemsReturns;
+        }
+        #[doc = "Sets `values` in extension storage in the given `storageArea`. The provided `values`\nwill be merged with existing values in the storage area.\n[setStorageItems](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-setStorageItems)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetStorageItemsParams {
+            #[doc = "ID of extension."]
+            #[serde(rename = "id")]
+            pub id: String,
+            #[doc = "StorageArea to set data in."]
+            #[serde(rename = "storageArea")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub storage_area: StorageArea,
+            #[doc = "Values to set."]
+            #[serde(rename = "values")]
+            pub values: serde_json::Value,
+        }
+        impl SetStorageItemsParams {
+            pub fn new(
+                id: impl Into<String>,
+                storage_area: impl Into<StorageArea>,
+                values: impl Into<serde_json::Value>,
+            ) -> Self {
+                Self {
+                    id: id.into(),
+                    storage_area: storage_area.into(),
+                    values: values.into(),
+                }
+            }
+        }
+        impl SetStorageItemsParams {
+            pub fn builder() -> SetStorageItemsParamsBuilder {
+                SetStorageItemsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetStorageItemsParamsBuilder {
+            id: Option<String>,
+            storage_area: Option<StorageArea>,
+            values: Option<serde_json::Value>,
+        }
+        impl SetStorageItemsParamsBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn storage_area(mut self, storage_area: impl Into<StorageArea>) -> Self {
+                self.storage_area = Some(storage_area.into());
+                self
+            }
+            pub fn values(mut self, values: impl Into<serde_json::Value>) -> Self {
+                self.values = Some(values.into());
+                self
+            }
+            pub fn build(self) -> Result<SetStorageItemsParams, String> {
+                Ok(SetStorageItemsParams {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    storage_area: self.storage_area.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_area))
+                    })?,
+                    values: self.values.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(values))
+                    })?,
+                })
+            }
+        }
+        impl SetStorageItemsParams {
+            pub const IDENTIFIER: &'static str = "Extensions.setStorageItems";
+        }
+        impl chromiumoxide_types::Method for SetStorageItemsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetStorageItemsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets `values` in extension storage in the given `storageArea`. The provided `values`\nwill be merged with existing values in the storage area.\n[setStorageItems](https://chromedevtools.github.io/devtools-protocol/tot/Extensions/#method-setStorageItems)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetStorageItemsReturns {}
+        impl chromiumoxide_types::Command for SetStorageItemsParams {
+            type Response = SetStorageItemsReturns;
+        }
+    }
+    #[doc = "This domain allows interacting with the FedCM dialog."]
+    pub mod fed_cm {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Whether this is a sign-up or sign-in action for this account, i.e.\nwhether this account has ever been used to sign in to this RP before."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum LoginState {
+            #[serde(rename = "SignIn")]
+            SignIn,
+            #[serde(rename = "SignUp")]
+            SignUp,
+        }
+        impl AsRef<str> for LoginState {
+            fn as_ref(&self) -> &str {
+                match self {
+                    LoginState::SignIn => "SignIn",
+                    LoginState::SignUp => "SignUp",
+                }
+            }
+        }
+        impl ::std::str::FromStr for LoginState {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "SignIn" | "signin" => Ok(LoginState::SignIn),
+                    "SignUp" | "signup" => Ok(LoginState::SignUp),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "The types of FedCM dialogs."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DialogType {
+            #[serde(rename = "AccountChooser")]
+            AccountChooser,
+            #[serde(rename = "AutoReauthn")]
+            AutoReauthn,
+            #[serde(rename = "ConfirmIdpLogin")]
+            ConfirmIdpLogin,
+            #[serde(rename = "Error")]
+            Error,
+        }
+        impl AsRef<str> for DialogType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DialogType::AccountChooser => "AccountChooser",
+                    DialogType::AutoReauthn => "AutoReauthn",
+                    DialogType::ConfirmIdpLogin => "ConfirmIdpLogin",
+                    DialogType::Error => "Error",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DialogType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "AccountChooser" | "accountchooser" => Ok(DialogType::AccountChooser),
+                    "AutoReauthn" | "autoreauthn" => Ok(DialogType::AutoReauthn),
+                    "ConfirmIdpLogin" | "confirmidplogin" => Ok(DialogType::ConfirmIdpLogin),
+                    "Error" | "error" => Ok(DialogType::Error),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "The buttons on the FedCM dialog."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DialogButton {
+            #[serde(rename = "ConfirmIdpLoginContinue")]
+            ConfirmIdpLoginContinue,
+            #[serde(rename = "ErrorGotIt")]
+            ErrorGotIt,
+            #[serde(rename = "ErrorMoreDetails")]
+            ErrorMoreDetails,
+        }
+        impl AsRef<str> for DialogButton {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DialogButton::ConfirmIdpLoginContinue => "ConfirmIdpLoginContinue",
+                    DialogButton::ErrorGotIt => "ErrorGotIt",
+                    DialogButton::ErrorMoreDetails => "ErrorMoreDetails",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DialogButton {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "ConfirmIdpLoginContinue" | "confirmidplogincontinue" => {
+                        Ok(DialogButton::ConfirmIdpLoginContinue)
+                    }
+                    "ErrorGotIt" | "errorgotit" => Ok(DialogButton::ErrorGotIt),
+                    "ErrorMoreDetails" | "errormoredetails" => Ok(DialogButton::ErrorMoreDetails),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "The URLs that each account has"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AccountUrlType {
+            #[serde(rename = "TermsOfService")]
+            TermsOfService,
+            #[serde(rename = "PrivacyPolicy")]
+            PrivacyPolicy,
+        }
+        impl AsRef<str> for AccountUrlType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AccountUrlType::TermsOfService => "TermsOfService",
+                    AccountUrlType::PrivacyPolicy => "PrivacyPolicy",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AccountUrlType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "TermsOfService" | "termsofservice" => Ok(AccountUrlType::TermsOfService),
+                    "PrivacyPolicy" | "privacypolicy" => Ok(AccountUrlType::PrivacyPolicy),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Corresponds to IdentityRequestAccount\n[Account](https://chromedevtools.github.io/devtools-protocol/tot/FedCm/#type-Account)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Account {
+            #[serde(rename = "accountId")]
+            pub account_id: String,
+            #[serde(rename = "email")]
+            pub email: String,
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "givenName")]
+            pub given_name: String,
+            #[serde(rename = "pictureUrl")]
+            pub picture_url: String,
+            #[serde(rename = "idpConfigUrl")]
+            pub idp_config_url: String,
+            #[serde(rename = "idpLoginUrl")]
+            pub idp_login_url: String,
+            #[serde(rename = "loginState")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub login_state: LoginState,
+            #[doc = "These two are only set if the loginState is signUp"]
+            #[serde(rename = "termsOfServiceUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub terms_of_service_url: Option<String>,
+            #[serde(rename = "privacyPolicyUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub privacy_policy_url: Option<String>,
+        }
+        impl Account {
+            pub fn builder() -> AccountBuilder {
+                AccountBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AccountBuilder {
+            account_id: Option<String>,
+            email: Option<String>,
+            name: Option<String>,
+            given_name: Option<String>,
+            picture_url: Option<String>,
+            idp_config_url: Option<String>,
+            idp_login_url: Option<String>,
+            login_state: Option<LoginState>,
+            terms_of_service_url: Option<String>,
+            privacy_policy_url: Option<String>,
+        }
+        impl AccountBuilder {
+            pub fn account_id(mut self, account_id: impl Into<String>) -> Self {
+                self.account_id = Some(account_id.into());
+                self
+            }
+            pub fn email(mut self, email: impl Into<String>) -> Self {
+                self.email = Some(email.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn given_name(mut self, given_name: impl Into<String>) -> Self {
+                self.given_name = Some(given_name.into());
+                self
+            }
+            pub fn picture_url(mut self, picture_url: impl Into<String>) -> Self {
+                self.picture_url = Some(picture_url.into());
+                self
+            }
+            pub fn idp_config_url(mut self, idp_config_url: impl Into<String>) -> Self {
+                self.idp_config_url = Some(idp_config_url.into());
+                self
+            }
+            pub fn idp_login_url(mut self, idp_login_url: impl Into<String>) -> Self {
+                self.idp_login_url = Some(idp_login_url.into());
+                self
+            }
+            pub fn login_state(mut self, login_state: impl Into<LoginState>) -> Self {
+                self.login_state = Some(login_state.into());
+                self
+            }
+            pub fn terms_of_service_url(mut self, terms_of_service_url: impl Into<String>) -> Self {
+                self.terms_of_service_url = Some(terms_of_service_url.into());
+                self
+            }
+            pub fn privacy_policy_url(mut self, privacy_policy_url: impl Into<String>) -> Self {
+                self.privacy_policy_url = Some(privacy_policy_url.into());
+                self
+            }
+            pub fn build(self) -> Result<Account, String> {
+                Ok(Account {
+                    account_id: self.account_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(account_id))
+                    })?,
+                    email: self.email.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(email))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    given_name: self.given_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(given_name))
+                    })?,
+                    picture_url: self.picture_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(picture_url))
+                    })?,
+                    idp_config_url: self.idp_config_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(idp_config_url))
+                    })?,
+                    idp_login_url: self.idp_login_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(idp_login_url))
+                    })?,
+                    login_state: self.login_state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(login_state))
+                    })?,
+                    terms_of_service_url: self.terms_of_service_url,
+                    privacy_policy_url: self.privacy_policy_url,
+                })
+            }
+        }
+        impl Account {
+            pub const IDENTIFIER: &'static str = "FedCm.Account";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[doc = "Allows callers to disable the promise rejection delay that would\nnormally happen, if this is unimportant to what's being tested.\n(step 4 of https://fedidcg.github.io/FedCM/#browser-api-rp-sign-in)"]
+            #[serde(rename = "disableRejectionDelay")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub disable_rejection_delay: Option<bool>,
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            disable_rejection_delay: Option<bool>,
+        }
+        impl EnableParamsBuilder {
+            pub fn disable_rejection_delay(
+                mut self,
+                disable_rejection_delay: impl Into<bool>,
+            ) -> Self {
+                self.disable_rejection_delay = Some(disable_rejection_delay.into());
+                self
+            }
+            pub fn build(self) -> EnableParams {
+                EnableParams {
+                    disable_rejection_delay: self.disable_rejection_delay,
+                }
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "FedCm.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "FedCm.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SelectAccountParams {
+            #[serde(rename = "dialogId")]
+            pub dialog_id: String,
+            #[serde(rename = "accountIndex")]
+            pub account_index: i64,
+        }
+        impl SelectAccountParams {
+            pub fn new(dialog_id: impl Into<String>, account_index: impl Into<i64>) -> Self {
+                Self {
+                    dialog_id: dialog_id.into(),
+                    account_index: account_index.into(),
+                }
+            }
+        }
+        impl SelectAccountParams {
+            pub fn builder() -> SelectAccountParamsBuilder {
+                SelectAccountParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SelectAccountParamsBuilder {
+            dialog_id: Option<String>,
+            account_index: Option<i64>,
+        }
+        impl SelectAccountParamsBuilder {
+            pub fn dialog_id(mut self, dialog_id: impl Into<String>) -> Self {
+                self.dialog_id = Some(dialog_id.into());
+                self
+            }
+            pub fn account_index(mut self, account_index: impl Into<i64>) -> Self {
+                self.account_index = Some(account_index.into());
+                self
+            }
+            pub fn build(self) -> Result<SelectAccountParams, String> {
+                Ok(SelectAccountParams {
+                    dialog_id: self.dialog_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(dialog_id))
+                    })?,
+                    account_index: self.account_index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(account_index))
+                    })?,
+                })
+            }
+        }
+        impl SelectAccountParams {
+            pub const IDENTIFIER: &'static str = "FedCm.selectAccount";
+        }
+        impl chromiumoxide_types::Method for SelectAccountParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SelectAccountParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SelectAccountReturns {}
+        impl chromiumoxide_types::Command for SelectAccountParams {
+            type Response = SelectAccountReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClickDialogButtonParams {
+            #[serde(rename = "dialogId")]
+            pub dialog_id: String,
+            #[serde(rename = "dialogButton")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub dialog_button: DialogButton,
+        }
+        impl ClickDialogButtonParams {
+            pub fn new(
+                dialog_id: impl Into<String>,
+                dialog_button: impl Into<DialogButton>,
+            ) -> Self {
+                Self {
+                    dialog_id: dialog_id.into(),
+                    dialog_button: dialog_button.into(),
+                }
+            }
+        }
+        impl ClickDialogButtonParams {
+            pub fn builder() -> ClickDialogButtonParamsBuilder {
+                ClickDialogButtonParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClickDialogButtonParamsBuilder {
+            dialog_id: Option<String>,
+            dialog_button: Option<DialogButton>,
+        }
+        impl ClickDialogButtonParamsBuilder {
+            pub fn dialog_id(mut self, dialog_id: impl Into<String>) -> Self {
+                self.dialog_id = Some(dialog_id.into());
+                self
+            }
+            pub fn dialog_button(mut self, dialog_button: impl Into<DialogButton>) -> Self {
+                self.dialog_button = Some(dialog_button.into());
+                self
+            }
+            pub fn build(self) -> Result<ClickDialogButtonParams, String> {
+                Ok(ClickDialogButtonParams {
+                    dialog_id: self.dialog_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(dialog_id))
+                    })?,
+                    dialog_button: self.dialog_button.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(dialog_button))
+                    })?,
+                })
+            }
+        }
+        impl ClickDialogButtonParams {
+            pub const IDENTIFIER: &'static str = "FedCm.clickDialogButton";
+        }
+        impl chromiumoxide_types::Method for ClickDialogButtonParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClickDialogButtonParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClickDialogButtonReturns {}
+        impl chromiumoxide_types::Command for ClickDialogButtonParams {
+            type Response = ClickDialogButtonReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct OpenUrlParams {
+            #[serde(rename = "dialogId")]
+            pub dialog_id: String,
+            #[serde(rename = "accountIndex")]
+            pub account_index: i64,
+            #[serde(rename = "accountUrlType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub account_url_type: AccountUrlType,
+        }
+        impl OpenUrlParams {
+            pub fn new(
+                dialog_id: impl Into<String>,
+                account_index: impl Into<i64>,
+                account_url_type: impl Into<AccountUrlType>,
+            ) -> Self {
+                Self {
+                    dialog_id: dialog_id.into(),
+                    account_index: account_index.into(),
+                    account_url_type: account_url_type.into(),
+                }
+            }
+        }
+        impl OpenUrlParams {
+            pub fn builder() -> OpenUrlParamsBuilder {
+                OpenUrlParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct OpenUrlParamsBuilder {
+            dialog_id: Option<String>,
+            account_index: Option<i64>,
+            account_url_type: Option<AccountUrlType>,
+        }
+        impl OpenUrlParamsBuilder {
+            pub fn dialog_id(mut self, dialog_id: impl Into<String>) -> Self {
+                self.dialog_id = Some(dialog_id.into());
+                self
+            }
+            pub fn account_index(mut self, account_index: impl Into<i64>) -> Self {
+                self.account_index = Some(account_index.into());
+                self
+            }
+            pub fn account_url_type(mut self, account_url_type: impl Into<AccountUrlType>) -> Self {
+                self.account_url_type = Some(account_url_type.into());
+                self
+            }
+            pub fn build(self) -> Result<OpenUrlParams, String> {
+                Ok(OpenUrlParams {
+                    dialog_id: self.dialog_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(dialog_id))
+                    })?,
+                    account_index: self.account_index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(account_index))
+                    })?,
+                    account_url_type: self.account_url_type.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(account_url_type)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl OpenUrlParams {
+            pub const IDENTIFIER: &'static str = "FedCm.openUrl";
+        }
+        impl chromiumoxide_types::Method for OpenUrlParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for OpenUrlParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct OpenUrlReturns {}
+        impl chromiumoxide_types::Command for OpenUrlParams {
+            type Response = OpenUrlReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DismissDialogParams {
+            #[serde(rename = "dialogId")]
+            pub dialog_id: String,
+            #[serde(rename = "triggerCooldown")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub trigger_cooldown: Option<bool>,
+        }
+        impl DismissDialogParams {
+            pub fn new(dialog_id: impl Into<String>) -> Self {
+                Self {
+                    dialog_id: dialog_id.into(),
+                    trigger_cooldown: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for DismissDialogParams {
+            fn from(url: T) -> Self {
+                DismissDialogParams::new(url)
+            }
+        }
+        impl DismissDialogParams {
+            pub fn builder() -> DismissDialogParamsBuilder {
+                DismissDialogParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DismissDialogParamsBuilder {
+            dialog_id: Option<String>,
+            trigger_cooldown: Option<bool>,
+        }
+        impl DismissDialogParamsBuilder {
+            pub fn dialog_id(mut self, dialog_id: impl Into<String>) -> Self {
+                self.dialog_id = Some(dialog_id.into());
+                self
+            }
+            pub fn trigger_cooldown(mut self, trigger_cooldown: impl Into<bool>) -> Self {
+                self.trigger_cooldown = Some(trigger_cooldown.into());
+                self
+            }
+            pub fn build(self) -> Result<DismissDialogParams, String> {
+                Ok(DismissDialogParams {
+                    dialog_id: self.dialog_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(dialog_id))
+                    })?,
+                    trigger_cooldown: self.trigger_cooldown,
+                })
+            }
+        }
+        impl DismissDialogParams {
+            pub const IDENTIFIER: &'static str = "FedCm.dismissDialog";
+        }
+        impl chromiumoxide_types::Method for DismissDialogParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DismissDialogParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DismissDialogReturns {}
+        impl chromiumoxide_types::Command for DismissDialogParams {
+            type Response = DismissDialogReturns;
+        }
+        #[doc = "Resets the cooldown time, if any, to allow the next FedCM call to show\na dialog even if one was recently dismissed by the user.\n[resetCooldown](https://chromedevtools.github.io/devtools-protocol/tot/FedCm/#method-resetCooldown)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResetCooldownParams {}
+        impl ResetCooldownParams {
+            pub const IDENTIFIER: &'static str = "FedCm.resetCooldown";
+        }
+        impl chromiumoxide_types::Method for ResetCooldownParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ResetCooldownParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Resets the cooldown time, if any, to allow the next FedCM call to show\na dialog even if one was recently dismissed by the user.\n[resetCooldown](https://chromedevtools.github.io/devtools-protocol/tot/FedCm/#method-resetCooldown)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResetCooldownReturns {}
+        impl chromiumoxide_types::Command for ResetCooldownParams {
+            type Response = ResetCooldownReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDialogShown {
+            #[serde(rename = "dialogId")]
+            pub dialog_id: String,
+            #[serde(rename = "dialogType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub dialog_type: DialogType,
+            #[serde(rename = "accounts")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub accounts: Vec<Account>,
+            #[doc = "These exist primarily so that the caller can verify the\nRP context was used appropriately."]
+            #[serde(rename = "title")]
+            pub title: String,
+            #[serde(rename = "subtitle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub subtitle: Option<String>,
+        }
+        impl EventDialogShown {
+            pub const IDENTIFIER: &'static str = "FedCm.dialogShown";
+        }
+        impl chromiumoxide_types::Method for EventDialogShown {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDialogShown {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Triggered when a dialog is closed, either by user action, JS abort,\nor a command below.\n[dialogClosed](https://chromedevtools.github.io/devtools-protocol/tot/FedCm/#event-dialogClosed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDialogClosed {
+            #[serde(rename = "dialogId")]
+            pub dialog_id: String,
+        }
+        impl EventDialogClosed {
+            pub const IDENTIFIER: &'static str = "FedCm.dialogClosed";
+        }
+        impl chromiumoxide_types::Method for EventDialogClosed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDialogClosed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "A domain for letting clients substitute browser's network layer with client code."]
+    pub mod fetch {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Unique request identifier.\nNote that this does not identify individual HTTP requests that are part of\na network request.\n[RequestId](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#type-RequestId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct RequestId(String);
+        impl RequestId {
+            pub fn new(val: impl Into<String>) -> Self {
+                RequestId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for RequestId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<RequestId> for String {
+            fn from(el: RequestId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for RequestId {
+            fn from(expr: String) -> Self {
+                RequestId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for RequestId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl RequestId {
+            pub const IDENTIFIER: &'static str = "Fetch.RequestId";
+        }
+        #[doc = "Stages of the request to handle. Request will intercept before the request is\nsent. Response will intercept after the response is received (but before response\nbody is received)."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum RequestStage {
+            #[serde(rename = "Request")]
+            Request,
+            #[serde(rename = "Response")]
+            Response,
+        }
+        impl AsRef<str> for RequestStage {
+            fn as_ref(&self) -> &str {
+                match self {
+                    RequestStage::Request => "Request",
+                    RequestStage::Response => "Response",
+                }
+            }
+        }
+        impl ::std::str::FromStr for RequestStage {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Request" | "request" => Ok(RequestStage::Request),
+                    "Response" | "response" => Ok(RequestStage::Response),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RequestPattern {
+            #[doc = "Wildcards (`'*'` -> zero or more, `'?'` -> exactly one) are allowed. Escape character is\nbackslash. Omitting is equivalent to `\"*\"`."]
+            #[serde(rename = "urlPattern")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url_pattern: Option<String>,
+            #[doc = "If set, only requests for matching resource types will be intercepted."]
+            #[serde(rename = "resourceType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub resource_type: Option<super::network::ResourceType>,
+            #[doc = "Stage at which to begin intercepting requests. Default is Request."]
+            #[serde(rename = "requestStage")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub request_stage: Option<RequestStage>,
+        }
+        impl RequestPattern {
+            pub fn builder() -> RequestPatternBuilder {
+                RequestPatternBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestPatternBuilder {
+            url_pattern: Option<String>,
+            resource_type: Option<super::network::ResourceType>,
+            request_stage: Option<RequestStage>,
+        }
+        impl RequestPatternBuilder {
+            pub fn url_pattern(mut self, url_pattern: impl Into<String>) -> Self {
+                self.url_pattern = Some(url_pattern.into());
+                self
+            }
+            pub fn resource_type(
+                mut self,
+                resource_type: impl Into<super::network::ResourceType>,
+            ) -> Self {
+                self.resource_type = Some(resource_type.into());
+                self
+            }
+            pub fn request_stage(mut self, request_stage: impl Into<RequestStage>) -> Self {
+                self.request_stage = Some(request_stage.into());
+                self
+            }
+            pub fn build(self) -> RequestPattern {
+                RequestPattern {
+                    url_pattern: self.url_pattern,
+                    resource_type: self.resource_type,
+                    request_stage: self.request_stage,
+                }
+            }
+        }
+        impl RequestPattern {
+            pub const IDENTIFIER: &'static str = "Fetch.RequestPattern";
+        }
+        #[doc = "Response HTTP header entry\n[HeaderEntry](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#type-HeaderEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct HeaderEntry {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl HeaderEntry {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl HeaderEntry {
+            pub fn builder() -> HeaderEntryBuilder {
+                HeaderEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HeaderEntryBuilder {
+            name: Option<String>,
+            value: Option<String>,
+        }
+        impl HeaderEntryBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<HeaderEntry, String> {
+                Ok(HeaderEntry {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl HeaderEntry {
+            pub const IDENTIFIER: &'static str = "Fetch.HeaderEntry";
+        }
+        #[doc = "Authorization challenge for HTTP status code 401 or 407.\n[AuthChallenge](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#type-AuthChallenge)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AuthChallenge {
+            #[doc = "Source of the authentication challenge."]
+            #[serde(rename = "source")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub source: Option<AuthChallengeSource>,
+            #[doc = "Origin of the challenger."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "The authentication scheme used, such as basic or digest"]
+            #[serde(rename = "scheme")]
+            pub scheme: String,
+            #[doc = "The realm of the challenge. May be empty."]
+            #[serde(rename = "realm")]
+            pub realm: String,
+        }
+        #[doc = "Source of the authentication challenge."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AuthChallengeSource {
+            #[serde(rename = "Server")]
+            Server,
+            #[serde(rename = "Proxy")]
+            Proxy,
+        }
+        impl AsRef<str> for AuthChallengeSource {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AuthChallengeSource::Server => "Server",
+                    AuthChallengeSource::Proxy => "Proxy",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AuthChallengeSource {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Server" | "server" => Ok(AuthChallengeSource::Server),
+                    "Proxy" | "proxy" => Ok(AuthChallengeSource::Proxy),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl AuthChallenge {
+            pub fn new(
+                origin: impl Into<String>,
+                scheme: impl Into<String>,
+                realm: impl Into<String>,
+            ) -> Self {
+                Self {
+                    origin: origin.into(),
+                    scheme: scheme.into(),
+                    realm: realm.into(),
+                    source: None,
+                }
+            }
+        }
+        impl AuthChallenge {
+            pub fn builder() -> AuthChallengeBuilder {
+                AuthChallengeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AuthChallengeBuilder {
+            source: Option<AuthChallengeSource>,
+            origin: Option<String>,
+            scheme: Option<String>,
+            realm: Option<String>,
+        }
+        impl AuthChallengeBuilder {
+            pub fn source(mut self, source: impl Into<AuthChallengeSource>) -> Self {
+                self.source = Some(source.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn scheme(mut self, scheme: impl Into<String>) -> Self {
+                self.scheme = Some(scheme.into());
+                self
+            }
+            pub fn realm(mut self, realm: impl Into<String>) -> Self {
+                self.realm = Some(realm.into());
+                self
+            }
+            pub fn build(self) -> Result<AuthChallenge, String> {
+                Ok(AuthChallenge {
+                    source: self.source,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    scheme: self.scheme.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scheme))
+                    })?,
+                    realm: self.realm.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(realm))
+                    })?,
+                })
+            }
+        }
+        impl AuthChallenge {
+            pub const IDENTIFIER: &'static str = "Fetch.AuthChallenge";
+        }
+        #[doc = "Response to an AuthChallenge.\n[AuthChallengeResponse](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#type-AuthChallengeResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AuthChallengeResponse {
+            #[doc = "The decision on what to do in response to the authorization challenge.  Default means\ndeferring to the default behavior of the net stack, which will likely either the Cancel\nauthentication or display a popup dialog box."]
+            #[serde(rename = "response")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub response: AuthChallengeResponseResponse,
+            #[doc = "The username to provide, possibly empty. Should only be set if response is\nProvideCredentials."]
+            #[serde(rename = "username")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub username: Option<String>,
+            #[doc = "The password to provide, possibly empty. Should only be set if response is\nProvideCredentials."]
+            #[serde(rename = "password")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub password: Option<String>,
+        }
+        #[doc = "The decision on what to do in response to the authorization challenge.  Default means\ndeferring to the default behavior of the net stack, which will likely either the Cancel\nauthentication or display a popup dialog box."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AuthChallengeResponseResponse {
+            #[serde(rename = "Default")]
+            Default,
+            #[serde(rename = "CancelAuth")]
+            CancelAuth,
+            #[serde(rename = "ProvideCredentials")]
+            ProvideCredentials,
+        }
+        impl AsRef<str> for AuthChallengeResponseResponse {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AuthChallengeResponseResponse::Default => "Default",
+                    AuthChallengeResponseResponse::CancelAuth => "CancelAuth",
+                    AuthChallengeResponseResponse::ProvideCredentials => "ProvideCredentials",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AuthChallengeResponseResponse {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Default" | "default" => Ok(AuthChallengeResponseResponse::Default),
+                    "CancelAuth" | "cancelauth" => Ok(AuthChallengeResponseResponse::CancelAuth),
+                    "ProvideCredentials" | "providecredentials" => {
+                        Ok(AuthChallengeResponseResponse::ProvideCredentials)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl AuthChallengeResponse {
+            pub fn new(response: impl Into<AuthChallengeResponseResponse>) -> Self {
+                Self {
+                    response: response.into(),
+                    username: None,
+                    password: None,
+                }
+            }
+        }
+        impl AuthChallengeResponse {
+            pub fn builder() -> AuthChallengeResponseBuilder {
+                AuthChallengeResponseBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AuthChallengeResponseBuilder {
+            response: Option<AuthChallengeResponseResponse>,
+            username: Option<String>,
+            password: Option<String>,
+        }
+        impl AuthChallengeResponseBuilder {
+            pub fn response(mut self, response: impl Into<AuthChallengeResponseResponse>) -> Self {
+                self.response = Some(response.into());
+                self
+            }
+            pub fn username(mut self, username: impl Into<String>) -> Self {
+                self.username = Some(username.into());
+                self
+            }
+            pub fn password(mut self, password: impl Into<String>) -> Self {
+                self.password = Some(password.into());
+                self
+            }
+            pub fn build(self) -> Result<AuthChallengeResponse, String> {
+                Ok(AuthChallengeResponse {
+                    response: self.response.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(response))
+                    })?,
+                    username: self.username,
+                    password: self.password,
+                })
+            }
+        }
+        impl AuthChallengeResponse {
+            pub const IDENTIFIER: &'static str = "Fetch.AuthChallengeResponse";
+        }
+        #[doc = "Disables the fetch domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Fetch.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables the fetch domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables issuing of requestPaused events. A request will be paused until client\ncalls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[doc = "If specified, only requests matching any of these patterns will produce\nfetchRequested event and will be paused until clients response. If not set,\nall requests will be affected."]
+            #[serde(rename = "patterns")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub patterns: Option<Vec<RequestPattern>>,
+            #[doc = "If true, authRequired events will be issued and requests will be paused\nexpecting a call to continueWithAuth."]
+            #[serde(rename = "handleAuthRequests")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub handle_auth_requests: Option<bool>,
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            patterns: Option<Vec<RequestPattern>>,
+            handle_auth_requests: Option<bool>,
+        }
+        impl EnableParamsBuilder {
+            pub fn pattern(mut self, pattern: impl Into<RequestPattern>) -> Self {
+                let v = self.patterns.get_or_insert(Vec::new());
+                v.push(pattern.into());
+                self
+            }
+            pub fn patterns<I, S>(mut self, patterns: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<RequestPattern>,
+            {
+                let v = self.patterns.get_or_insert(Vec::new());
+                for val in patterns {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn handle_auth_requests(mut self, handle_auth_requests: impl Into<bool>) -> Self {
+                self.handle_auth_requests = Some(handle_auth_requests.into());
+                self
+            }
+            pub fn build(self) -> EnableParams {
+                EnableParams {
+                    patterns: self.patterns,
+                    handle_auth_requests: self.handle_auth_requests,
+                }
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Fetch.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables issuing of requestPaused events. A request will be paused until client\ncalls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Causes the request to fail with specified reason.\n[failRequest](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-failRequest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FailRequestParams {
+            #[doc = "An id the client received in requestPaused event."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Causes the request to fail with the given reason."]
+            #[serde(rename = "errorReason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub error_reason: super::network::ErrorReason,
+        }
+        impl FailRequestParams {
+            pub fn new(
+                request_id: impl Into<RequestId>,
+                error_reason: impl Into<super::network::ErrorReason>,
+            ) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                    error_reason: error_reason.into(),
+                }
+            }
+        }
+        impl FailRequestParams {
+            pub fn builder() -> FailRequestParamsBuilder {
+                FailRequestParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FailRequestParamsBuilder {
+            request_id: Option<RequestId>,
+            error_reason: Option<super::network::ErrorReason>,
+        }
+        impl FailRequestParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn error_reason(
+                mut self,
+                error_reason: impl Into<super::network::ErrorReason>,
+            ) -> Self {
+                self.error_reason = Some(error_reason.into());
+                self
+            }
+            pub fn build(self) -> Result<FailRequestParams, String> {
+                Ok(FailRequestParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                    error_reason: self.error_reason.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(error_reason))
+                    })?,
+                })
+            }
+        }
+        impl FailRequestParams {
+            pub const IDENTIFIER: &'static str = "Fetch.failRequest";
+        }
+        impl chromiumoxide_types::Method for FailRequestParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for FailRequestParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Causes the request to fail with specified reason.\n[failRequest](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-failRequest)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct FailRequestReturns {}
+        impl chromiumoxide_types::Command for FailRequestParams {
+            type Response = FailRequestReturns;
+        }
+        #[doc = "Provides response to the request.\n[fulfillRequest](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-fulfillRequest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FulfillRequestParams {
+            #[doc = "An id the client received in requestPaused event."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "An HTTP response code."]
+            #[serde(rename = "responseCode")]
+            pub response_code: i64,
+            #[doc = "Response headers."]
+            #[serde(rename = "responseHeaders")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub response_headers: Option<Vec<HeaderEntry>>,
+            #[doc = "Alternative way of specifying response headers as a \\0-separated\nseries of name: value pairs. Prefer the above method unless you\nneed to represent some non-UTF8 values that can't be transmitted\nover the protocol as text."]
+            #[serde(rename = "binaryResponseHeaders")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub binary_response_headers: Option<chromiumoxide_types::Binary>,
+            #[doc = "A response body. If absent, original response body will be used if\nthe request is intercepted at the response stage and empty body\nwill be used if the request is intercepted at the request stage."]
+            #[serde(rename = "body")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub body: Option<chromiumoxide_types::Binary>,
+            #[doc = "A textual representation of responseCode.\nIf absent, a standard phrase matching responseCode is used."]
+            #[serde(rename = "responsePhrase")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub response_phrase: Option<String>,
+        }
+        impl FulfillRequestParams {
+            pub fn new(request_id: impl Into<RequestId>, response_code: impl Into<i64>) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                    response_code: response_code.into(),
+                    response_headers: None,
+                    binary_response_headers: None,
+                    body: None,
+                    response_phrase: None,
+                }
+            }
+        }
+        impl FulfillRequestParams {
+            pub fn builder() -> FulfillRequestParamsBuilder {
+                FulfillRequestParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FulfillRequestParamsBuilder {
+            request_id: Option<RequestId>,
+            response_code: Option<i64>,
+            response_headers: Option<Vec<HeaderEntry>>,
+            binary_response_headers: Option<chromiumoxide_types::Binary>,
+            body: Option<chromiumoxide_types::Binary>,
+            response_phrase: Option<String>,
+        }
+        impl FulfillRequestParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn response_code(mut self, response_code: impl Into<i64>) -> Self {
+                self.response_code = Some(response_code.into());
+                self
+            }
+            pub fn response_header(mut self, response_header: impl Into<HeaderEntry>) -> Self {
+                let v = self.response_headers.get_or_insert(Vec::new());
+                v.push(response_header.into());
+                self
+            }
+            pub fn response_headers<I, S>(mut self, response_headers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<HeaderEntry>,
+            {
+                let v = self.response_headers.get_or_insert(Vec::new());
+                for val in response_headers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn binary_response_headers(
+                mut self,
+                binary_response_headers: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.binary_response_headers = Some(binary_response_headers.into());
+                self
+            }
+            pub fn body(mut self, body: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.body = Some(body.into());
+                self
+            }
+            pub fn response_phrase(mut self, response_phrase: impl Into<String>) -> Self {
+                self.response_phrase = Some(response_phrase.into());
+                self
+            }
+            pub fn build(self) -> Result<FulfillRequestParams, String> {
+                Ok(FulfillRequestParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                    response_code: self.response_code.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(response_code))
+                    })?,
+                    response_headers: self.response_headers,
+                    binary_response_headers: self.binary_response_headers,
+                    body: self.body,
+                    response_phrase: self.response_phrase,
+                })
+            }
+        }
+        impl FulfillRequestParams {
+            pub const IDENTIFIER: &'static str = "Fetch.fulfillRequest";
+        }
+        impl chromiumoxide_types::Method for FulfillRequestParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for FulfillRequestParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Provides response to the request.\n[fulfillRequest](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-fulfillRequest)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct FulfillRequestReturns {}
+        impl chromiumoxide_types::Command for FulfillRequestParams {
+            type Response = FulfillRequestReturns;
+        }
+        #[doc = "Continues the request, optionally modifying some of its parameters.\n[continueRequest](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-continueRequest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ContinueRequestParams {
+            #[doc = "An id the client received in requestPaused event."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "If set, the request url will be modified in a way that's not observable by page."]
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[doc = "If set, the request method is overridden."]
+            #[serde(rename = "method")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub method: Option<String>,
+            #[doc = "If set, overrides the post data in the request."]
+            #[serde(rename = "postData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub post_data: Option<chromiumoxide_types::Binary>,
+            #[doc = "If set, overrides the request headers. Note that the overrides do not\nextend to subsequent redirect hops, if a redirect happens. Another override\nmay be applied to a different request produced by a redirect."]
+            #[serde(rename = "headers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub headers: Option<Vec<HeaderEntry>>,
+            #[doc = "If set, overrides response interception behavior for this request."]
+            #[serde(rename = "interceptResponse")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub intercept_response: Option<bool>,
+        }
+        impl ContinueRequestParams {
+            pub fn new(request_id: impl Into<RequestId>) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                    url: None,
+                    method: None,
+                    post_data: None,
+                    headers: None,
+                    intercept_response: None,
+                }
+            }
+        }
+        impl ContinueRequestParams {
+            pub fn builder() -> ContinueRequestParamsBuilder {
+                ContinueRequestParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ContinueRequestParamsBuilder {
+            request_id: Option<RequestId>,
+            url: Option<String>,
+            method: Option<String>,
+            post_data: Option<chromiumoxide_types::Binary>,
+            headers: Option<Vec<HeaderEntry>>,
+            intercept_response: Option<bool>,
+        }
+        impl ContinueRequestParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn method(mut self, method: impl Into<String>) -> Self {
+                self.method = Some(method.into());
+                self
+            }
+            pub fn post_data(mut self, post_data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.post_data = Some(post_data.into());
+                self
+            }
+            pub fn header(mut self, header: impl Into<HeaderEntry>) -> Self {
+                let v = self.headers.get_or_insert(Vec::new());
+                v.push(header.into());
+                self
+            }
+            pub fn headers<I, S>(mut self, headers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<HeaderEntry>,
+            {
+                let v = self.headers.get_or_insert(Vec::new());
+                for val in headers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn intercept_response(mut self, intercept_response: impl Into<bool>) -> Self {
+                self.intercept_response = Some(intercept_response.into());
+                self
+            }
+            pub fn build(self) -> Result<ContinueRequestParams, String> {
+                Ok(ContinueRequestParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                    url: self.url,
+                    method: self.method,
+                    post_data: self.post_data,
+                    headers: self.headers,
+                    intercept_response: self.intercept_response,
+                })
+            }
+        }
+        impl ContinueRequestParams {
+            pub const IDENTIFIER: &'static str = "Fetch.continueRequest";
+        }
+        impl chromiumoxide_types::Method for ContinueRequestParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ContinueRequestParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Continues the request, optionally modifying some of its parameters.\n[continueRequest](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-continueRequest)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ContinueRequestReturns {}
+        impl chromiumoxide_types::Command for ContinueRequestParams {
+            type Response = ContinueRequestReturns;
+        }
+        #[doc = "Continues a request supplying authChallengeResponse following authRequired event.\n[continueWithAuth](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-continueWithAuth)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ContinueWithAuthParams {
+            #[doc = "An id the client received in authRequired event."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Response to  with an authChallenge."]
+            #[serde(rename = "authChallengeResponse")]
+            pub auth_challenge_response: AuthChallengeResponse,
+        }
+        impl ContinueWithAuthParams {
+            pub fn new(
+                request_id: impl Into<RequestId>,
+                auth_challenge_response: impl Into<AuthChallengeResponse>,
+            ) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                    auth_challenge_response: auth_challenge_response.into(),
+                }
+            }
+        }
+        impl ContinueWithAuthParams {
+            pub fn builder() -> ContinueWithAuthParamsBuilder {
+                ContinueWithAuthParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ContinueWithAuthParamsBuilder {
+            request_id: Option<RequestId>,
+            auth_challenge_response: Option<AuthChallengeResponse>,
+        }
+        impl ContinueWithAuthParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn auth_challenge_response(
+                mut self,
+                auth_challenge_response: impl Into<AuthChallengeResponse>,
+            ) -> Self {
+                self.auth_challenge_response = Some(auth_challenge_response.into());
+                self
+            }
+            pub fn build(self) -> Result<ContinueWithAuthParams, String> {
+                Ok(ContinueWithAuthParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                    auth_challenge_response: self.auth_challenge_response.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(auth_challenge_response)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl ContinueWithAuthParams {
+            pub const IDENTIFIER: &'static str = "Fetch.continueWithAuth";
+        }
+        impl chromiumoxide_types::Method for ContinueWithAuthParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ContinueWithAuthParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Continues a request supplying authChallengeResponse following authRequired event.\n[continueWithAuth](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-continueWithAuth)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ContinueWithAuthReturns {}
+        impl chromiumoxide_types::Command for ContinueWithAuthParams {
+            type Response = ContinueWithAuthReturns;
+        }
+        #[doc = "Continues loading of the paused response, optionally modifying the\nresponse headers. If either responseCode or headers are modified, all of them\nmust be present.\n[continueResponse](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-continueResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ContinueResponseParams {
+            #[doc = "An id the client received in requestPaused event."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "An HTTP response code. If absent, original response code will be used."]
+            #[serde(rename = "responseCode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub response_code: Option<i64>,
+            #[doc = "A textual representation of responseCode.\nIf absent, a standard phrase matching responseCode is used."]
+            #[serde(rename = "responsePhrase")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub response_phrase: Option<String>,
+            #[doc = "Response headers. If absent, original response headers will be used."]
+            #[serde(rename = "responseHeaders")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub response_headers: Option<Vec<HeaderEntry>>,
+            #[doc = "Alternative way of specifying response headers as a \\0-separated\nseries of name: value pairs. Prefer the above method unless you\nneed to represent some non-UTF8 values that can't be transmitted\nover the protocol as text."]
+            #[serde(rename = "binaryResponseHeaders")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub binary_response_headers: Option<chromiumoxide_types::Binary>,
+        }
+        impl ContinueResponseParams {
+            pub fn new(request_id: impl Into<RequestId>) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                    response_code: None,
+                    response_phrase: None,
+                    response_headers: None,
+                    binary_response_headers: None,
+                }
+            }
+        }
+        impl ContinueResponseParams {
+            pub fn builder() -> ContinueResponseParamsBuilder {
+                ContinueResponseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ContinueResponseParamsBuilder {
+            request_id: Option<RequestId>,
+            response_code: Option<i64>,
+            response_phrase: Option<String>,
+            response_headers: Option<Vec<HeaderEntry>>,
+            binary_response_headers: Option<chromiumoxide_types::Binary>,
+        }
+        impl ContinueResponseParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn response_code(mut self, response_code: impl Into<i64>) -> Self {
+                self.response_code = Some(response_code.into());
+                self
+            }
+            pub fn response_phrase(mut self, response_phrase: impl Into<String>) -> Self {
+                self.response_phrase = Some(response_phrase.into());
+                self
+            }
+            pub fn response_header(mut self, response_header: impl Into<HeaderEntry>) -> Self {
+                let v = self.response_headers.get_or_insert(Vec::new());
+                v.push(response_header.into());
+                self
+            }
+            pub fn response_headers<I, S>(mut self, response_headers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<HeaderEntry>,
+            {
+                let v = self.response_headers.get_or_insert(Vec::new());
+                for val in response_headers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn binary_response_headers(
+                mut self,
+                binary_response_headers: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.binary_response_headers = Some(binary_response_headers.into());
+                self
+            }
+            pub fn build(self) -> Result<ContinueResponseParams, String> {
+                Ok(ContinueResponseParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                    response_code: self.response_code,
+                    response_phrase: self.response_phrase,
+                    response_headers: self.response_headers,
+                    binary_response_headers: self.binary_response_headers,
+                })
+            }
+        }
+        impl ContinueResponseParams {
+            pub const IDENTIFIER: &'static str = "Fetch.continueResponse";
+        }
+        impl chromiumoxide_types::Method for ContinueResponseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ContinueResponseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Continues loading of the paused response, optionally modifying the\nresponse headers. If either responseCode or headers are modified, all of them\nmust be present.\n[continueResponse](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-continueResponse)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ContinueResponseReturns {}
+        impl chromiumoxide_types::Command for ContinueResponseParams {
+            type Response = ContinueResponseReturns;
+        }
+        #[doc = "Causes the body of the response to be received from the server and\nreturned as a single string. May only be issued for a request that\nis paused in the Response stage and is mutually exclusive with\ntakeResponseBodyForInterceptionAsStream. Calling other methods that\naffect the request or disabling fetch domain before body is received\nresults in an undefined behavior.\nNote that the response body is not available for redirects. Requests\npaused in the _redirect received_ state may be differentiated by\n`responseCode` and presence of `location` response header, see\ncomments to `requestPaused` for details.\n[getResponseBody](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-getResponseBody)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetResponseBodyParams {
+            #[doc = "Identifier for the intercepted request to get body for."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+        }
+        impl GetResponseBodyParams {
+            pub fn new(request_id: impl Into<RequestId>) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                }
+            }
+        }
+        impl GetResponseBodyParams {
+            pub fn builder() -> GetResponseBodyParamsBuilder {
+                GetResponseBodyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetResponseBodyParamsBuilder {
+            request_id: Option<RequestId>,
+        }
+        impl GetResponseBodyParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetResponseBodyParams, String> {
+                Ok(GetResponseBodyParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                })
+            }
+        }
+        impl GetResponseBodyParams {
+            pub const IDENTIFIER: &'static str = "Fetch.getResponseBody";
+        }
+        impl chromiumoxide_types::Method for GetResponseBodyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetResponseBodyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Causes the body of the response to be received from the server and\nreturned as a single string. May only be issued for a request that\nis paused in the Response stage and is mutually exclusive with\ntakeResponseBodyForInterceptionAsStream. Calling other methods that\naffect the request or disabling fetch domain before body is received\nresults in an undefined behavior.\nNote that the response body is not available for redirects. Requests\npaused in the _redirect received_ state may be differentiated by\n`responseCode` and presence of `location` response header, see\ncomments to `requestPaused` for details.\n[getResponseBody](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-getResponseBody)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetResponseBodyReturns {
+            #[doc = "Response body."]
+            #[serde(rename = "body")]
+            pub body: String,
+            #[doc = "True, if content was sent as base64."]
+            #[serde(rename = "base64Encoded")]
+            pub base64_encoded: bool,
+        }
+        impl GetResponseBodyReturns {
+            pub fn new(body: impl Into<String>, base64_encoded: impl Into<bool>) -> Self {
+                Self {
+                    body: body.into(),
+                    base64_encoded: base64_encoded.into(),
+                }
+            }
+        }
+        impl GetResponseBodyReturns {
+            pub fn builder() -> GetResponseBodyReturnsBuilder {
+                GetResponseBodyReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetResponseBodyReturnsBuilder {
+            body: Option<String>,
+            base64_encoded: Option<bool>,
+        }
+        impl GetResponseBodyReturnsBuilder {
+            pub fn body(mut self, body: impl Into<String>) -> Self {
+                self.body = Some(body.into());
+                self
+            }
+            pub fn base64_encoded(mut self, base64_encoded: impl Into<bool>) -> Self {
+                self.base64_encoded = Some(base64_encoded.into());
+                self
+            }
+            pub fn build(self) -> Result<GetResponseBodyReturns, String> {
+                Ok(GetResponseBodyReturns {
+                    body: self.body.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(body))
+                    })?,
+                    base64_encoded: self.base64_encoded.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(base64_encoded))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetResponseBodyParams {
+            type Response = GetResponseBodyReturns;
+        }
+        #[doc = "Returns a handle to the stream representing the response body.\nThe request must be paused in the HeadersReceived stage.\nNote that after this command the request can't be continued\nas is -- client either needs to cancel it or to provide the\nresponse body.\nThe stream only supports sequential read, IO.read will fail if the position\nis specified.\nThis method is mutually exclusive with getResponseBody.\nCalling other methods that affect the request or disabling fetch\ndomain before body is received results in an undefined behavior.\n[takeResponseBodyAsStream](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-takeResponseBodyAsStream)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TakeResponseBodyAsStreamParams {
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+        }
+        impl TakeResponseBodyAsStreamParams {
+            pub fn new(request_id: impl Into<RequestId>) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                }
+            }
+        }
+        impl TakeResponseBodyAsStreamParams {
+            pub fn builder() -> TakeResponseBodyAsStreamParamsBuilder {
+                TakeResponseBodyAsStreamParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TakeResponseBodyAsStreamParamsBuilder {
+            request_id: Option<RequestId>,
+        }
+        impl TakeResponseBodyAsStreamParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn build(self) -> Result<TakeResponseBodyAsStreamParams, String> {
+                Ok(TakeResponseBodyAsStreamParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                })
+            }
+        }
+        impl TakeResponseBodyAsStreamParams {
+            pub const IDENTIFIER: &'static str = "Fetch.takeResponseBodyAsStream";
+        }
+        impl chromiumoxide_types::Method for TakeResponseBodyAsStreamParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TakeResponseBodyAsStreamParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns a handle to the stream representing the response body.\nThe request must be paused in the HeadersReceived stage.\nNote that after this command the request can't be continued\nas is -- client either needs to cancel it or to provide the\nresponse body.\nThe stream only supports sequential read, IO.read will fail if the position\nis specified.\nThis method is mutually exclusive with getResponseBody.\nCalling other methods that affect the request or disabling fetch\ndomain before body is received results in an undefined behavior.\n[takeResponseBodyAsStream](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-takeResponseBodyAsStream)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TakeResponseBodyAsStreamReturns {
+            #[serde(rename = "stream")]
+            pub stream: super::io::StreamHandle,
+        }
+        impl TakeResponseBodyAsStreamReturns {
+            pub fn new(stream: impl Into<super::io::StreamHandle>) -> Self {
+                Self {
+                    stream: stream.into(),
+                }
+            }
+        }
+        impl TakeResponseBodyAsStreamReturns {
+            pub fn builder() -> TakeResponseBodyAsStreamReturnsBuilder {
+                TakeResponseBodyAsStreamReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TakeResponseBodyAsStreamReturnsBuilder {
+            stream: Option<super::io::StreamHandle>,
+        }
+        impl TakeResponseBodyAsStreamReturnsBuilder {
+            pub fn stream(mut self, stream: impl Into<super::io::StreamHandle>) -> Self {
+                self.stream = Some(stream.into());
+                self
+            }
+            pub fn build(self) -> Result<TakeResponseBodyAsStreamReturns, String> {
+                Ok(TakeResponseBodyAsStreamReturns {
+                    stream: self.stream.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(stream))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for TakeResponseBodyAsStreamParams {
+            type Response = TakeResponseBodyAsStreamReturns;
+        }
+        #[doc = "Issued when the domain is enabled and the request URL matches the\nspecified filter. The request is paused until the client responds\nwith one of continueRequest, failRequest or fulfillRequest.\nThe stage of the request can be determined by presence of responseErrorReason\nand responseStatusCode -- the request is at the response stage if either\nof these fields is present and in the request stage otherwise.\nRedirect responses and subsequent requests are reported similarly to regular\nresponses and requests. Redirect responses may be distinguished by the value\nof `responseStatusCode` (which is one of 301, 302, 303, 307, 308) along with\npresence of the `location` header. Requests resulting from a redirect will\nhave `redirectedRequestId` field set.\n[requestPaused](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#event-requestPaused)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventRequestPaused {
+            #[doc = "Each request the page makes will have a unique id."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "The details of the request."]
+            #[serde(rename = "request")]
+            pub request: super::network::Request,
+            #[doc = "The id of the frame that initiated the request."]
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+            #[doc = "How the requested resource will be used."]
+            #[serde(rename = "resourceType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub resource_type: super::network::ResourceType,
+            #[doc = "Response error if intercepted at response stage."]
+            #[serde(rename = "responseErrorReason")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub response_error_reason: Option<super::network::ErrorReason>,
+            #[doc = "Response code if intercepted at response stage."]
+            #[serde(rename = "responseStatusCode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub response_status_code: Option<i64>,
+            #[doc = "Response status text if intercepted at response stage."]
+            #[serde(rename = "responseStatusText")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub response_status_text: Option<String>,
+            #[doc = "Response headers if intercepted at the response stage."]
+            #[serde(rename = "responseHeaders")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub response_headers: Option<Vec<HeaderEntry>>,
+            #[doc = "If the intercepted request had a corresponding Network.requestWillBeSent event fired for it,\nthen this networkId will be the same as the requestId present in the requestWillBeSent event."]
+            #[serde(rename = "networkId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub network_id: Option<super::network::RequestId>,
+            #[doc = "If the request is due to a redirect response from the server, the id of the request that\nhas caused the redirect."]
+            #[serde(rename = "redirectedRequestId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub redirected_request_id: Option<RequestId>,
+        }
+        impl EventRequestPaused {
+            pub const IDENTIFIER: &'static str = "Fetch.requestPaused";
+        }
+        impl chromiumoxide_types::Method for EventRequestPaused {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventRequestPaused {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when the domain is enabled with handleAuthRequests set to true.\nThe request is paused until client responds with continueWithAuth.\n[authRequired](https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#event-authRequired)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAuthRequired {
+            #[doc = "Each request the page makes will have a unique id."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "The details of the request."]
+            #[serde(rename = "request")]
+            pub request: super::network::Request,
+            #[doc = "The id of the frame that initiated the request."]
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+            #[doc = "How the requested resource will be used."]
+            #[serde(rename = "resourceType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub resource_type: super::network::ResourceType,
+            #[doc = "Details of the Authorization Challenge encountered.\nIf this is set, client should respond with continueRequest that\ncontains AuthChallengeResponse."]
+            #[serde(rename = "authChallenge")]
+            pub auth_challenge: AuthChallenge,
+        }
+        impl EventAuthRequired {
+            pub const IDENTIFIER: &'static str = "Fetch.authRequired";
+        }
+        impl chromiumoxide_types::Method for EventAuthRequired {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAuthRequired {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod file_system {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct File {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Timestamp"]
+            #[serde(rename = "lastModified")]
+            pub last_modified: super::network::TimeSinceEpoch,
+            #[doc = "Size in bytes"]
+            #[serde(rename = "size")]
+            pub size: f64,
+            #[serde(rename = "type")]
+            pub r#type: String,
+        }
+        impl File {
+            pub fn new(
+                name: impl Into<String>,
+                last_modified: impl Into<super::network::TimeSinceEpoch>,
+                size: impl Into<f64>,
+                r#type: impl Into<String>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    last_modified: last_modified.into(),
+                    size: size.into(),
+                    r#type: r#type.into(),
+                }
+            }
+        }
+        impl File {
+            pub fn builder() -> FileBuilder {
+                FileBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FileBuilder {
+            name: Option<String>,
+            last_modified: Option<super::network::TimeSinceEpoch>,
+            size: Option<f64>,
+            r#type: Option<String>,
+        }
+        impl FileBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn last_modified(
+                mut self,
+                last_modified: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.last_modified = Some(last_modified.into());
+                self
+            }
+            pub fn size(mut self, size: impl Into<f64>) -> Self {
+                self.size = Some(size.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<File, String> {
+                Ok(File {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    last_modified: self.last_modified.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(last_modified))
+                    })?,
+                    size: self.size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(size))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                })
+            }
+        }
+        impl File {
+            pub const IDENTIFIER: &'static str = "FileSystem.File";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Directory {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "nestedDirectories")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub nested_directories: Vec<String>,
+            #[doc = "Files that are directly nested under this directory."]
+            #[serde(rename = "nestedFiles")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub nested_files: Vec<File>,
+        }
+        impl Directory {
+            pub fn new(
+                name: impl Into<String>,
+                nested_directories: Vec<String>,
+                nested_files: Vec<File>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    nested_directories,
+                    nested_files,
+                }
+            }
+        }
+        impl Directory {
+            pub fn builder() -> DirectoryBuilder {
+                DirectoryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DirectoryBuilder {
+            name: Option<String>,
+            nested_directories: Option<Vec<String>>,
+            nested_files: Option<Vec<File>>,
+        }
+        impl DirectoryBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn nested_directorie(mut self, nested_directorie: impl Into<String>) -> Self {
+                let v = self.nested_directories.get_or_insert(Vec::new());
+                v.push(nested_directorie.into());
+                self
+            }
+            pub fn nested_directories<I, S>(mut self, nested_directories: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.nested_directories.get_or_insert(Vec::new());
+                for val in nested_directories {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn nested_file(mut self, nested_file: impl Into<File>) -> Self {
+                let v = self.nested_files.get_or_insert(Vec::new());
+                v.push(nested_file.into());
+                self
+            }
+            pub fn nested_files<I, S>(mut self, nested_files: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<File>,
+            {
+                let v = self.nested_files.get_or_insert(Vec::new());
+                for val in nested_files {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<Directory, String> {
+                Ok(Directory {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    nested_directories: self.nested_directories.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(nested_directories)
+                        )
+                    })?,
+                    nested_files: self.nested_files.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(nested_files))
+                    })?,
+                })
+            }
+        }
+        impl Directory {
+            pub const IDENTIFIER: &'static str = "FileSystem.Directory";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BucketFileSystemLocator {
+            #[doc = "Storage key"]
+            #[serde(rename = "storageKey")]
+            pub storage_key: super::storage::SerializedStorageKey,
+            #[doc = "Bucket name. Not passing a `bucketName` will retrieve the default Bucket. (https://developer.mozilla.org/en-US/docs/Web/API/Storage_API#storage_buckets)"]
+            #[serde(rename = "bucketName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub bucket_name: Option<String>,
+            #[doc = "Path to the directory using each path component as an array item."]
+            #[serde(rename = "pathComponents")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub path_components: Vec<String>,
+        }
+        impl BucketFileSystemLocator {
+            pub fn new(
+                storage_key: impl Into<super::storage::SerializedStorageKey>,
+                path_components: Vec<String>,
+            ) -> Self {
+                Self {
+                    storage_key: storage_key.into(),
+                    path_components,
+                    bucket_name: None,
+                }
+            }
+        }
+        impl BucketFileSystemLocator {
+            pub fn builder() -> BucketFileSystemLocatorBuilder {
+                BucketFileSystemLocatorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BucketFileSystemLocatorBuilder {
+            storage_key: Option<super::storage::SerializedStorageKey>,
+            bucket_name: Option<String>,
+            path_components: Option<Vec<String>>,
+        }
+        impl BucketFileSystemLocatorBuilder {
+            pub fn storage_key(
+                mut self,
+                storage_key: impl Into<super::storage::SerializedStorageKey>,
+            ) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn bucket_name(mut self, bucket_name: impl Into<String>) -> Self {
+                self.bucket_name = Some(bucket_name.into());
+                self
+            }
+            pub fn path_component(mut self, path_component: impl Into<String>) -> Self {
+                let v = self.path_components.get_or_insert(Vec::new());
+                v.push(path_component.into());
+                self
+            }
+            pub fn path_components<I, S>(mut self, path_components: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.path_components.get_or_insert(Vec::new());
+                for val in path_components {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<BucketFileSystemLocator, String> {
+                Ok(BucketFileSystemLocator {
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                    bucket_name: self.bucket_name,
+                    path_components: self.path_components.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(path_components))
+                    })?,
+                })
+            }
+        }
+        impl BucketFileSystemLocator {
+            pub const IDENTIFIER: &'static str = "FileSystem.BucketFileSystemLocator";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetDirectoryParams {
+            #[serde(rename = "bucketFileSystemLocator")]
+            pub bucket_file_system_locator: BucketFileSystemLocator,
+        }
+        impl GetDirectoryParams {
+            pub fn new(bucket_file_system_locator: impl Into<BucketFileSystemLocator>) -> Self {
+                Self {
+                    bucket_file_system_locator: bucket_file_system_locator.into(),
+                }
+            }
+        }
+        impl GetDirectoryParams {
+            pub fn builder() -> GetDirectoryParamsBuilder {
+                GetDirectoryParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDirectoryParamsBuilder {
+            bucket_file_system_locator: Option<BucketFileSystemLocator>,
+        }
+        impl GetDirectoryParamsBuilder {
+            pub fn bucket_file_system_locator(
+                mut self,
+                bucket_file_system_locator: impl Into<BucketFileSystemLocator>,
+            ) -> Self {
+                self.bucket_file_system_locator = Some(bucket_file_system_locator.into());
+                self
+            }
+            pub fn build(self) -> Result<GetDirectoryParams, String> {
+                Ok(GetDirectoryParams {
+                    bucket_file_system_locator: self.bucket_file_system_locator.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(bucket_file_system_locator)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl GetDirectoryParams {
+            pub const IDENTIFIER: &'static str = "FileSystem.getDirectory";
+        }
+        impl chromiumoxide_types::Method for GetDirectoryParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetDirectoryParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetDirectoryReturns {
+            #[doc = "Returns the directory object at the path."]
+            #[serde(rename = "directory")]
+            pub directory: Directory,
+        }
+        impl GetDirectoryReturns {
+            pub fn new(directory: impl Into<Directory>) -> Self {
+                Self {
+                    directory: directory.into(),
+                }
+            }
+        }
+        impl GetDirectoryReturns {
+            pub fn builder() -> GetDirectoryReturnsBuilder {
+                GetDirectoryReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDirectoryReturnsBuilder {
+            directory: Option<Directory>,
+        }
+        impl GetDirectoryReturnsBuilder {
+            pub fn directory(mut self, directory: impl Into<Directory>) -> Self {
+                self.directory = Some(directory.into());
+                self
+            }
+            pub fn build(self) -> Result<GetDirectoryReturns, String> {
+                Ok(GetDirectoryReturns {
+                    directory: self.directory.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(directory))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetDirectoryParams {
+            type Response = GetDirectoryReturns;
+        }
+    }
+    #[doc = "This domain provides experimental commands only supported in headless mode."]
+    pub mod headless_experimental {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Encoding options for a screenshot.\n[ScreenshotParams](https://chromedevtools.github.io/devtools-protocol/tot/HeadlessExperimental/#type-ScreenshotParams)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ScreenshotParams {
+            #[doc = "Image compression format (defaults to png)."]
+            #[serde(rename = "format")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub format: Option<ScreenshotParamsFormat>,
+            #[doc = "Compression quality from range [0..100] (jpeg and webp only)."]
+            #[serde(rename = "quality")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub quality: Option<i64>,
+            #[doc = "Optimize image encoding for speed, not for resulting size (defaults to false)"]
+            #[serde(rename = "optimizeForSpeed")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub optimize_for_speed: Option<bool>,
+        }
+        #[doc = "Image compression format (defaults to png)."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ScreenshotParamsFormat {
+            #[serde(rename = "jpeg")]
+            Jpeg,
+            #[serde(rename = "png")]
+            Png,
+            #[serde(rename = "webp")]
+            Webp,
+        }
+        impl AsRef<str> for ScreenshotParamsFormat {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ScreenshotParamsFormat::Jpeg => "jpeg",
+                    ScreenshotParamsFormat::Png => "png",
+                    ScreenshotParamsFormat::Webp => "webp",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ScreenshotParamsFormat {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "jpeg" | "Jpeg" => Ok(ScreenshotParamsFormat::Jpeg),
+                    "png" | "Png" => Ok(ScreenshotParamsFormat::Png),
+                    "webp" | "Webp" => Ok(ScreenshotParamsFormat::Webp),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl ScreenshotParams {
+            pub fn builder() -> ScreenshotParamsBuilder {
+                ScreenshotParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScreenshotParamsBuilder {
+            format: Option<ScreenshotParamsFormat>,
+            quality: Option<i64>,
+            optimize_for_speed: Option<bool>,
+        }
+        impl ScreenshotParamsBuilder {
+            pub fn format(mut self, format: impl Into<ScreenshotParamsFormat>) -> Self {
+                self.format = Some(format.into());
+                self
+            }
+            pub fn quality(mut self, quality: impl Into<i64>) -> Self {
+                self.quality = Some(quality.into());
+                self
+            }
+            pub fn optimize_for_speed(mut self, optimize_for_speed: impl Into<bool>) -> Self {
+                self.optimize_for_speed = Some(optimize_for_speed.into());
+                self
+            }
+            pub fn build(self) -> ScreenshotParams {
+                ScreenshotParams {
+                    format: self.format,
+                    quality: self.quality,
+                    optimize_for_speed: self.optimize_for_speed,
+                }
+            }
+        }
+        impl ScreenshotParams {
+            pub const IDENTIFIER: &'static str = "HeadlessExperimental.ScreenshotParams";
+        }
+        #[doc = "Sends a BeginFrame to the target and returns when the frame was completed. Optionally captures a\nscreenshot from the resulting frame. Requires that the target was created with enabled\nBeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also\nhttps://goo.gle/chrome-headless-rendering for more background.\n[beginFrame](https://chromedevtools.github.io/devtools-protocol/tot/HeadlessExperimental/#method-beginFrame)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct BeginFrameParams {
+            #[doc = "Timestamp of this BeginFrame in Renderer TimeTicks (milliseconds of uptime). If not set,\nthe current time will be used."]
+            #[serde(rename = "frameTimeTicks")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_time_ticks: Option<f64>,
+            #[doc = "The interval between BeginFrames that is reported to the compositor, in milliseconds.\nDefaults to a 60 frames/second interval, i.e. about 16.666 milliseconds."]
+            #[serde(rename = "interval")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub interval: Option<f64>,
+            #[doc = "Whether updates should not be committed and drawn onto the display. False by default. If\ntrue, only side effects of the BeginFrame will be run, such as layout and animations, but\nany visual updates may not be visible on the display or in screenshots."]
+            #[serde(rename = "noDisplayUpdates")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub no_display_updates: Option<bool>,
+            #[doc = "If set, a screenshot of the frame will be captured and returned in the response. Otherwise,\nno screenshot will be captured. Note that capturing a screenshot can fail, for example,\nduring renderer initialization. In such a case, no screenshot data will be returned."]
+            #[serde(rename = "screenshot")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub screenshot: Option<ScreenshotParams>,
+        }
+        impl BeginFrameParams {
+            pub fn builder() -> BeginFrameParamsBuilder {
+                BeginFrameParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BeginFrameParamsBuilder {
+            frame_time_ticks: Option<f64>,
+            interval: Option<f64>,
+            no_display_updates: Option<bool>,
+            screenshot: Option<ScreenshotParams>,
+        }
+        impl BeginFrameParamsBuilder {
+            pub fn frame_time_ticks(mut self, frame_time_ticks: impl Into<f64>) -> Self {
+                self.frame_time_ticks = Some(frame_time_ticks.into());
+                self
+            }
+            pub fn interval(mut self, interval: impl Into<f64>) -> Self {
+                self.interval = Some(interval.into());
+                self
+            }
+            pub fn no_display_updates(mut self, no_display_updates: impl Into<bool>) -> Self {
+                self.no_display_updates = Some(no_display_updates.into());
+                self
+            }
+            pub fn screenshot(mut self, screenshot: impl Into<ScreenshotParams>) -> Self {
+                self.screenshot = Some(screenshot.into());
+                self
+            }
+            pub fn build(self) -> BeginFrameParams {
+                BeginFrameParams {
+                    frame_time_ticks: self.frame_time_ticks,
+                    interval: self.interval,
+                    no_display_updates: self.no_display_updates,
+                    screenshot: self.screenshot,
+                }
+            }
+        }
+        impl BeginFrameParams {
+            pub const IDENTIFIER: &'static str = "HeadlessExperimental.beginFrame";
+        }
+        impl chromiumoxide_types::Method for BeginFrameParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for BeginFrameParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sends a BeginFrame to the target and returns when the frame was completed. Optionally captures a\nscreenshot from the resulting frame. Requires that the target was created with enabled\nBeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also\nhttps://goo.gle/chrome-headless-rendering for more background.\n[beginFrame](https://chromedevtools.github.io/devtools-protocol/tot/HeadlessExperimental/#method-beginFrame)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BeginFrameReturns {
+            #[doc = "Whether the BeginFrame resulted in damage and, thus, a new frame was committed to the\ndisplay. Reported for diagnostic uses, may be removed in the future."]
+            #[serde(rename = "hasDamage")]
+            pub has_damage: bool,
+            #[doc = "Base64-encoded image data of the screenshot, if one was requested and successfully taken."]
+            #[serde(rename = "screenshotData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub screenshot_data: Option<chromiumoxide_types::Binary>,
+        }
+        impl BeginFrameReturns {
+            pub fn new(has_damage: impl Into<bool>) -> Self {
+                Self {
+                    has_damage: has_damage.into(),
+                    screenshot_data: None,
+                }
+            }
+        }
+        impl BeginFrameReturns {
+            pub fn builder() -> BeginFrameReturnsBuilder {
+                BeginFrameReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BeginFrameReturnsBuilder {
+            has_damage: Option<bool>,
+            screenshot_data: Option<chromiumoxide_types::Binary>,
+        }
+        impl BeginFrameReturnsBuilder {
+            pub fn has_damage(mut self, has_damage: impl Into<bool>) -> Self {
+                self.has_damage = Some(has_damage.into());
+                self
+            }
+            pub fn screenshot_data(
+                mut self,
+                screenshot_data: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.screenshot_data = Some(screenshot_data.into());
+                self
+            }
+            pub fn build(self) -> Result<BeginFrameReturns, String> {
+                Ok(BeginFrameReturns {
+                    has_damage: self.has_damage.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(has_damage))
+                    })?,
+                    screenshot_data: self.screenshot_data,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for BeginFrameParams {
+            type Response = BeginFrameReturns;
+        }
+    }
+    #[doc = "Input/Output operations for streams produced by DevTools."]
+    pub mod io {
+        use serde::{Deserialize, Serialize};
+        #[doc = "This is either obtained from another method or specified as `blob:<uuid>` where\n`<uuid>` is an UUID of a Blob.\n[StreamHandle](https://chromedevtools.github.io/devtools-protocol/tot/IO/#type-StreamHandle)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct StreamHandle(String);
+        impl StreamHandle {
+            pub fn new(val: impl Into<String>) -> Self {
+                StreamHandle(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for StreamHandle {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<StreamHandle> for String {
+            fn from(el: StreamHandle) -> String {
+                el.0
+            }
+        }
+        impl From<String> for StreamHandle {
+            fn from(expr: String) -> Self {
+                StreamHandle(expr)
+            }
+        }
+        impl StreamHandle {
+            pub const IDENTIFIER: &'static str = "IO.StreamHandle";
+        }
+        #[doc = "Close the stream, discard any temporary backing storage.\n[close](https://chromedevtools.github.io/devtools-protocol/tot/IO/#method-close)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CloseParams {
+            #[doc = "Handle of the stream to close."]
+            #[serde(rename = "handle")]
+            pub handle: StreamHandle,
+        }
+        impl CloseParams {
+            pub fn new(handle: impl Into<StreamHandle>) -> Self {
+                Self {
+                    handle: handle.into(),
+                }
+            }
+        }
+        impl CloseParams {
+            pub fn builder() -> CloseParamsBuilder {
+                CloseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CloseParamsBuilder {
+            handle: Option<StreamHandle>,
+        }
+        impl CloseParamsBuilder {
+            pub fn handle(mut self, handle: impl Into<StreamHandle>) -> Self {
+                self.handle = Some(handle.into());
+                self
+            }
+            pub fn build(self) -> Result<CloseParams, String> {
+                Ok(CloseParams {
+                    handle: self.handle.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(handle))
+                    })?,
+                })
+            }
+        }
+        impl CloseParams {
+            pub const IDENTIFIER: &'static str = "IO.close";
+        }
+        impl chromiumoxide_types::Method for CloseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CloseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Close the stream, discard any temporary backing storage.\n[close](https://chromedevtools.github.io/devtools-protocol/tot/IO/#method-close)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CloseReturns {}
+        impl chromiumoxide_types::Command for CloseParams {
+            type Response = CloseReturns;
+        }
+        #[doc = "Read a chunk of the stream\n[read](https://chromedevtools.github.io/devtools-protocol/tot/IO/#method-read)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReadParams {
+            #[doc = "Handle of the stream to read."]
+            #[serde(rename = "handle")]
+            pub handle: StreamHandle,
+            #[doc = "Seek to the specified offset before reading (if not specified, proceed with offset\nfollowing the last read). Some types of streams may only support sequential reads."]
+            #[serde(rename = "offset")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub offset: Option<i64>,
+            #[doc = "Maximum number of bytes to read (left upon the agent discretion if not specified)."]
+            #[serde(rename = "size")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub size: Option<i64>,
+        }
+        impl ReadParams {
+            pub fn new(handle: impl Into<StreamHandle>) -> Self {
+                Self {
+                    handle: handle.into(),
+                    offset: None,
+                    size: None,
+                }
+            }
+        }
+        impl ReadParams {
+            pub fn builder() -> ReadParamsBuilder {
+                ReadParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReadParamsBuilder {
+            handle: Option<StreamHandle>,
+            offset: Option<i64>,
+            size: Option<i64>,
+        }
+        impl ReadParamsBuilder {
+            pub fn handle(mut self, handle: impl Into<StreamHandle>) -> Self {
+                self.handle = Some(handle.into());
+                self
+            }
+            pub fn offset(mut self, offset: impl Into<i64>) -> Self {
+                self.offset = Some(offset.into());
+                self
+            }
+            pub fn size(mut self, size: impl Into<i64>) -> Self {
+                self.size = Some(size.into());
+                self
+            }
+            pub fn build(self) -> Result<ReadParams, String> {
+                Ok(ReadParams {
+                    handle: self.handle.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(handle))
+                    })?,
+                    offset: self.offset,
+                    size: self.size,
+                })
+            }
+        }
+        impl ReadParams {
+            pub const IDENTIFIER: &'static str = "IO.read";
+        }
+        impl chromiumoxide_types::Method for ReadParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ReadParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Read a chunk of the stream\n[read](https://chromedevtools.github.io/devtools-protocol/tot/IO/#method-read)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReadReturns {
+            #[doc = "Set if the data is base64-encoded"]
+            #[serde(rename = "base64Encoded")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub base64_encoded: Option<bool>,
+            #[doc = "Data that were read."]
+            #[serde(rename = "data")]
+            pub data: String,
+            #[doc = "Set if the end-of-file condition occurred while reading."]
+            #[serde(rename = "eof")]
+            pub eof: bool,
+        }
+        impl ReadReturns {
+            pub fn new(data: impl Into<String>, eof: impl Into<bool>) -> Self {
+                Self {
+                    data: data.into(),
+                    eof: eof.into(),
+                    base64_encoded: None,
+                }
+            }
+        }
+        impl ReadReturns {
+            pub fn builder() -> ReadReturnsBuilder {
+                ReadReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReadReturnsBuilder {
+            base64_encoded: Option<bool>,
+            data: Option<String>,
+            eof: Option<bool>,
+        }
+        impl ReadReturnsBuilder {
+            pub fn base64_encoded(mut self, base64_encoded: impl Into<bool>) -> Self {
+                self.base64_encoded = Some(base64_encoded.into());
+                self
+            }
+            pub fn data(mut self, data: impl Into<String>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn eof(mut self, eof: impl Into<bool>) -> Self {
+                self.eof = Some(eof.into());
+                self
+            }
+            pub fn build(self) -> Result<ReadReturns, String> {
+                Ok(ReadReturns {
+                    base64_encoded: self.base64_encoded,
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                    eof: self
+                        .eof
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(eof)))?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for ReadParams {
+            type Response = ReadReturns;
+        }
+        #[doc = "Return UUID of Blob object specified by a remote object id.\n[resolveBlob](https://chromedevtools.github.io/devtools-protocol/tot/IO/#method-resolveBlob)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ResolveBlobParams {
+            #[doc = "Object id of a Blob object wrapper."]
+            #[serde(rename = "objectId")]
+            pub object_id: super::super::js_protocol::runtime::RemoteObjectId,
+        }
+        impl ResolveBlobParams {
+            pub fn new(
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                Self {
+                    object_id: object_id.into(),
+                }
+            }
+        }
+        impl ResolveBlobParams {
+            pub fn builder() -> ResolveBlobParamsBuilder {
+                ResolveBlobParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResolveBlobParamsBuilder {
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl ResolveBlobParamsBuilder {
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ResolveBlobParams, String> {
+                Ok(ResolveBlobParams {
+                    object_id: self.object_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_id))
+                    })?,
+                })
+            }
+        }
+        impl ResolveBlobParams {
+            pub const IDENTIFIER: &'static str = "IO.resolveBlob";
+        }
+        impl chromiumoxide_types::Method for ResolveBlobParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ResolveBlobParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Return UUID of Blob object specified by a remote object id.\n[resolveBlob](https://chromedevtools.github.io/devtools-protocol/tot/IO/#method-resolveBlob)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ResolveBlobReturns {
+            #[doc = "UUID of the specified Blob."]
+            #[serde(rename = "uuid")]
+            pub uuid: String,
+        }
+        impl ResolveBlobReturns {
+            pub fn new(uuid: impl Into<String>) -> Self {
+                Self { uuid: uuid.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for ResolveBlobReturns {
+            fn from(url: T) -> Self {
+                ResolveBlobReturns::new(url)
+            }
+        }
+        impl ResolveBlobReturns {
+            pub fn builder() -> ResolveBlobReturnsBuilder {
+                ResolveBlobReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResolveBlobReturnsBuilder {
+            uuid: Option<String>,
+        }
+        impl ResolveBlobReturnsBuilder {
+            pub fn uuid(mut self, uuid: impl Into<String>) -> Self {
+                self.uuid = Some(uuid.into());
+                self
+            }
+            pub fn build(self) -> Result<ResolveBlobReturns, String> {
+                Ok(ResolveBlobReturns {
+                    uuid: self.uuid.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(uuid))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for ResolveBlobParams {
+            type Response = ResolveBlobReturns;
+        }
+    }
+    pub mod indexed_db {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Database with an array of object stores.\n[DatabaseWithObjectStores](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#type-DatabaseWithObjectStores)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DatabaseWithObjectStores {
+            #[doc = "Database name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Database version (type is not 'integer', as the standard\nrequires the version number to be 'unsigned long long')"]
+            #[serde(rename = "version")]
+            pub version: f64,
+            #[doc = "Object stores in this database."]
+            #[serde(rename = "objectStores")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub object_stores: Vec<ObjectStore>,
+        }
+        impl DatabaseWithObjectStores {
+            pub fn new(
+                name: impl Into<String>,
+                version: impl Into<f64>,
+                object_stores: Vec<ObjectStore>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    version: version.into(),
+                    object_stores,
+                }
+            }
+        }
+        impl DatabaseWithObjectStores {
+            pub fn builder() -> DatabaseWithObjectStoresBuilder {
+                DatabaseWithObjectStoresBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DatabaseWithObjectStoresBuilder {
+            name: Option<String>,
+            version: Option<f64>,
+            object_stores: Option<Vec<ObjectStore>>,
+        }
+        impl DatabaseWithObjectStoresBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn version(mut self, version: impl Into<f64>) -> Self {
+                self.version = Some(version.into());
+                self
+            }
+            pub fn object_store(mut self, object_store: impl Into<ObjectStore>) -> Self {
+                let v = self.object_stores.get_or_insert(Vec::new());
+                v.push(object_store.into());
+                self
+            }
+            pub fn object_stores<I, S>(mut self, object_stores: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ObjectStore>,
+            {
+                let v = self.object_stores.get_or_insert(Vec::new());
+                for val in object_stores {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<DatabaseWithObjectStores, String> {
+                Ok(DatabaseWithObjectStores {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    version: self.version.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(version))
+                    })?,
+                    object_stores: self.object_stores.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(object_stores))
+                    })?,
+                })
+            }
+        }
+        impl DatabaseWithObjectStores {
+            pub const IDENTIFIER: &'static str = "IndexedDB.DatabaseWithObjectStores";
+        }
+        #[doc = "Object store.\n[ObjectStore](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#type-ObjectStore)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ObjectStore {
+            #[doc = "Object store name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Object store key path."]
+            #[serde(rename = "keyPath")]
+            pub key_path: KeyPath,
+            #[doc = "If true, object store has auto increment flag set."]
+            #[serde(rename = "autoIncrement")]
+            pub auto_increment: bool,
+            #[doc = "Indexes in this object store."]
+            #[serde(rename = "indexes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub indexes: Vec<ObjectStoreIndex>,
+        }
+        impl ObjectStore {
+            pub fn new(
+                name: impl Into<String>,
+                key_path: impl Into<KeyPath>,
+                auto_increment: impl Into<bool>,
+                indexes: Vec<ObjectStoreIndex>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    key_path: key_path.into(),
+                    auto_increment: auto_increment.into(),
+                    indexes,
+                }
+            }
+        }
+        impl ObjectStore {
+            pub fn builder() -> ObjectStoreBuilder {
+                ObjectStoreBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ObjectStoreBuilder {
+            name: Option<String>,
+            key_path: Option<KeyPath>,
+            auto_increment: Option<bool>,
+            indexes: Option<Vec<ObjectStoreIndex>>,
+        }
+        impl ObjectStoreBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn key_path(mut self, key_path: impl Into<KeyPath>) -> Self {
+                self.key_path = Some(key_path.into());
+                self
+            }
+            pub fn auto_increment(mut self, auto_increment: impl Into<bool>) -> Self {
+                self.auto_increment = Some(auto_increment.into());
+                self
+            }
+            pub fn indexe(mut self, indexe: impl Into<ObjectStoreIndex>) -> Self {
+                let v = self.indexes.get_or_insert(Vec::new());
+                v.push(indexe.into());
+                self
+            }
+            pub fn indexes<I, S>(mut self, indexes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ObjectStoreIndex>,
+            {
+                let v = self.indexes.get_or_insert(Vec::new());
+                for val in indexes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ObjectStore, String> {
+                Ok(ObjectStore {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    key_path: self.key_path.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_path))
+                    })?,
+                    auto_increment: self.auto_increment.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(auto_increment))
+                    })?,
+                    indexes: self.indexes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(indexes))
+                    })?,
+                })
+            }
+        }
+        impl ObjectStore {
+            pub const IDENTIFIER: &'static str = "IndexedDB.ObjectStore";
+        }
+        #[doc = "Object store index.\n[ObjectStoreIndex](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#type-ObjectStoreIndex)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ObjectStoreIndex {
+            #[doc = "Index name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Index key path."]
+            #[serde(rename = "keyPath")]
+            pub key_path: KeyPath,
+            #[doc = "If true, index is unique."]
+            #[serde(rename = "unique")]
+            pub unique: bool,
+            #[doc = "If true, index allows multiple entries for a key."]
+            #[serde(rename = "multiEntry")]
+            pub multi_entry: bool,
+        }
+        impl ObjectStoreIndex {
+            pub fn new(
+                name: impl Into<String>,
+                key_path: impl Into<KeyPath>,
+                unique: impl Into<bool>,
+                multi_entry: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    key_path: key_path.into(),
+                    unique: unique.into(),
+                    multi_entry: multi_entry.into(),
+                }
+            }
+        }
+        impl ObjectStoreIndex {
+            pub fn builder() -> ObjectStoreIndexBuilder {
+                ObjectStoreIndexBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ObjectStoreIndexBuilder {
+            name: Option<String>,
+            key_path: Option<KeyPath>,
+            unique: Option<bool>,
+            multi_entry: Option<bool>,
+        }
+        impl ObjectStoreIndexBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn key_path(mut self, key_path: impl Into<KeyPath>) -> Self {
+                self.key_path = Some(key_path.into());
+                self
+            }
+            pub fn unique(mut self, unique: impl Into<bool>) -> Self {
+                self.unique = Some(unique.into());
+                self
+            }
+            pub fn multi_entry(mut self, multi_entry: impl Into<bool>) -> Self {
+                self.multi_entry = Some(multi_entry.into());
+                self
+            }
+            pub fn build(self) -> Result<ObjectStoreIndex, String> {
+                Ok(ObjectStoreIndex {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    key_path: self.key_path.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_path))
+                    })?,
+                    unique: self.unique.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(unique))
+                    })?,
+                    multi_entry: self.multi_entry.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(multi_entry))
+                    })?,
+                })
+            }
+        }
+        impl ObjectStoreIndex {
+            pub const IDENTIFIER: &'static str = "IndexedDB.ObjectStoreIndex";
+        }
+        #[doc = "Key.\n[Key](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#type-Key)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Key {
+            #[doc = "Key type."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: KeyType,
+            #[doc = "Number value."]
+            #[serde(rename = "number")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub number: Option<f64>,
+            #[doc = "String value."]
+            #[serde(rename = "string")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub string: Option<String>,
+            #[doc = "Date value."]
+            #[serde(rename = "date")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub date: Option<f64>,
+            #[doc = "Array value."]
+            #[serde(rename = "array")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub array: Option<Vec<Key>>,
+        }
+        #[doc = "Key type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum KeyType {
+            #[serde(rename = "number")]
+            Number,
+            #[serde(rename = "string")]
+            String,
+            #[serde(rename = "date")]
+            Date,
+            #[serde(rename = "array")]
+            Array,
+        }
+        impl AsRef<str> for KeyType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    KeyType::Number => "number",
+                    KeyType::String => "string",
+                    KeyType::Date => "date",
+                    KeyType::Array => "array",
+                }
+            }
+        }
+        impl ::std::str::FromStr for KeyType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "number" | "Number" => Ok(KeyType::Number),
+                    "string" | "String" => Ok(KeyType::String),
+                    "date" | "Date" => Ok(KeyType::Date),
+                    "array" | "Array" => Ok(KeyType::Array),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl Key {
+            pub fn new(r#type: impl Into<KeyType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    number: None,
+                    string: None,
+                    date: None,
+                    array: None,
+                }
+            }
+        }
+        impl Key {
+            pub fn builder() -> KeyBuilder {
+                KeyBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct KeyBuilder {
+            r#type: Option<KeyType>,
+            number: Option<f64>,
+            string: Option<String>,
+            date: Option<f64>,
+            array: Option<Vec<Key>>,
+        }
+        impl KeyBuilder {
+            pub fn r#type(mut self, r#type: impl Into<KeyType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn number(mut self, number: impl Into<f64>) -> Self {
+                self.number = Some(number.into());
+                self
+            }
+            pub fn string(mut self, string: impl Into<String>) -> Self {
+                self.string = Some(string.into());
+                self
+            }
+            pub fn date(mut self, date: impl Into<f64>) -> Self {
+                self.date = Some(date.into());
+                self
+            }
+            pub fn array(mut self, array: impl Into<Key>) -> Self {
+                let v = self.array.get_or_insert(Vec::new());
+                v.push(array.into());
+                self
+            }
+            pub fn arrays<I, S>(mut self, arrays: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Key>,
+            {
+                let v = self.array.get_or_insert(Vec::new());
+                for val in arrays {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<Key, String> {
+                Ok(Key {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    number: self.number,
+                    string: self.string,
+                    date: self.date,
+                    array: self.array,
+                })
+            }
+        }
+        impl Key {
+            pub const IDENTIFIER: &'static str = "IndexedDB.Key";
+        }
+        #[doc = "Key range.\n[KeyRange](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#type-KeyRange)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct KeyRange {
+            #[doc = "Lower bound."]
+            #[serde(rename = "lower")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub lower: Option<Key>,
+            #[doc = "Upper bound."]
+            #[serde(rename = "upper")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub upper: Option<Key>,
+            #[doc = "If true lower bound is open."]
+            #[serde(rename = "lowerOpen")]
+            pub lower_open: bool,
+            #[doc = "If true upper bound is open."]
+            #[serde(rename = "upperOpen")]
+            pub upper_open: bool,
+        }
+        impl KeyRange {
+            pub fn new(lower_open: impl Into<bool>, upper_open: impl Into<bool>) -> Self {
+                Self {
+                    lower_open: lower_open.into(),
+                    upper_open: upper_open.into(),
+                    lower: None,
+                    upper: None,
+                }
+            }
+        }
+        impl KeyRange {
+            pub fn builder() -> KeyRangeBuilder {
+                KeyRangeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct KeyRangeBuilder {
+            lower: Option<Key>,
+            upper: Option<Key>,
+            lower_open: Option<bool>,
+            upper_open: Option<bool>,
+        }
+        impl KeyRangeBuilder {
+            pub fn lower(mut self, lower: impl Into<Key>) -> Self {
+                self.lower = Some(lower.into());
+                self
+            }
+            pub fn upper(mut self, upper: impl Into<Key>) -> Self {
+                self.upper = Some(upper.into());
+                self
+            }
+            pub fn lower_open(mut self, lower_open: impl Into<bool>) -> Self {
+                self.lower_open = Some(lower_open.into());
+                self
+            }
+            pub fn upper_open(mut self, upper_open: impl Into<bool>) -> Self {
+                self.upper_open = Some(upper_open.into());
+                self
+            }
+            pub fn build(self) -> Result<KeyRange, String> {
+                Ok(KeyRange {
+                    lower: self.lower,
+                    upper: self.upper,
+                    lower_open: self.lower_open.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(lower_open))
+                    })?,
+                    upper_open: self.upper_open.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(upper_open))
+                    })?,
+                })
+            }
+        }
+        impl KeyRange {
+            pub const IDENTIFIER: &'static str = "IndexedDB.KeyRange";
+        }
+        #[doc = "Data entry.\n[DataEntry](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#type-DataEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DataEntry {
+            #[doc = "Key object."]
+            #[serde(rename = "key")]
+            pub key: super::super::js_protocol::runtime::RemoteObject,
+            #[doc = "Primary key object."]
+            #[serde(rename = "primaryKey")]
+            pub primary_key: super::super::js_protocol::runtime::RemoteObject,
+            #[doc = "Value object."]
+            #[serde(rename = "value")]
+            pub value: super::super::js_protocol::runtime::RemoteObject,
+        }
+        impl DataEntry {
+            pub fn new(
+                key: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+                primary_key: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+                value: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                Self {
+                    key: key.into(),
+                    primary_key: primary_key.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl DataEntry {
+            pub fn builder() -> DataEntryBuilder {
+                DataEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DataEntryBuilder {
+            key: Option<super::super::js_protocol::runtime::RemoteObject>,
+            primary_key: Option<super::super::js_protocol::runtime::RemoteObject>,
+            value: Option<super::super::js_protocol::runtime::RemoteObject>,
+        }
+        impl DataEntryBuilder {
+            pub fn key(
+                mut self,
+                key: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn primary_key(
+                mut self,
+                primary_key: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                self.primary_key = Some(primary_key.into());
+                self
+            }
+            pub fn value(
+                mut self,
+                value: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<DataEntry, String> {
+                Ok(DataEntry {
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    primary_key: self.primary_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(primary_key))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl DataEntry {
+            pub const IDENTIFIER: &'static str = "IndexedDB.DataEntry";
+        }
+        #[doc = "Key path.\n[KeyPath](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#type-KeyPath)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct KeyPath {
+            #[doc = "Key path type."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: KeyPathType,
+            #[doc = "String value."]
+            #[serde(rename = "string")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub string: Option<String>,
+            #[doc = "Array value."]
+            #[serde(rename = "array")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub array: Option<Vec<String>>,
+        }
+        #[doc = "Key path type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum KeyPathType {
+            #[serde(rename = "null")]
+            Null,
+            #[serde(rename = "string")]
+            String,
+            #[serde(rename = "array")]
+            Array,
+        }
+        impl AsRef<str> for KeyPathType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    KeyPathType::Null => "null",
+                    KeyPathType::String => "string",
+                    KeyPathType::Array => "array",
+                }
+            }
+        }
+        impl ::std::str::FromStr for KeyPathType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "null" | "Null" => Ok(KeyPathType::Null),
+                    "string" | "String" => Ok(KeyPathType::String),
+                    "array" | "Array" => Ok(KeyPathType::Array),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl KeyPath {
+            pub fn new(r#type: impl Into<KeyPathType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    string: None,
+                    array: None,
+                }
+            }
+        }
+        impl KeyPath {
+            pub fn builder() -> KeyPathBuilder {
+                KeyPathBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct KeyPathBuilder {
+            r#type: Option<KeyPathType>,
+            string: Option<String>,
+            array: Option<Vec<String>>,
+        }
+        impl KeyPathBuilder {
+            pub fn r#type(mut self, r#type: impl Into<KeyPathType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn string(mut self, string: impl Into<String>) -> Self {
+                self.string = Some(string.into());
+                self
+            }
+            pub fn array(mut self, array: impl Into<String>) -> Self {
+                let v = self.array.get_or_insert(Vec::new());
+                v.push(array.into());
+                self
+            }
+            pub fn arrays<I, S>(mut self, arrays: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.array.get_or_insert(Vec::new());
+                for val in arrays {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<KeyPath, String> {
+                Ok(KeyPath {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    string: self.string,
+                    array: self.array,
+                })
+            }
+        }
+        impl KeyPath {
+            pub const IDENTIFIER: &'static str = "IndexedDB.KeyPath";
+        }
+        #[doc = "Clears all entries from an object store.\n[clearObjectStore](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-clearObjectStore)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClearObjectStoreParams {
+            #[doc = "At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.\nSecurity origin."]
+            #[serde(rename = "securityOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_origin: Option<String>,
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_key: Option<String>,
+            #[doc = "Storage bucket. If not specified, it uses the default bucket."]
+            #[serde(rename = "storageBucket")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_bucket: Option<super::storage::StorageBucket>,
+            #[doc = "Database name."]
+            #[serde(rename = "databaseName")]
+            pub database_name: String,
+            #[doc = "Object store name."]
+            #[serde(rename = "objectStoreName")]
+            pub object_store_name: String,
+        }
+        impl ClearObjectStoreParams {
+            pub fn new(
+                database_name: impl Into<String>,
+                object_store_name: impl Into<String>,
+            ) -> Self {
+                Self {
+                    database_name: database_name.into(),
+                    object_store_name: object_store_name.into(),
+                    security_origin: None,
+                    storage_key: None,
+                    storage_bucket: None,
+                }
+            }
+        }
+        impl ClearObjectStoreParams {
+            pub fn builder() -> ClearObjectStoreParamsBuilder {
+                ClearObjectStoreParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearObjectStoreParamsBuilder {
+            security_origin: Option<String>,
+            storage_key: Option<String>,
+            storage_bucket: Option<super::storage::StorageBucket>,
+            database_name: Option<String>,
+            object_store_name: Option<String>,
+        }
+        impl ClearObjectStoreParamsBuilder {
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn storage_bucket(
+                mut self,
+                storage_bucket: impl Into<super::storage::StorageBucket>,
+            ) -> Self {
+                self.storage_bucket = Some(storage_bucket.into());
+                self
+            }
+            pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
+                self.database_name = Some(database_name.into());
+                self
+            }
+            pub fn object_store_name(mut self, object_store_name: impl Into<String>) -> Self {
+                self.object_store_name = Some(object_store_name.into());
+                self
+            }
+            pub fn build(self) -> Result<ClearObjectStoreParams, String> {
+                Ok(ClearObjectStoreParams {
+                    security_origin: self.security_origin,
+                    storage_key: self.storage_key,
+                    storage_bucket: self.storage_bucket,
+                    database_name: self.database_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(database_name))
+                    })?,
+                    object_store_name: self.object_store_name.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(object_store_name)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl ClearObjectStoreParams {
+            pub const IDENTIFIER: &'static str = "IndexedDB.clearObjectStore";
+        }
+        impl chromiumoxide_types::Method for ClearObjectStoreParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearObjectStoreParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears all entries from an object store.\n[clearObjectStore](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-clearObjectStore)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearObjectStoreReturns {}
+        impl chromiumoxide_types::Command for ClearObjectStoreParams {
+            type Response = ClearObjectStoreReturns;
+        }
+        #[doc = "Deletes a database.\n[deleteDatabase](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-deleteDatabase)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeleteDatabaseParams {
+            #[doc = "At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.\nSecurity origin."]
+            #[serde(rename = "securityOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_origin: Option<String>,
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_key: Option<String>,
+            #[doc = "Storage bucket. If not specified, it uses the default bucket."]
+            #[serde(rename = "storageBucket")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_bucket: Option<super::storage::StorageBucket>,
+            #[doc = "Database name."]
+            #[serde(rename = "databaseName")]
+            pub database_name: String,
+        }
+        impl DeleteDatabaseParams {
+            pub fn new(database_name: impl Into<String>) -> Self {
+                Self {
+                    database_name: database_name.into(),
+                    security_origin: None,
+                    storage_key: None,
+                    storage_bucket: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for DeleteDatabaseParams {
+            fn from(url: T) -> Self {
+                DeleteDatabaseParams::new(url)
+            }
+        }
+        impl DeleteDatabaseParams {
+            pub fn builder() -> DeleteDatabaseParamsBuilder {
+                DeleteDatabaseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeleteDatabaseParamsBuilder {
+            security_origin: Option<String>,
+            storage_key: Option<String>,
+            storage_bucket: Option<super::storage::StorageBucket>,
+            database_name: Option<String>,
+        }
+        impl DeleteDatabaseParamsBuilder {
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn storage_bucket(
+                mut self,
+                storage_bucket: impl Into<super::storage::StorageBucket>,
+            ) -> Self {
+                self.storage_bucket = Some(storage_bucket.into());
+                self
+            }
+            pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
+                self.database_name = Some(database_name.into());
+                self
+            }
+            pub fn build(self) -> Result<DeleteDatabaseParams, String> {
+                Ok(DeleteDatabaseParams {
+                    security_origin: self.security_origin,
+                    storage_key: self.storage_key,
+                    storage_bucket: self.storage_bucket,
+                    database_name: self.database_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(database_name))
+                    })?,
+                })
+            }
+        }
+        impl DeleteDatabaseParams {
+            pub const IDENTIFIER: &'static str = "IndexedDB.deleteDatabase";
+        }
+        impl chromiumoxide_types::Method for DeleteDatabaseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DeleteDatabaseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Deletes a database.\n[deleteDatabase](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-deleteDatabase)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DeleteDatabaseReturns {}
+        impl chromiumoxide_types::Command for DeleteDatabaseParams {
+            type Response = DeleteDatabaseReturns;
+        }
+        #[doc = "Delete a range of entries from an object store\n[deleteObjectStoreEntries](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-deleteObjectStoreEntries)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeleteObjectStoreEntriesParams {
+            #[doc = "At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.\nSecurity origin."]
+            #[serde(rename = "securityOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_origin: Option<String>,
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_key: Option<String>,
+            #[doc = "Storage bucket. If not specified, it uses the default bucket."]
+            #[serde(rename = "storageBucket")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_bucket: Option<super::storage::StorageBucket>,
+            #[serde(rename = "databaseName")]
+            pub database_name: String,
+            #[serde(rename = "objectStoreName")]
+            pub object_store_name: String,
+            #[doc = "Range of entry keys to delete"]
+            #[serde(rename = "keyRange")]
+            pub key_range: KeyRange,
+        }
+        impl DeleteObjectStoreEntriesParams {
+            pub fn new(
+                database_name: impl Into<String>,
+                object_store_name: impl Into<String>,
+                key_range: impl Into<KeyRange>,
+            ) -> Self {
+                Self {
+                    database_name: database_name.into(),
+                    object_store_name: object_store_name.into(),
+                    key_range: key_range.into(),
+                    security_origin: None,
+                    storage_key: None,
+                    storage_bucket: None,
+                }
+            }
+        }
+        impl DeleteObjectStoreEntriesParams {
+            pub fn builder() -> DeleteObjectStoreEntriesParamsBuilder {
+                DeleteObjectStoreEntriesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeleteObjectStoreEntriesParamsBuilder {
+            security_origin: Option<String>,
+            storage_key: Option<String>,
+            storage_bucket: Option<super::storage::StorageBucket>,
+            database_name: Option<String>,
+            object_store_name: Option<String>,
+            key_range: Option<KeyRange>,
+        }
+        impl DeleteObjectStoreEntriesParamsBuilder {
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn storage_bucket(
+                mut self,
+                storage_bucket: impl Into<super::storage::StorageBucket>,
+            ) -> Self {
+                self.storage_bucket = Some(storage_bucket.into());
+                self
+            }
+            pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
+                self.database_name = Some(database_name.into());
+                self
+            }
+            pub fn object_store_name(mut self, object_store_name: impl Into<String>) -> Self {
+                self.object_store_name = Some(object_store_name.into());
+                self
+            }
+            pub fn key_range(mut self, key_range: impl Into<KeyRange>) -> Self {
+                self.key_range = Some(key_range.into());
+                self
+            }
+            pub fn build(self) -> Result<DeleteObjectStoreEntriesParams, String> {
+                Ok(DeleteObjectStoreEntriesParams {
+                    security_origin: self.security_origin,
+                    storage_key: self.storage_key,
+                    storage_bucket: self.storage_bucket,
+                    database_name: self.database_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(database_name))
+                    })?,
+                    object_store_name: self.object_store_name.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(object_store_name)
+                        )
+                    })?,
+                    key_range: self.key_range.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_range))
+                    })?,
+                })
+            }
+        }
+        impl DeleteObjectStoreEntriesParams {
+            pub const IDENTIFIER: &'static str = "IndexedDB.deleteObjectStoreEntries";
+        }
+        impl chromiumoxide_types::Method for DeleteObjectStoreEntriesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DeleteObjectStoreEntriesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Delete a range of entries from an object store\n[deleteObjectStoreEntries](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-deleteObjectStoreEntries)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DeleteObjectStoreEntriesReturns {}
+        impl chromiumoxide_types::Command for DeleteObjectStoreEntriesParams {
+            type Response = DeleteObjectStoreEntriesReturns;
+        }
+        #[doc = "Disables events from backend.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "IndexedDB.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables events from backend.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables events from backend.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "IndexedDB.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables events from backend.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Requests data from object store or index.\n[requestData](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-requestData)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestDataParams {
+            #[doc = "At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.\nSecurity origin."]
+            #[serde(rename = "securityOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_origin: Option<String>,
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_key: Option<String>,
+            #[doc = "Storage bucket. If not specified, it uses the default bucket."]
+            #[serde(rename = "storageBucket")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_bucket: Option<super::storage::StorageBucket>,
+            #[doc = "Database name."]
+            #[serde(rename = "databaseName")]
+            pub database_name: String,
+            #[doc = "Object store name."]
+            #[serde(rename = "objectStoreName")]
+            pub object_store_name: String,
+            #[doc = "Index name. If not specified, it performs an object store data request."]
+            #[serde(rename = "indexName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub index_name: Option<String>,
+            #[doc = "Number of records to skip."]
+            #[serde(rename = "skipCount")]
+            pub skip_count: i64,
+            #[doc = "Number of records to fetch."]
+            #[serde(rename = "pageSize")]
+            pub page_size: i64,
+            #[doc = "Key range."]
+            #[serde(rename = "keyRange")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub key_range: Option<KeyRange>,
+        }
+        impl RequestDataParams {
+            pub fn new(
+                database_name: impl Into<String>,
+                object_store_name: impl Into<String>,
+                skip_count: impl Into<i64>,
+                page_size: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    database_name: database_name.into(),
+                    object_store_name: object_store_name.into(),
+                    skip_count: skip_count.into(),
+                    page_size: page_size.into(),
+                    security_origin: None,
+                    storage_key: None,
+                    storage_bucket: None,
+                    index_name: None,
+                    key_range: None,
+                }
+            }
+        }
+        impl RequestDataParams {
+            pub fn builder() -> RequestDataParamsBuilder {
+                RequestDataParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestDataParamsBuilder {
+            security_origin: Option<String>,
+            storage_key: Option<String>,
+            storage_bucket: Option<super::storage::StorageBucket>,
+            database_name: Option<String>,
+            object_store_name: Option<String>,
+            index_name: Option<String>,
+            skip_count: Option<i64>,
+            page_size: Option<i64>,
+            key_range: Option<KeyRange>,
+        }
+        impl RequestDataParamsBuilder {
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn storage_bucket(
+                mut self,
+                storage_bucket: impl Into<super::storage::StorageBucket>,
+            ) -> Self {
+                self.storage_bucket = Some(storage_bucket.into());
+                self
+            }
+            pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
+                self.database_name = Some(database_name.into());
+                self
+            }
+            pub fn object_store_name(mut self, object_store_name: impl Into<String>) -> Self {
+                self.object_store_name = Some(object_store_name.into());
+                self
+            }
+            pub fn index_name(mut self, index_name: impl Into<String>) -> Self {
+                self.index_name = Some(index_name.into());
+                self
+            }
+            pub fn skip_count(mut self, skip_count: impl Into<i64>) -> Self {
+                self.skip_count = Some(skip_count.into());
+                self
+            }
+            pub fn page_size(mut self, page_size: impl Into<i64>) -> Self {
+                self.page_size = Some(page_size.into());
+                self
+            }
+            pub fn key_range(mut self, key_range: impl Into<KeyRange>) -> Self {
+                self.key_range = Some(key_range.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestDataParams, String> {
+                Ok(RequestDataParams {
+                    security_origin: self.security_origin,
+                    storage_key: self.storage_key,
+                    storage_bucket: self.storage_bucket,
+                    database_name: self.database_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(database_name))
+                    })?,
+                    object_store_name: self.object_store_name.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(object_store_name)
+                        )
+                    })?,
+                    index_name: self.index_name,
+                    skip_count: self.skip_count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(skip_count))
+                    })?,
+                    page_size: self.page_size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(page_size))
+                    })?,
+                    key_range: self.key_range,
+                })
+            }
+        }
+        impl RequestDataParams {
+            pub const IDENTIFIER: &'static str = "IndexedDB.requestData";
+        }
+        impl chromiumoxide_types::Method for RequestDataParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RequestDataParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests data from object store or index.\n[requestData](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-requestData)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestDataReturns {
+            #[doc = "Array of object store data entries."]
+            #[serde(rename = "objectStoreDataEntries")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub object_store_data_entries: Vec<DataEntry>,
+            #[doc = "If true, there are more entries to fetch in the given range."]
+            #[serde(rename = "hasMore")]
+            pub has_more: bool,
+        }
+        impl RequestDataReturns {
+            pub fn new(
+                object_store_data_entries: Vec<DataEntry>,
+                has_more: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    object_store_data_entries,
+                    has_more: has_more.into(),
+                }
+            }
+        }
+        impl RequestDataReturns {
+            pub fn builder() -> RequestDataReturnsBuilder {
+                RequestDataReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestDataReturnsBuilder {
+            object_store_data_entries: Option<Vec<DataEntry>>,
+            has_more: Option<bool>,
+        }
+        impl RequestDataReturnsBuilder {
+            pub fn object_store_data_entrie(
+                mut self,
+                object_store_data_entrie: impl Into<DataEntry>,
+            ) -> Self {
+                let v = self.object_store_data_entries.get_or_insert(Vec::new());
+                v.push(object_store_data_entrie.into());
+                self
+            }
+            pub fn object_store_data_entries<I, S>(mut self, object_store_data_entries: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<DataEntry>,
+            {
+                let v = self.object_store_data_entries.get_or_insert(Vec::new());
+                for val in object_store_data_entries {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn has_more(mut self, has_more: impl Into<bool>) -> Self {
+                self.has_more = Some(has_more.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestDataReturns, String> {
+                Ok(RequestDataReturns {
+                    object_store_data_entries: self.object_store_data_entries.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(object_store_data_entries)
+                        )
+                    })?,
+                    has_more: self.has_more.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(has_more))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for RequestDataParams {
+            type Response = RequestDataReturns;
+        }
+        #[doc = "Gets metadata of an object store.\n[getMetadata](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-getMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetMetadataParams {
+            #[doc = "At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.\nSecurity origin."]
+            #[serde(rename = "securityOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_origin: Option<String>,
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_key: Option<String>,
+            #[doc = "Storage bucket. If not specified, it uses the default bucket."]
+            #[serde(rename = "storageBucket")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_bucket: Option<super::storage::StorageBucket>,
+            #[doc = "Database name."]
+            #[serde(rename = "databaseName")]
+            pub database_name: String,
+            #[doc = "Object store name."]
+            #[serde(rename = "objectStoreName")]
+            pub object_store_name: String,
+        }
+        impl GetMetadataParams {
+            pub fn new(
+                database_name: impl Into<String>,
+                object_store_name: impl Into<String>,
+            ) -> Self {
+                Self {
+                    database_name: database_name.into(),
+                    object_store_name: object_store_name.into(),
+                    security_origin: None,
+                    storage_key: None,
+                    storage_bucket: None,
+                }
+            }
+        }
+        impl GetMetadataParams {
+            pub fn builder() -> GetMetadataParamsBuilder {
+                GetMetadataParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetMetadataParamsBuilder {
+            security_origin: Option<String>,
+            storage_key: Option<String>,
+            storage_bucket: Option<super::storage::StorageBucket>,
+            database_name: Option<String>,
+            object_store_name: Option<String>,
+        }
+        impl GetMetadataParamsBuilder {
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn storage_bucket(
+                mut self,
+                storage_bucket: impl Into<super::storage::StorageBucket>,
+            ) -> Self {
+                self.storage_bucket = Some(storage_bucket.into());
+                self
+            }
+            pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
+                self.database_name = Some(database_name.into());
+                self
+            }
+            pub fn object_store_name(mut self, object_store_name: impl Into<String>) -> Self {
+                self.object_store_name = Some(object_store_name.into());
+                self
+            }
+            pub fn build(self) -> Result<GetMetadataParams, String> {
+                Ok(GetMetadataParams {
+                    security_origin: self.security_origin,
+                    storage_key: self.storage_key,
+                    storage_bucket: self.storage_bucket,
+                    database_name: self.database_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(database_name))
+                    })?,
+                    object_store_name: self.object_store_name.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(object_store_name)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl GetMetadataParams {
+            pub const IDENTIFIER: &'static str = "IndexedDB.getMetadata";
+        }
+        impl chromiumoxide_types::Method for GetMetadataParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetMetadataParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets metadata of an object store.\n[getMetadata](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-getMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetMetadataReturns {
+            #[doc = "the entries count"]
+            #[serde(rename = "entriesCount")]
+            pub entries_count: f64,
+            #[doc = "the current value of key generator, to become the next inserted\nkey into the object store. Valid if objectStore.autoIncrement\nis true."]
+            #[serde(rename = "keyGeneratorValue")]
+            pub key_generator_value: f64,
+        }
+        impl GetMetadataReturns {
+            pub fn new(entries_count: impl Into<f64>, key_generator_value: impl Into<f64>) -> Self {
+                Self {
+                    entries_count: entries_count.into(),
+                    key_generator_value: key_generator_value.into(),
+                }
+            }
+        }
+        impl GetMetadataReturns {
+            pub fn builder() -> GetMetadataReturnsBuilder {
+                GetMetadataReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetMetadataReturnsBuilder {
+            entries_count: Option<f64>,
+            key_generator_value: Option<f64>,
+        }
+        impl GetMetadataReturnsBuilder {
+            pub fn entries_count(mut self, entries_count: impl Into<f64>) -> Self {
+                self.entries_count = Some(entries_count.into());
+                self
+            }
+            pub fn key_generator_value(mut self, key_generator_value: impl Into<f64>) -> Self {
+                self.key_generator_value = Some(key_generator_value.into());
+                self
+            }
+            pub fn build(self) -> Result<GetMetadataReturns, String> {
+                Ok(GetMetadataReturns {
+                    entries_count: self.entries_count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(entries_count))
+                    })?,
+                    key_generator_value: self.key_generator_value.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(key_generator_value)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetMetadataParams {
+            type Response = GetMetadataReturns;
+        }
+        #[doc = "Requests database with given name in given frame.\n[requestDatabase](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-requestDatabase)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestDatabaseParams {
+            #[doc = "At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.\nSecurity origin."]
+            #[serde(rename = "securityOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_origin: Option<String>,
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_key: Option<String>,
+            #[doc = "Storage bucket. If not specified, it uses the default bucket."]
+            #[serde(rename = "storageBucket")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_bucket: Option<super::storage::StorageBucket>,
+            #[doc = "Database name."]
+            #[serde(rename = "databaseName")]
+            pub database_name: String,
+        }
+        impl RequestDatabaseParams {
+            pub fn new(database_name: impl Into<String>) -> Self {
+                Self {
+                    database_name: database_name.into(),
+                    security_origin: None,
+                    storage_key: None,
+                    storage_bucket: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for RequestDatabaseParams {
+            fn from(url: T) -> Self {
+                RequestDatabaseParams::new(url)
+            }
+        }
+        impl RequestDatabaseParams {
+            pub fn builder() -> RequestDatabaseParamsBuilder {
+                RequestDatabaseParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestDatabaseParamsBuilder {
+            security_origin: Option<String>,
+            storage_key: Option<String>,
+            storage_bucket: Option<super::storage::StorageBucket>,
+            database_name: Option<String>,
+        }
+        impl RequestDatabaseParamsBuilder {
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn storage_bucket(
+                mut self,
+                storage_bucket: impl Into<super::storage::StorageBucket>,
+            ) -> Self {
+                self.storage_bucket = Some(storage_bucket.into());
+                self
+            }
+            pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
+                self.database_name = Some(database_name.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestDatabaseParams, String> {
+                Ok(RequestDatabaseParams {
+                    security_origin: self.security_origin,
+                    storage_key: self.storage_key,
+                    storage_bucket: self.storage_bucket,
+                    database_name: self.database_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(database_name))
+                    })?,
+                })
+            }
+        }
+        impl RequestDatabaseParams {
+            pub const IDENTIFIER: &'static str = "IndexedDB.requestDatabase";
+        }
+        impl chromiumoxide_types::Method for RequestDatabaseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RequestDatabaseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests database with given name in given frame.\n[requestDatabase](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-requestDatabase)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestDatabaseReturns {
+            #[doc = "Database with an array of object stores."]
+            #[serde(rename = "databaseWithObjectStores")]
+            pub database_with_object_stores: DatabaseWithObjectStores,
+        }
+        impl RequestDatabaseReturns {
+            pub fn new(database_with_object_stores: impl Into<DatabaseWithObjectStores>) -> Self {
+                Self {
+                    database_with_object_stores: database_with_object_stores.into(),
+                }
+            }
+        }
+        impl RequestDatabaseReturns {
+            pub fn builder() -> RequestDatabaseReturnsBuilder {
+                RequestDatabaseReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestDatabaseReturnsBuilder {
+            database_with_object_stores: Option<DatabaseWithObjectStores>,
+        }
+        impl RequestDatabaseReturnsBuilder {
+            pub fn database_with_object_stores(
+                mut self,
+                database_with_object_stores: impl Into<DatabaseWithObjectStores>,
+            ) -> Self {
+                self.database_with_object_stores = Some(database_with_object_stores.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestDatabaseReturns, String> {
+                Ok(RequestDatabaseReturns {
+                    database_with_object_stores: self.database_with_object_stores.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(database_with_object_stores)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for RequestDatabaseParams {
+            type Response = RequestDatabaseReturns;
+        }
+        #[doc = "Requests database names for given security origin.\n[requestDatabaseNames](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-requestDatabaseNames)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RequestDatabaseNamesParams {
+            #[doc = "At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.\nSecurity origin."]
+            #[serde(rename = "securityOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_origin: Option<String>,
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_key: Option<String>,
+            #[doc = "Storage bucket. If not specified, it uses the default bucket."]
+            #[serde(rename = "storageBucket")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub storage_bucket: Option<super::storage::StorageBucket>,
+        }
+        impl RequestDatabaseNamesParams {
+            pub fn builder() -> RequestDatabaseNamesParamsBuilder {
+                RequestDatabaseNamesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestDatabaseNamesParamsBuilder {
+            security_origin: Option<String>,
+            storage_key: Option<String>,
+            storage_bucket: Option<super::storage::StorageBucket>,
+        }
+        impl RequestDatabaseNamesParamsBuilder {
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn storage_bucket(
+                mut self,
+                storage_bucket: impl Into<super::storage::StorageBucket>,
+            ) -> Self {
+                self.storage_bucket = Some(storage_bucket.into());
+                self
+            }
+            pub fn build(self) -> RequestDatabaseNamesParams {
+                RequestDatabaseNamesParams {
+                    security_origin: self.security_origin,
+                    storage_key: self.storage_key,
+                    storage_bucket: self.storage_bucket,
+                }
+            }
+        }
+        impl RequestDatabaseNamesParams {
+            pub const IDENTIFIER: &'static str = "IndexedDB.requestDatabaseNames";
+        }
+        impl chromiumoxide_types::Method for RequestDatabaseNamesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RequestDatabaseNamesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests database names for given security origin.\n[requestDatabaseNames](https://chromedevtools.github.io/devtools-protocol/tot/IndexedDB/#method-requestDatabaseNames)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestDatabaseNamesReturns {
+            #[doc = "Database names for origin."]
+            #[serde(rename = "databaseNames")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub database_names: Vec<String>,
+        }
+        impl RequestDatabaseNamesReturns {
+            pub fn new(database_names: Vec<String>) -> Self {
+                Self { database_names }
+            }
+        }
+        impl RequestDatabaseNamesReturns {
+            pub fn builder() -> RequestDatabaseNamesReturnsBuilder {
+                RequestDatabaseNamesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestDatabaseNamesReturnsBuilder {
+            database_names: Option<Vec<String>>,
+        }
+        impl RequestDatabaseNamesReturnsBuilder {
+            pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
+                let v = self.database_names.get_or_insert(Vec::new());
+                v.push(database_name.into());
+                self
+            }
+            pub fn database_names<I, S>(mut self, database_names: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.database_names.get_or_insert(Vec::new());
+                for val in database_names {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<RequestDatabaseNamesReturns, String> {
+                Ok(RequestDatabaseNamesReturns {
+                    database_names: self.database_names.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(database_names))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for RequestDatabaseNamesParams {
+            type Response = RequestDatabaseNamesReturns;
+        }
+    }
+    pub mod input {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TouchPoint {
+            #[doc = "X coordinate of the event relative to the main frame's viewport in CSS pixels."]
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[doc = "Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to\nthe top of the viewport and Y increases as it proceeds towards the bottom of the viewport."]
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[doc = "X radius of the touch area (default: 1.0)."]
+            #[serde(rename = "radiusX")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub radius_x: Option<f64>,
+            #[doc = "Y radius of the touch area (default: 1.0)."]
+            #[serde(rename = "radiusY")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub radius_y: Option<f64>,
+            #[doc = "Rotation angle (default: 0.0)."]
+            #[serde(rename = "rotationAngle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub rotation_angle: Option<f64>,
+            #[doc = "Force (default: 1.0)."]
+            #[serde(rename = "force")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub force: Option<f64>,
+            #[doc = "The normalized tangential pressure, which has a range of [-1,1] (default: 0)."]
+            #[serde(rename = "tangentialPressure")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub tangential_pressure: Option<f64>,
+            #[doc = "The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0)"]
+            #[serde(rename = "tiltX")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub tilt_x: Option<f64>,
+            #[doc = "The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0)."]
+            #[serde(rename = "tiltY")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub tilt_y: Option<f64>,
+            #[doc = "The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0)."]
+            #[serde(rename = "twist")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub twist: Option<i64>,
+            #[doc = "Identifier used to track touch sources between events, must be unique within an event."]
+            #[serde(rename = "id")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub id: Option<f64>,
+        }
+        impl TouchPoint {
+            pub fn new(x: impl Into<f64>, y: impl Into<f64>) -> Self {
+                Self {
+                    x: x.into(),
+                    y: y.into(),
+                    radius_x: None,
+                    radius_y: None,
+                    rotation_angle: None,
+                    force: None,
+                    tangential_pressure: None,
+                    tilt_x: None,
+                    tilt_y: None,
+                    twist: None,
+                    id: None,
+                }
+            }
+        }
+        impl TouchPoint {
+            pub fn builder() -> TouchPointBuilder {
+                TouchPointBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TouchPointBuilder {
+            x: Option<f64>,
+            y: Option<f64>,
+            radius_x: Option<f64>,
+            radius_y: Option<f64>,
+            rotation_angle: Option<f64>,
+            force: Option<f64>,
+            tangential_pressure: Option<f64>,
+            tilt_x: Option<f64>,
+            tilt_y: Option<f64>,
+            twist: Option<i64>,
+            id: Option<f64>,
+        }
+        impl TouchPointBuilder {
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn radius_x(mut self, radius_x: impl Into<f64>) -> Self {
+                self.radius_x = Some(radius_x.into());
+                self
+            }
+            pub fn radius_y(mut self, radius_y: impl Into<f64>) -> Self {
+                self.radius_y = Some(radius_y.into());
+                self
+            }
+            pub fn rotation_angle(mut self, rotation_angle: impl Into<f64>) -> Self {
+                self.rotation_angle = Some(rotation_angle.into());
+                self
+            }
+            pub fn force(mut self, force: impl Into<f64>) -> Self {
+                self.force = Some(force.into());
+                self
+            }
+            pub fn tangential_pressure(mut self, tangential_pressure: impl Into<f64>) -> Self {
+                self.tangential_pressure = Some(tangential_pressure.into());
+                self
+            }
+            pub fn tilt_x(mut self, tilt_x: impl Into<f64>) -> Self {
+                self.tilt_x = Some(tilt_x.into());
+                self
+            }
+            pub fn tilt_y(mut self, tilt_y: impl Into<f64>) -> Self {
+                self.tilt_y = Some(tilt_y.into());
+                self
+            }
+            pub fn twist(mut self, twist: impl Into<i64>) -> Self {
+                self.twist = Some(twist.into());
+                self
+            }
+            pub fn id(mut self, id: impl Into<f64>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn build(self) -> Result<TouchPoint, String> {
+                Ok(TouchPoint {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    radius_x: self.radius_x,
+                    radius_y: self.radius_y,
+                    rotation_angle: self.rotation_angle,
+                    force: self.force,
+                    tangential_pressure: self.tangential_pressure,
+                    tilt_x: self.tilt_x,
+                    tilt_y: self.tilt_y,
+                    twist: self.twist,
+                    id: self.id,
+                })
+            }
+        }
+        impl TouchPoint {
+            pub const IDENTIFIER: &'static str = "Input.TouchPoint";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum GestureSourceType {
+            #[serde(rename = "default")]
+            Default,
+            #[serde(rename = "touch")]
+            Touch,
+            #[serde(rename = "mouse")]
+            Mouse,
+        }
+        impl AsRef<str> for GestureSourceType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    GestureSourceType::Default => "default",
+                    GestureSourceType::Touch => "touch",
+                    GestureSourceType::Mouse => "mouse",
+                }
+            }
+        }
+        impl ::std::str::FromStr for GestureSourceType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "default" | "Default" => Ok(GestureSourceType::Default),
+                    "touch" | "Touch" => Ok(GestureSourceType::Touch),
+                    "mouse" | "Mouse" => Ok(GestureSourceType::Mouse),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum MouseButton {
+            #[serde(rename = "none")]
+            None,
+            #[serde(rename = "left")]
+            Left,
+            #[serde(rename = "middle")]
+            Middle,
+            #[serde(rename = "right")]
+            Right,
+            #[serde(rename = "back")]
+            Back,
+            #[serde(rename = "forward")]
+            Forward,
+        }
+        impl AsRef<str> for MouseButton {
+            fn as_ref(&self) -> &str {
+                match self {
+                    MouseButton::None => "none",
+                    MouseButton::Left => "left",
+                    MouseButton::Middle => "middle",
+                    MouseButton::Right => "right",
+                    MouseButton::Back => "back",
+                    MouseButton::Forward => "forward",
+                }
+            }
+        }
+        impl ::std::str::FromStr for MouseButton {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "none" | "None" => Ok(MouseButton::None),
+                    "left" | "Left" => Ok(MouseButton::Left),
+                    "middle" | "Middle" => Ok(MouseButton::Middle),
+                    "right" | "Right" => Ok(MouseButton::Right),
+                    "back" | "Back" => Ok(MouseButton::Back),
+                    "forward" | "Forward" => Ok(MouseButton::Forward),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "UTC time in seconds, counted from January 1, 1970.\n[TimeSinceEpoch](https://chromedevtools.github.io/devtools-protocol/tot/Input/#type-TimeSinceEpoch)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TimeSinceEpoch(f64);
+        impl TimeSinceEpoch {
+            pub fn new(val: impl Into<f64>) -> Self {
+                TimeSinceEpoch(val.into())
+            }
+            pub fn inner(&self) -> &f64 {
+                &self.0
+            }
+        }
+        impl TimeSinceEpoch {
+            pub const IDENTIFIER: &'static str = "Input.TimeSinceEpoch";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DragDataItem {
+            #[doc = "Mime type of the dragged data."]
+            #[serde(rename = "mimeType")]
+            pub mime_type: String,
+            #[doc = "Depending of the value of `mimeType`, it contains the dragged link,\ntext, HTML markup or any other data."]
+            #[serde(rename = "data")]
+            pub data: String,
+            #[doc = "Title associated with a link. Only valid when `mimeType` == \"text/uri-list\"."]
+            #[serde(rename = "title")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub title: Option<String>,
+            #[doc = "Stores the base URL for the contained markup. Only valid when `mimeType`\n== \"text/html\"."]
+            #[serde(rename = "baseURL")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub base_url: Option<String>,
+        }
+        impl DragDataItem {
+            pub fn new(mime_type: impl Into<String>, data: impl Into<String>) -> Self {
+                Self {
+                    mime_type: mime_type.into(),
+                    data: data.into(),
+                    title: None,
+                    base_url: None,
+                }
+            }
+        }
+        impl DragDataItem {
+            pub fn builder() -> DragDataItemBuilder {
+                DragDataItemBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DragDataItemBuilder {
+            mime_type: Option<String>,
+            data: Option<String>,
+            title: Option<String>,
+            base_url: Option<String>,
+        }
+        impl DragDataItemBuilder {
+            pub fn mime_type(mut self, mime_type: impl Into<String>) -> Self {
+                self.mime_type = Some(mime_type.into());
+                self
+            }
+            pub fn data(mut self, data: impl Into<String>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn title(mut self, title: impl Into<String>) -> Self {
+                self.title = Some(title.into());
+                self
+            }
+            pub fn base_url(mut self, base_url: impl Into<String>) -> Self {
+                self.base_url = Some(base_url.into());
+                self
+            }
+            pub fn build(self) -> Result<DragDataItem, String> {
+                Ok(DragDataItem {
+                    mime_type: self.mime_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mime_type))
+                    })?,
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                    title: self.title,
+                    base_url: self.base_url,
+                })
+            }
+        }
+        impl DragDataItem {
+            pub const IDENTIFIER: &'static str = "Input.DragDataItem";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DragData {
+            #[serde(rename = "items")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub items: Vec<DragDataItem>,
+            #[doc = "List of filenames that should be included when dropping"]
+            #[serde(rename = "files")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub files: Option<Vec<String>>,
+            #[doc = "Bit field representing allowed drag operations. Copy = 1, Link = 2, Move = 16"]
+            #[serde(rename = "dragOperationsMask")]
+            pub drag_operations_mask: i64,
+        }
+        impl DragData {
+            pub fn new(items: Vec<DragDataItem>, drag_operations_mask: impl Into<i64>) -> Self {
+                Self {
+                    items,
+                    drag_operations_mask: drag_operations_mask.into(),
+                    files: None,
+                }
+            }
+        }
+        impl DragData {
+            pub fn builder() -> DragDataBuilder {
+                DragDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DragDataBuilder {
+            items: Option<Vec<DragDataItem>>,
+            files: Option<Vec<String>>,
+            drag_operations_mask: Option<i64>,
+        }
+        impl DragDataBuilder {
+            pub fn item(mut self, item: impl Into<DragDataItem>) -> Self {
+                let v = self.items.get_or_insert(Vec::new());
+                v.push(item.into());
+                self
+            }
+            pub fn items<I, S>(mut self, items: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<DragDataItem>,
+            {
+                let v = self.items.get_or_insert(Vec::new());
+                for val in items {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn file(mut self, file: impl Into<String>) -> Self {
+                let v = self.files.get_or_insert(Vec::new());
+                v.push(file.into());
+                self
+            }
+            pub fn files<I, S>(mut self, files: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.files.get_or_insert(Vec::new());
+                for val in files {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn drag_operations_mask(mut self, drag_operations_mask: impl Into<i64>) -> Self {
+                self.drag_operations_mask = Some(drag_operations_mask.into());
+                self
+            }
+            pub fn build(self) -> Result<DragData, String> {
+                Ok(DragData {
+                    items: self.items.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(items))
+                    })?,
+                    files: self.files,
+                    drag_operations_mask: self.drag_operations_mask.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(drag_operations_mask)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl DragData {
+            pub const IDENTIFIER: &'static str = "Input.DragData";
+        }
+        #[doc = "Dispatches a drag event into the page.\n[dispatchDragEvent](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchDragEvent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DispatchDragEventParams {
+            #[doc = "Type of the drag event."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DispatchDragEventType,
+            #[doc = "X coordinate of the event relative to the main frame's viewport in CSS pixels."]
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[doc = "Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to\nthe top of the viewport and Y increases as it proceeds towards the bottom of the viewport."]
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[serde(rename = "data")]
+            pub data: DragData,
+            #[doc = "Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8\n(default: 0)."]
+            #[serde(rename = "modifiers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub modifiers: Option<i64>,
+        }
+        #[doc = "Type of the drag event."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DispatchDragEventType {
+            #[serde(rename = "dragEnter")]
+            DragEnter,
+            #[serde(rename = "dragOver")]
+            DragOver,
+            #[serde(rename = "drop")]
+            Drop,
+            #[serde(rename = "dragCancel")]
+            DragCancel,
+        }
+        impl AsRef<str> for DispatchDragEventType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DispatchDragEventType::DragEnter => "dragEnter",
+                    DispatchDragEventType::DragOver => "dragOver",
+                    DispatchDragEventType::Drop => "drop",
+                    DispatchDragEventType::DragCancel => "dragCancel",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DispatchDragEventType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "dragEnter" | "DragEnter" | "dragenter" => Ok(DispatchDragEventType::DragEnter),
+                    "dragOver" | "DragOver" | "dragover" => Ok(DispatchDragEventType::DragOver),
+                    "drop" | "Drop" => Ok(DispatchDragEventType::Drop),
+                    "dragCancel" | "DragCancel" | "dragcancel" => {
+                        Ok(DispatchDragEventType::DragCancel)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl DispatchDragEventParams {
+            pub fn new(
+                r#type: impl Into<DispatchDragEventType>,
+                x: impl Into<f64>,
+                y: impl Into<f64>,
+                data: impl Into<DragData>,
+            ) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    x: x.into(),
+                    y: y.into(),
+                    data: data.into(),
+                    modifiers: None,
+                }
+            }
+        }
+        impl DispatchDragEventParams {
+            pub fn builder() -> DispatchDragEventParamsBuilder {
+                DispatchDragEventParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DispatchDragEventParamsBuilder {
+            r#type: Option<DispatchDragEventType>,
+            x: Option<f64>,
+            y: Option<f64>,
+            data: Option<DragData>,
+            modifiers: Option<i64>,
+        }
+        impl DispatchDragEventParamsBuilder {
+            pub fn r#type(mut self, r#type: impl Into<DispatchDragEventType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn data(mut self, data: impl Into<DragData>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn modifiers(mut self, modifiers: impl Into<i64>) -> Self {
+                self.modifiers = Some(modifiers.into());
+                self
+            }
+            pub fn build(self) -> Result<DispatchDragEventParams, String> {
+                Ok(DispatchDragEventParams {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                    modifiers: self.modifiers,
+                })
+            }
+        }
+        impl DispatchDragEventParams {
+            pub const IDENTIFIER: &'static str = "Input.dispatchDragEvent";
+        }
+        impl chromiumoxide_types::Method for DispatchDragEventParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DispatchDragEventParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Dispatches a drag event into the page.\n[dispatchDragEvent](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchDragEvent)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DispatchDragEventReturns {}
+        impl chromiumoxide_types::Command for DispatchDragEventParams {
+            type Response = DispatchDragEventReturns;
+        }
+        #[doc = "Dispatches a key event to the page.\n[dispatchKeyEvent](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchKeyEvent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DispatchKeyEventParams {
+            #[doc = "Type of the key event."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DispatchKeyEventType,
+            #[doc = "Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8\n(default: 0)."]
+            #[serde(rename = "modifiers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub modifiers: Option<i64>,
+            #[doc = "Time at which the event occurred."]
+            #[serde(rename = "timestamp")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub timestamp: Option<TimeSinceEpoch>,
+            #[doc = "Text as generated by processing a virtual key code with a keyboard layout. Not needed for\nfor `keyUp` and `rawKeyDown` events (default: \"\")"]
+            #[serde(rename = "text")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub text: Option<String>,
+            #[doc = "Text that would have been generated by the keyboard if no modifiers were pressed (except for\nshift). Useful for shortcut (accelerator) key handling (default: \"\")."]
+            #[serde(rename = "unmodifiedText")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub unmodified_text: Option<String>,
+            #[doc = "Unique key identifier (e.g., 'U+0041') (default: \"\")."]
+            #[serde(rename = "keyIdentifier")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub key_identifier: Option<String>,
+            #[doc = "Unique DOM defined string value for each physical key (e.g., 'KeyA') (default: \"\")."]
+            #[serde(rename = "code")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub code: Option<String>,
+            #[doc = "Unique DOM defined string value describing the meaning of the key in the context of active\nmodifiers, keyboard layout, etc (e.g., 'AltGr') (default: \"\")."]
+            #[serde(rename = "key")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub key: Option<String>,
+            #[doc = "Windows virtual key code (default: 0)."]
+            #[serde(rename = "windowsVirtualKeyCode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub windows_virtual_key_code: Option<i64>,
+            #[doc = "Native virtual key code (default: 0)."]
+            #[serde(rename = "nativeVirtualKeyCode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub native_virtual_key_code: Option<i64>,
+            #[doc = "Whether the event was generated from auto repeat (default: false)."]
+            #[serde(rename = "autoRepeat")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub auto_repeat: Option<bool>,
+            #[doc = "Whether the event was generated from the keypad (default: false)."]
+            #[serde(rename = "isKeypad")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_keypad: Option<bool>,
+            #[doc = "Whether the event was a system key event (default: false)."]
+            #[serde(rename = "isSystemKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_system_key: Option<bool>,
+            #[doc = "Whether the event was from the left or right side of the keyboard. 1=Left, 2=Right (default:\n0)."]
+            #[serde(rename = "location")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub location: Option<i64>,
+            #[doc = "Editing commands to send with the key event (e.g., 'selectAll') (default: []).\nThese are related to but not equal the command names used in `document.execCommand` and NSStandardKeyBindingResponding.\nSee https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/editing/commands/editor_command_names.h for valid command names."]
+            #[serde(rename = "commands")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub commands: Option<Vec<String>>,
+        }
+        #[doc = "Type of the key event."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DispatchKeyEventType {
+            #[serde(rename = "keyDown")]
+            KeyDown,
+            #[serde(rename = "keyUp")]
+            KeyUp,
+            #[serde(rename = "rawKeyDown")]
+            RawKeyDown,
+            #[serde(rename = "char")]
+            Char,
+        }
+        impl AsRef<str> for DispatchKeyEventType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DispatchKeyEventType::KeyDown => "keyDown",
+                    DispatchKeyEventType::KeyUp => "keyUp",
+                    DispatchKeyEventType::RawKeyDown => "rawKeyDown",
+                    DispatchKeyEventType::Char => "char",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DispatchKeyEventType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "keyDown" | "KeyDown" | "keydown" => Ok(DispatchKeyEventType::KeyDown),
+                    "keyUp" | "KeyUp" | "keyup" => Ok(DispatchKeyEventType::KeyUp),
+                    "rawKeyDown" | "RawKeyDown" | "rawkeydown" => {
+                        Ok(DispatchKeyEventType::RawKeyDown)
+                    }
+                    "char" | "Char" => Ok(DispatchKeyEventType::Char),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl DispatchKeyEventParams {
+            pub fn new(r#type: impl Into<DispatchKeyEventType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    modifiers: None,
+                    timestamp: None,
+                    text: None,
+                    unmodified_text: None,
+                    key_identifier: None,
+                    code: None,
+                    key: None,
+                    windows_virtual_key_code: None,
+                    native_virtual_key_code: None,
+                    auto_repeat: None,
+                    is_keypad: None,
+                    is_system_key: None,
+                    location: None,
+                    commands: None,
+                }
+            }
+        }
+        impl DispatchKeyEventParams {
+            pub fn builder() -> DispatchKeyEventParamsBuilder {
+                DispatchKeyEventParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DispatchKeyEventParamsBuilder {
+            r#type: Option<DispatchKeyEventType>,
+            modifiers: Option<i64>,
+            timestamp: Option<TimeSinceEpoch>,
+            text: Option<String>,
+            unmodified_text: Option<String>,
+            key_identifier: Option<String>,
+            code: Option<String>,
+            key: Option<String>,
+            windows_virtual_key_code: Option<i64>,
+            native_virtual_key_code: Option<i64>,
+            auto_repeat: Option<bool>,
+            is_keypad: Option<bool>,
+            is_system_key: Option<bool>,
+            location: Option<i64>,
+            commands: Option<Vec<String>>,
+        }
+        impl DispatchKeyEventParamsBuilder {
+            pub fn r#type(mut self, r#type: impl Into<DispatchKeyEventType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn modifiers(mut self, modifiers: impl Into<i64>) -> Self {
+                self.modifiers = Some(modifiers.into());
+                self
+            }
+            pub fn timestamp(mut self, timestamp: impl Into<TimeSinceEpoch>) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn unmodified_text(mut self, unmodified_text: impl Into<String>) -> Self {
+                self.unmodified_text = Some(unmodified_text.into());
+                self
+            }
+            pub fn key_identifier(mut self, key_identifier: impl Into<String>) -> Self {
+                self.key_identifier = Some(key_identifier.into());
+                self
+            }
+            pub fn code(mut self, code: impl Into<String>) -> Self {
+                self.code = Some(code.into());
+                self
+            }
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn windows_virtual_key_code(
+                mut self,
+                windows_virtual_key_code: impl Into<i64>,
+            ) -> Self {
+                self.windows_virtual_key_code = Some(windows_virtual_key_code.into());
+                self
+            }
+            pub fn native_virtual_key_code(
+                mut self,
+                native_virtual_key_code: impl Into<i64>,
+            ) -> Self {
+                self.native_virtual_key_code = Some(native_virtual_key_code.into());
+                self
+            }
+            pub fn auto_repeat(mut self, auto_repeat: impl Into<bool>) -> Self {
+                self.auto_repeat = Some(auto_repeat.into());
+                self
+            }
+            pub fn is_keypad(mut self, is_keypad: impl Into<bool>) -> Self {
+                self.is_keypad = Some(is_keypad.into());
+                self
+            }
+            pub fn is_system_key(mut self, is_system_key: impl Into<bool>) -> Self {
+                self.is_system_key = Some(is_system_key.into());
+                self
+            }
+            pub fn location(mut self, location: impl Into<i64>) -> Self {
+                self.location = Some(location.into());
+                self
+            }
+            pub fn command(mut self, command: impl Into<String>) -> Self {
+                let v = self.commands.get_or_insert(Vec::new());
+                v.push(command.into());
+                self
+            }
+            pub fn commands<I, S>(mut self, commands: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.commands.get_or_insert(Vec::new());
+                for val in commands {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<DispatchKeyEventParams, String> {
+                Ok(DispatchKeyEventParams {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    modifiers: self.modifiers,
+                    timestamp: self.timestamp,
+                    text: self.text,
+                    unmodified_text: self.unmodified_text,
+                    key_identifier: self.key_identifier,
+                    code: self.code,
+                    key: self.key,
+                    windows_virtual_key_code: self.windows_virtual_key_code,
+                    native_virtual_key_code: self.native_virtual_key_code,
+                    auto_repeat: self.auto_repeat,
+                    is_keypad: self.is_keypad,
+                    is_system_key: self.is_system_key,
+                    location: self.location,
+                    commands: self.commands,
+                })
+            }
+        }
+        impl DispatchKeyEventParams {
+            pub const IDENTIFIER: &'static str = "Input.dispatchKeyEvent";
+        }
+        impl chromiumoxide_types::Method for DispatchKeyEventParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DispatchKeyEventParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Dispatches a key event to the page.\n[dispatchKeyEvent](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchKeyEvent)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DispatchKeyEventReturns {}
+        impl chromiumoxide_types::Command for DispatchKeyEventParams {
+            type Response = DispatchKeyEventReturns;
+        }
+        #[doc = "This method emulates inserting text that doesn't come from a key press,\nfor example an emoji keyboard or an IME.\n[insertText](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-insertText)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct InsertTextParams {
+            #[doc = "The text to insert."]
+            #[serde(rename = "text")]
+            pub text: String,
+        }
+        impl InsertTextParams {
+            pub fn new(text: impl Into<String>) -> Self {
+                Self { text: text.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for InsertTextParams {
+            fn from(url: T) -> Self {
+                InsertTextParams::new(url)
+            }
+        }
+        impl InsertTextParams {
+            pub fn builder() -> InsertTextParamsBuilder {
+                InsertTextParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InsertTextParamsBuilder {
+            text: Option<String>,
+        }
+        impl InsertTextParamsBuilder {
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn build(self) -> Result<InsertTextParams, String> {
+                Ok(InsertTextParams {
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                })
+            }
+        }
+        impl InsertTextParams {
+            pub const IDENTIFIER: &'static str = "Input.insertText";
+        }
+        impl chromiumoxide_types::Method for InsertTextParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for InsertTextParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "This method emulates inserting text that doesn't come from a key press,\nfor example an emoji keyboard or an IME.\n[insertText](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-insertText)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct InsertTextReturns {}
+        impl chromiumoxide_types::Command for InsertTextParams {
+            type Response = InsertTextReturns;
+        }
+        #[doc = "This method sets the current candidate text for IME.\nUse imeCommitComposition to commit the final text.\nUse imeSetComposition with empty string as text to cancel composition.\n[imeSetComposition](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-imeSetComposition)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ImeSetCompositionParams {
+            #[doc = "The text to insert"]
+            #[serde(rename = "text")]
+            pub text: String,
+            #[doc = "selection start"]
+            #[serde(rename = "selectionStart")]
+            pub selection_start: i64,
+            #[doc = "selection end"]
+            #[serde(rename = "selectionEnd")]
+            pub selection_end: i64,
+            #[doc = "replacement start"]
+            #[serde(rename = "replacementStart")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub replacement_start: Option<i64>,
+            #[doc = "replacement end"]
+            #[serde(rename = "replacementEnd")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub replacement_end: Option<i64>,
+        }
+        impl ImeSetCompositionParams {
+            pub fn new(
+                text: impl Into<String>,
+                selection_start: impl Into<i64>,
+                selection_end: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    text: text.into(),
+                    selection_start: selection_start.into(),
+                    selection_end: selection_end.into(),
+                    replacement_start: None,
+                    replacement_end: None,
+                }
+            }
+        }
+        impl ImeSetCompositionParams {
+            pub fn builder() -> ImeSetCompositionParamsBuilder {
+                ImeSetCompositionParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ImeSetCompositionParamsBuilder {
+            text: Option<String>,
+            selection_start: Option<i64>,
+            selection_end: Option<i64>,
+            replacement_start: Option<i64>,
+            replacement_end: Option<i64>,
+        }
+        impl ImeSetCompositionParamsBuilder {
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn selection_start(mut self, selection_start: impl Into<i64>) -> Self {
+                self.selection_start = Some(selection_start.into());
+                self
+            }
+            pub fn selection_end(mut self, selection_end: impl Into<i64>) -> Self {
+                self.selection_end = Some(selection_end.into());
+                self
+            }
+            pub fn replacement_start(mut self, replacement_start: impl Into<i64>) -> Self {
+                self.replacement_start = Some(replacement_start.into());
+                self
+            }
+            pub fn replacement_end(mut self, replacement_end: impl Into<i64>) -> Self {
+                self.replacement_end = Some(replacement_end.into());
+                self
+            }
+            pub fn build(self) -> Result<ImeSetCompositionParams, String> {
+                Ok(ImeSetCompositionParams {
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    selection_start: self.selection_start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(selection_start))
+                    })?,
+                    selection_end: self.selection_end.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(selection_end))
+                    })?,
+                    replacement_start: self.replacement_start,
+                    replacement_end: self.replacement_end,
+                })
+            }
+        }
+        impl ImeSetCompositionParams {
+            pub const IDENTIFIER: &'static str = "Input.imeSetComposition";
+        }
+        impl chromiumoxide_types::Method for ImeSetCompositionParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ImeSetCompositionParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "This method sets the current candidate text for IME.\nUse imeCommitComposition to commit the final text.\nUse imeSetComposition with empty string as text to cancel composition.\n[imeSetComposition](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-imeSetComposition)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ImeSetCompositionReturns {}
+        impl chromiumoxide_types::Command for ImeSetCompositionParams {
+            type Response = ImeSetCompositionReturns;
+        }
+        #[doc = "Dispatches a mouse event to the page.\n[dispatchMouseEvent](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchMouseEvent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DispatchMouseEventParams {
+            #[doc = "Type of the mouse event."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DispatchMouseEventType,
+            #[doc = "X coordinate of the event relative to the main frame's viewport in CSS pixels."]
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[doc = "Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to\nthe top of the viewport and Y increases as it proceeds towards the bottom of the viewport."]
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[doc = "Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8\n(default: 0)."]
+            #[serde(rename = "modifiers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub modifiers: Option<i64>,
+            #[doc = "Time at which the event occurred."]
+            #[serde(rename = "timestamp")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub timestamp: Option<TimeSinceEpoch>,
+            #[doc = "Mouse button (default: \"none\")."]
+            #[serde(rename = "button")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub button: Option<MouseButton>,
+            #[doc = "A number indicating which buttons are pressed on the mouse when a mouse event is triggered.\nLeft=1, Right=2, Middle=4, Back=8, Forward=16, None=0."]
+            #[serde(rename = "buttons")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub buttons: Option<i64>,
+            #[doc = "Number of times the mouse button was clicked (default: 0)."]
+            #[serde(rename = "clickCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub click_count: Option<i64>,
+            #[doc = "The normalized pressure, which has a range of [0,1] (default: 0)."]
+            #[serde(rename = "force")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub force: Option<f64>,
+            #[doc = "The normalized tangential pressure, which has a range of [-1,1] (default: 0)."]
+            #[serde(rename = "tangentialPressure")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub tangential_pressure: Option<f64>,
+            #[doc = "The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0)."]
+            #[serde(rename = "tiltX")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub tilt_x: Option<f64>,
+            #[doc = "The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0)."]
+            #[serde(rename = "tiltY")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub tilt_y: Option<f64>,
+            #[doc = "The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0)."]
+            #[serde(rename = "twist")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub twist: Option<i64>,
+            #[doc = "X delta in CSS pixels for mouse wheel event (default: 0)."]
+            #[serde(rename = "deltaX")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub delta_x: Option<f64>,
+            #[doc = "Y delta in CSS pixels for mouse wheel event (default: 0)."]
+            #[serde(rename = "deltaY")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub delta_y: Option<f64>,
+            #[doc = "Pointer type (default: \"mouse\")."]
+            #[serde(rename = "pointerType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub pointer_type: Option<DispatchMouseEventPointerType>,
+        }
+        #[doc = "Type of the mouse event."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DispatchMouseEventType {
+            #[serde(rename = "mousePressed")]
+            MousePressed,
+            #[serde(rename = "mouseReleased")]
+            MouseReleased,
+            #[serde(rename = "mouseMoved")]
+            MouseMoved,
+            #[serde(rename = "mouseWheel")]
+            MouseWheel,
+        }
+        impl AsRef<str> for DispatchMouseEventType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DispatchMouseEventType::MousePressed => "mousePressed",
+                    DispatchMouseEventType::MouseReleased => "mouseReleased",
+                    DispatchMouseEventType::MouseMoved => "mouseMoved",
+                    DispatchMouseEventType::MouseWheel => "mouseWheel",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DispatchMouseEventType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "mousePressed" | "MousePressed" | "mousepressed" => {
+                        Ok(DispatchMouseEventType::MousePressed)
+                    }
+                    "mouseReleased" | "MouseReleased" | "mousereleased" => {
+                        Ok(DispatchMouseEventType::MouseReleased)
+                    }
+                    "mouseMoved" | "MouseMoved" | "mousemoved" => {
+                        Ok(DispatchMouseEventType::MouseMoved)
+                    }
+                    "mouseWheel" | "MouseWheel" | "mousewheel" => {
+                        Ok(DispatchMouseEventType::MouseWheel)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Pointer type (default: \"mouse\")."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DispatchMouseEventPointerType {
+            #[serde(rename = "mouse")]
+            Mouse,
+            #[serde(rename = "pen")]
+            Pen,
+        }
+        impl AsRef<str> for DispatchMouseEventPointerType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DispatchMouseEventPointerType::Mouse => "mouse",
+                    DispatchMouseEventPointerType::Pen => "pen",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DispatchMouseEventPointerType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "mouse" | "Mouse" => Ok(DispatchMouseEventPointerType::Mouse),
+                    "pen" | "Pen" => Ok(DispatchMouseEventPointerType::Pen),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl DispatchMouseEventParams {
+            pub fn new(
+                r#type: impl Into<DispatchMouseEventType>,
+                x: impl Into<f64>,
+                y: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    x: x.into(),
+                    y: y.into(),
+                    modifiers: None,
+                    timestamp: None,
+                    button: None,
+                    buttons: None,
+                    click_count: None,
+                    force: None,
+                    tangential_pressure: None,
+                    tilt_x: None,
+                    tilt_y: None,
+                    twist: None,
+                    delta_x: None,
+                    delta_y: None,
+                    pointer_type: None,
+                }
+            }
+        }
+        impl DispatchMouseEventParams {
+            pub fn builder() -> DispatchMouseEventParamsBuilder {
+                DispatchMouseEventParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DispatchMouseEventParamsBuilder {
+            r#type: Option<DispatchMouseEventType>,
+            x: Option<f64>,
+            y: Option<f64>,
+            modifiers: Option<i64>,
+            timestamp: Option<TimeSinceEpoch>,
+            button: Option<MouseButton>,
+            buttons: Option<i64>,
+            click_count: Option<i64>,
+            force: Option<f64>,
+            tangential_pressure: Option<f64>,
+            tilt_x: Option<f64>,
+            tilt_y: Option<f64>,
+            twist: Option<i64>,
+            delta_x: Option<f64>,
+            delta_y: Option<f64>,
+            pointer_type: Option<DispatchMouseEventPointerType>,
+        }
+        impl DispatchMouseEventParamsBuilder {
+            pub fn r#type(mut self, r#type: impl Into<DispatchMouseEventType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn modifiers(mut self, modifiers: impl Into<i64>) -> Self {
+                self.modifiers = Some(modifiers.into());
+                self
+            }
+            pub fn timestamp(mut self, timestamp: impl Into<TimeSinceEpoch>) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn button(mut self, button: impl Into<MouseButton>) -> Self {
+                self.button = Some(button.into());
+                self
+            }
+            pub fn buttons(mut self, buttons: impl Into<i64>) -> Self {
+                self.buttons = Some(buttons.into());
+                self
+            }
+            pub fn click_count(mut self, click_count: impl Into<i64>) -> Self {
+                self.click_count = Some(click_count.into());
+                self
+            }
+            pub fn force(mut self, force: impl Into<f64>) -> Self {
+                self.force = Some(force.into());
+                self
+            }
+            pub fn tangential_pressure(mut self, tangential_pressure: impl Into<f64>) -> Self {
+                self.tangential_pressure = Some(tangential_pressure.into());
+                self
+            }
+            pub fn tilt_x(mut self, tilt_x: impl Into<f64>) -> Self {
+                self.tilt_x = Some(tilt_x.into());
+                self
+            }
+            pub fn tilt_y(mut self, tilt_y: impl Into<f64>) -> Self {
+                self.tilt_y = Some(tilt_y.into());
+                self
+            }
+            pub fn twist(mut self, twist: impl Into<i64>) -> Self {
+                self.twist = Some(twist.into());
+                self
+            }
+            pub fn delta_x(mut self, delta_x: impl Into<f64>) -> Self {
+                self.delta_x = Some(delta_x.into());
+                self
+            }
+            pub fn delta_y(mut self, delta_y: impl Into<f64>) -> Self {
+                self.delta_y = Some(delta_y.into());
+                self
+            }
+            pub fn pointer_type(
+                mut self,
+                pointer_type: impl Into<DispatchMouseEventPointerType>,
+            ) -> Self {
+                self.pointer_type = Some(pointer_type.into());
+                self
+            }
+            pub fn build(self) -> Result<DispatchMouseEventParams, String> {
+                Ok(DispatchMouseEventParams {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    modifiers: self.modifiers,
+                    timestamp: self.timestamp,
+                    button: self.button,
+                    buttons: self.buttons,
+                    click_count: self.click_count,
+                    force: self.force,
+                    tangential_pressure: self.tangential_pressure,
+                    tilt_x: self.tilt_x,
+                    tilt_y: self.tilt_y,
+                    twist: self.twist,
+                    delta_x: self.delta_x,
+                    delta_y: self.delta_y,
+                    pointer_type: self.pointer_type,
+                })
+            }
+        }
+        impl DispatchMouseEventParams {
+            pub const IDENTIFIER: &'static str = "Input.dispatchMouseEvent";
+        }
+        impl chromiumoxide_types::Method for DispatchMouseEventParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DispatchMouseEventParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Dispatches a mouse event to the page.\n[dispatchMouseEvent](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchMouseEvent)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DispatchMouseEventReturns {}
+        impl chromiumoxide_types::Command for DispatchMouseEventParams {
+            type Response = DispatchMouseEventReturns;
+        }
+        #[doc = "Dispatches a touch event to the page.\n[dispatchTouchEvent](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchTouchEvent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DispatchTouchEventParams {
+            #[doc = "Type of the touch event. TouchEnd and TouchCancel must not contain any touch points, while\nTouchStart and TouchMove must contains at least one."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DispatchTouchEventType,
+            #[doc = "Active touch points on the touch device. One event per any changed point (compared to\nprevious touch event in a sequence) is generated, emulating pressing/moving/releasing points\none by one."]
+            #[serde(rename = "touchPoints")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub touch_points: Vec<TouchPoint>,
+            #[doc = "Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8\n(default: 0)."]
+            #[serde(rename = "modifiers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub modifiers: Option<i64>,
+            #[doc = "Time at which the event occurred."]
+            #[serde(rename = "timestamp")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub timestamp: Option<TimeSinceEpoch>,
+        }
+        #[doc = "Type of the touch event. TouchEnd and TouchCancel must not contain any touch points, while\nTouchStart and TouchMove must contains at least one."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DispatchTouchEventType {
+            #[serde(rename = "touchStart")]
+            TouchStart,
+            #[serde(rename = "touchEnd")]
+            TouchEnd,
+            #[serde(rename = "touchMove")]
+            TouchMove,
+            #[serde(rename = "touchCancel")]
+            TouchCancel,
+        }
+        impl AsRef<str> for DispatchTouchEventType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DispatchTouchEventType::TouchStart => "touchStart",
+                    DispatchTouchEventType::TouchEnd => "touchEnd",
+                    DispatchTouchEventType::TouchMove => "touchMove",
+                    DispatchTouchEventType::TouchCancel => "touchCancel",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DispatchTouchEventType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "touchStart" | "TouchStart" | "touchstart" => {
+                        Ok(DispatchTouchEventType::TouchStart)
+                    }
+                    "touchEnd" | "TouchEnd" | "touchend" => Ok(DispatchTouchEventType::TouchEnd),
+                    "touchMove" | "TouchMove" | "touchmove" => {
+                        Ok(DispatchTouchEventType::TouchMove)
+                    }
+                    "touchCancel" | "TouchCancel" | "touchcancel" => {
+                        Ok(DispatchTouchEventType::TouchCancel)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl DispatchTouchEventParams {
+            pub fn new(
+                r#type: impl Into<DispatchTouchEventType>,
+                touch_points: Vec<TouchPoint>,
+            ) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    touch_points,
+                    modifiers: None,
+                    timestamp: None,
+                }
+            }
+        }
+        impl DispatchTouchEventParams {
+            pub fn builder() -> DispatchTouchEventParamsBuilder {
+                DispatchTouchEventParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DispatchTouchEventParamsBuilder {
+            r#type: Option<DispatchTouchEventType>,
+            touch_points: Option<Vec<TouchPoint>>,
+            modifiers: Option<i64>,
+            timestamp: Option<TimeSinceEpoch>,
+        }
+        impl DispatchTouchEventParamsBuilder {
+            pub fn r#type(mut self, r#type: impl Into<DispatchTouchEventType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn touch_point(mut self, touch_point: impl Into<TouchPoint>) -> Self {
+                let v = self.touch_points.get_or_insert(Vec::new());
+                v.push(touch_point.into());
+                self
+            }
+            pub fn touch_points<I, S>(mut self, touch_points: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<TouchPoint>,
+            {
+                let v = self.touch_points.get_or_insert(Vec::new());
+                for val in touch_points {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn modifiers(mut self, modifiers: impl Into<i64>) -> Self {
+                self.modifiers = Some(modifiers.into());
+                self
+            }
+            pub fn timestamp(mut self, timestamp: impl Into<TimeSinceEpoch>) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn build(self) -> Result<DispatchTouchEventParams, String> {
+                Ok(DispatchTouchEventParams {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    touch_points: self.touch_points.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(touch_points))
+                    })?,
+                    modifiers: self.modifiers,
+                    timestamp: self.timestamp,
+                })
+            }
+        }
+        impl DispatchTouchEventParams {
+            pub const IDENTIFIER: &'static str = "Input.dispatchTouchEvent";
+        }
+        impl chromiumoxide_types::Method for DispatchTouchEventParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DispatchTouchEventParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Dispatches a touch event to the page.\n[dispatchTouchEvent](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchTouchEvent)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DispatchTouchEventReturns {}
+        impl chromiumoxide_types::Command for DispatchTouchEventParams {
+            type Response = DispatchTouchEventReturns;
+        }
+        #[doc = "Cancels any active dragging in the page.\n[cancelDragging](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-cancelDragging)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CancelDraggingParams {}
+        impl CancelDraggingParams {
+            pub const IDENTIFIER: &'static str = "Input.cancelDragging";
+        }
+        impl chromiumoxide_types::Method for CancelDraggingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CancelDraggingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Cancels any active dragging in the page.\n[cancelDragging](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-cancelDragging)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CancelDraggingReturns {}
+        impl chromiumoxide_types::Command for CancelDraggingParams {
+            type Response = CancelDraggingReturns;
+        }
+        #[doc = "Emulates touch event from the mouse event parameters.\n[emulateTouchFromMouseEvent](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-emulateTouchFromMouseEvent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EmulateTouchFromMouseEventParams {
+            #[doc = "Type of the mouse event."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: EmulateTouchFromMouseEventType,
+            #[doc = "X coordinate of the mouse pointer in DIP."]
+            #[serde(rename = "x")]
+            pub x: i64,
+            #[doc = "Y coordinate of the mouse pointer in DIP."]
+            #[serde(rename = "y")]
+            pub y: i64,
+            #[doc = "Mouse button. Only \"none\", \"left\", \"right\" are supported."]
+            #[serde(rename = "button")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub button: MouseButton,
+            #[doc = "Time at which the event occurred (default: current time)."]
+            #[serde(rename = "timestamp")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub timestamp: Option<TimeSinceEpoch>,
+            #[doc = "X delta in DIP for mouse wheel event (default: 0)."]
+            #[serde(rename = "deltaX")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub delta_x: Option<f64>,
+            #[doc = "Y delta in DIP for mouse wheel event (default: 0)."]
+            #[serde(rename = "deltaY")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub delta_y: Option<f64>,
+            #[doc = "Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8\n(default: 0)."]
+            #[serde(rename = "modifiers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub modifiers: Option<i64>,
+            #[doc = "Number of times the mouse button was clicked (default: 0)."]
+            #[serde(rename = "clickCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub click_count: Option<i64>,
+        }
+        #[doc = "Type of the mouse event."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum EmulateTouchFromMouseEventType {
+            #[serde(rename = "mousePressed")]
+            MousePressed,
+            #[serde(rename = "mouseReleased")]
+            MouseReleased,
+            #[serde(rename = "mouseMoved")]
+            MouseMoved,
+            #[serde(rename = "mouseWheel")]
+            MouseWheel,
+        }
+        impl AsRef<str> for EmulateTouchFromMouseEventType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    EmulateTouchFromMouseEventType::MousePressed => "mousePressed",
+                    EmulateTouchFromMouseEventType::MouseReleased => "mouseReleased",
+                    EmulateTouchFromMouseEventType::MouseMoved => "mouseMoved",
+                    EmulateTouchFromMouseEventType::MouseWheel => "mouseWheel",
+                }
+            }
+        }
+        impl ::std::str::FromStr for EmulateTouchFromMouseEventType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "mousePressed" | "MousePressed" | "mousepressed" => {
+                        Ok(EmulateTouchFromMouseEventType::MousePressed)
+                    }
+                    "mouseReleased" | "MouseReleased" | "mousereleased" => {
+                        Ok(EmulateTouchFromMouseEventType::MouseReleased)
+                    }
+                    "mouseMoved" | "MouseMoved" | "mousemoved" => {
+                        Ok(EmulateTouchFromMouseEventType::MouseMoved)
+                    }
+                    "mouseWheel" | "MouseWheel" | "mousewheel" => {
+                        Ok(EmulateTouchFromMouseEventType::MouseWheel)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EmulateTouchFromMouseEventParams {
+            pub fn new(
+                r#type: impl Into<EmulateTouchFromMouseEventType>,
+                x: impl Into<i64>,
+                y: impl Into<i64>,
+                button: impl Into<MouseButton>,
+            ) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    x: x.into(),
+                    y: y.into(),
+                    button: button.into(),
+                    timestamp: None,
+                    delta_x: None,
+                    delta_y: None,
+                    modifiers: None,
+                    click_count: None,
+                }
+            }
+        }
+        impl EmulateTouchFromMouseEventParams {
+            pub fn builder() -> EmulateTouchFromMouseEventParamsBuilder {
+                EmulateTouchFromMouseEventParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EmulateTouchFromMouseEventParamsBuilder {
+            r#type: Option<EmulateTouchFromMouseEventType>,
+            x: Option<i64>,
+            y: Option<i64>,
+            button: Option<MouseButton>,
+            timestamp: Option<TimeSinceEpoch>,
+            delta_x: Option<f64>,
+            delta_y: Option<f64>,
+            modifiers: Option<i64>,
+            click_count: Option<i64>,
+        }
+        impl EmulateTouchFromMouseEventParamsBuilder {
+            pub fn r#type(mut self, r#type: impl Into<EmulateTouchFromMouseEventType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn x(mut self, x: impl Into<i64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<i64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn button(mut self, button: impl Into<MouseButton>) -> Self {
+                self.button = Some(button.into());
+                self
+            }
+            pub fn timestamp(mut self, timestamp: impl Into<TimeSinceEpoch>) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn delta_x(mut self, delta_x: impl Into<f64>) -> Self {
+                self.delta_x = Some(delta_x.into());
+                self
+            }
+            pub fn delta_y(mut self, delta_y: impl Into<f64>) -> Self {
+                self.delta_y = Some(delta_y.into());
+                self
+            }
+            pub fn modifiers(mut self, modifiers: impl Into<i64>) -> Self {
+                self.modifiers = Some(modifiers.into());
+                self
+            }
+            pub fn click_count(mut self, click_count: impl Into<i64>) -> Self {
+                self.click_count = Some(click_count.into());
+                self
+            }
+            pub fn build(self) -> Result<EmulateTouchFromMouseEventParams, String> {
+                Ok(EmulateTouchFromMouseEventParams {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    button: self.button.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(button))
+                    })?,
+                    timestamp: self.timestamp,
+                    delta_x: self.delta_x,
+                    delta_y: self.delta_y,
+                    modifiers: self.modifiers,
+                    click_count: self.click_count,
+                })
+            }
+        }
+        impl EmulateTouchFromMouseEventParams {
+            pub const IDENTIFIER: &'static str = "Input.emulateTouchFromMouseEvent";
+        }
+        impl chromiumoxide_types::Method for EmulateTouchFromMouseEventParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EmulateTouchFromMouseEventParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Emulates touch event from the mouse event parameters.\n[emulateTouchFromMouseEvent](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-emulateTouchFromMouseEvent)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EmulateTouchFromMouseEventReturns {}
+        impl chromiumoxide_types::Command for EmulateTouchFromMouseEventParams {
+            type Response = EmulateTouchFromMouseEventReturns;
+        }
+        #[doc = "Ignores input events (useful while auditing page).\n[setIgnoreInputEvents](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-setIgnoreInputEvents)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetIgnoreInputEventsParams {
+            #[doc = "Ignores input events processing when set to true."]
+            #[serde(rename = "ignore")]
+            pub ignore: bool,
+        }
+        impl SetIgnoreInputEventsParams {
+            pub fn new(ignore: impl Into<bool>) -> Self {
+                Self {
+                    ignore: ignore.into(),
+                }
+            }
+        }
+        impl SetIgnoreInputEventsParams {
+            pub fn builder() -> SetIgnoreInputEventsParamsBuilder {
+                SetIgnoreInputEventsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetIgnoreInputEventsParamsBuilder {
+            ignore: Option<bool>,
+        }
+        impl SetIgnoreInputEventsParamsBuilder {
+            pub fn ignore(mut self, ignore: impl Into<bool>) -> Self {
+                self.ignore = Some(ignore.into());
+                self
+            }
+            pub fn build(self) -> Result<SetIgnoreInputEventsParams, String> {
+                Ok(SetIgnoreInputEventsParams {
+                    ignore: self.ignore.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ignore))
+                    })?,
+                })
+            }
+        }
+        impl SetIgnoreInputEventsParams {
+            pub const IDENTIFIER: &'static str = "Input.setIgnoreInputEvents";
+        }
+        impl chromiumoxide_types::Method for SetIgnoreInputEventsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetIgnoreInputEventsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Ignores input events (useful while auditing page).\n[setIgnoreInputEvents](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-setIgnoreInputEvents)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetIgnoreInputEventsReturns {}
+        impl chromiumoxide_types::Command for SetIgnoreInputEventsParams {
+            type Response = SetIgnoreInputEventsReturns;
+        }
+        #[doc = "Prevents default drag and drop behavior and instead emits `Input.dragIntercepted` events.\nDrag and drop behavior can be directly controlled via `Input.dispatchDragEvent`.\n[setInterceptDrags](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-setInterceptDrags)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetInterceptDragsParams {
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetInterceptDragsParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetInterceptDragsParams {
+            pub fn builder() -> SetInterceptDragsParamsBuilder {
+                SetInterceptDragsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetInterceptDragsParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetInterceptDragsParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetInterceptDragsParams, String> {
+                Ok(SetInterceptDragsParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetInterceptDragsParams {
+            pub const IDENTIFIER: &'static str = "Input.setInterceptDrags";
+        }
+        impl chromiumoxide_types::Method for SetInterceptDragsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetInterceptDragsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Prevents default drag and drop behavior and instead emits `Input.dragIntercepted` events.\nDrag and drop behavior can be directly controlled via `Input.dispatchDragEvent`.\n[setInterceptDrags](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-setInterceptDrags)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetInterceptDragsReturns {}
+        impl chromiumoxide_types::Command for SetInterceptDragsParams {
+            type Response = SetInterceptDragsReturns;
+        }
+        #[doc = "Synthesizes a pinch gesture over a time period by issuing appropriate touch events.\n[synthesizePinchGesture](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-synthesizePinchGesture)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SynthesizePinchGestureParams {
+            #[doc = "X coordinate of the start of the gesture in CSS pixels."]
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[doc = "Y coordinate of the start of the gesture in CSS pixels."]
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[doc = "Relative scale factor after zooming (>1.0 zooms in, <1.0 zooms out)."]
+            #[serde(rename = "scaleFactor")]
+            pub scale_factor: f64,
+            #[doc = "Relative pointer speed in pixels per second (default: 800)."]
+            #[serde(rename = "relativeSpeed")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub relative_speed: Option<i64>,
+            #[doc = "Which type of input events to be generated (default: 'default', which queries the platform\nfor the preferred input type)."]
+            #[serde(rename = "gestureSourceType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub gesture_source_type: Option<GestureSourceType>,
+        }
+        impl SynthesizePinchGestureParams {
+            pub fn new(x: impl Into<f64>, y: impl Into<f64>, scale_factor: impl Into<f64>) -> Self {
+                Self {
+                    x: x.into(),
+                    y: y.into(),
+                    scale_factor: scale_factor.into(),
+                    relative_speed: None,
+                    gesture_source_type: None,
+                }
+            }
+        }
+        impl SynthesizePinchGestureParams {
+            pub fn builder() -> SynthesizePinchGestureParamsBuilder {
+                SynthesizePinchGestureParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SynthesizePinchGestureParamsBuilder {
+            x: Option<f64>,
+            y: Option<f64>,
+            scale_factor: Option<f64>,
+            relative_speed: Option<i64>,
+            gesture_source_type: Option<GestureSourceType>,
+        }
+        impl SynthesizePinchGestureParamsBuilder {
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn scale_factor(mut self, scale_factor: impl Into<f64>) -> Self {
+                self.scale_factor = Some(scale_factor.into());
+                self
+            }
+            pub fn relative_speed(mut self, relative_speed: impl Into<i64>) -> Self {
+                self.relative_speed = Some(relative_speed.into());
+                self
+            }
+            pub fn gesture_source_type(
+                mut self,
+                gesture_source_type: impl Into<GestureSourceType>,
+            ) -> Self {
+                self.gesture_source_type = Some(gesture_source_type.into());
+                self
+            }
+            pub fn build(self) -> Result<SynthesizePinchGestureParams, String> {
+                Ok(SynthesizePinchGestureParams {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    scale_factor: self.scale_factor.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scale_factor))
+                    })?,
+                    relative_speed: self.relative_speed,
+                    gesture_source_type: self.gesture_source_type,
+                })
+            }
+        }
+        impl SynthesizePinchGestureParams {
+            pub const IDENTIFIER: &'static str = "Input.synthesizePinchGesture";
+        }
+        impl chromiumoxide_types::Method for SynthesizePinchGestureParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SynthesizePinchGestureParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Synthesizes a pinch gesture over a time period by issuing appropriate touch events.\n[synthesizePinchGesture](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-synthesizePinchGesture)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SynthesizePinchGestureReturns {}
+        impl chromiumoxide_types::Command for SynthesizePinchGestureParams {
+            type Response = SynthesizePinchGestureReturns;
+        }
+        #[doc = "Synthesizes a scroll gesture over a time period by issuing appropriate touch events.\n[synthesizeScrollGesture](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-synthesizeScrollGesture)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SynthesizeScrollGestureParams {
+            #[doc = "X coordinate of the start of the gesture in CSS pixels."]
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[doc = "Y coordinate of the start of the gesture in CSS pixels."]
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[doc = "The distance to scroll along the X axis (positive to scroll left)."]
+            #[serde(rename = "xDistance")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub x_distance: Option<f64>,
+            #[doc = "The distance to scroll along the Y axis (positive to scroll up)."]
+            #[serde(rename = "yDistance")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub y_distance: Option<f64>,
+            #[doc = "The number of additional pixels to scroll back along the X axis, in addition to the given\ndistance."]
+            #[serde(rename = "xOverscroll")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub x_overscroll: Option<f64>,
+            #[doc = "The number of additional pixels to scroll back along the Y axis, in addition to the given\ndistance."]
+            #[serde(rename = "yOverscroll")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub y_overscroll: Option<f64>,
+            #[doc = "Prevent fling (default: true)."]
+            #[serde(rename = "preventFling")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub prevent_fling: Option<bool>,
+            #[doc = "Swipe speed in pixels per second (default: 800)."]
+            #[serde(rename = "speed")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub speed: Option<i64>,
+            #[doc = "Which type of input events to be generated (default: 'default', which queries the platform\nfor the preferred input type)."]
+            #[serde(rename = "gestureSourceType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub gesture_source_type: Option<GestureSourceType>,
+            #[doc = "The number of times to repeat the gesture (default: 0)."]
+            #[serde(rename = "repeatCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub repeat_count: Option<i64>,
+            #[doc = "The number of milliseconds delay between each repeat. (default: 250)."]
+            #[serde(rename = "repeatDelayMs")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub repeat_delay_ms: Option<i64>,
+            #[doc = "The name of the interaction markers to generate, if not empty (default: \"\")."]
+            #[serde(rename = "interactionMarkerName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub interaction_marker_name: Option<String>,
+        }
+        impl SynthesizeScrollGestureParams {
+            pub fn new(x: impl Into<f64>, y: impl Into<f64>) -> Self {
+                Self {
+                    x: x.into(),
+                    y: y.into(),
+                    x_distance: None,
+                    y_distance: None,
+                    x_overscroll: None,
+                    y_overscroll: None,
+                    prevent_fling: None,
+                    speed: None,
+                    gesture_source_type: None,
+                    repeat_count: None,
+                    repeat_delay_ms: None,
+                    interaction_marker_name: None,
+                }
+            }
+        }
+        impl SynthesizeScrollGestureParams {
+            pub fn builder() -> SynthesizeScrollGestureParamsBuilder {
+                SynthesizeScrollGestureParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SynthesizeScrollGestureParamsBuilder {
+            x: Option<f64>,
+            y: Option<f64>,
+            x_distance: Option<f64>,
+            y_distance: Option<f64>,
+            x_overscroll: Option<f64>,
+            y_overscroll: Option<f64>,
+            prevent_fling: Option<bool>,
+            speed: Option<i64>,
+            gesture_source_type: Option<GestureSourceType>,
+            repeat_count: Option<i64>,
+            repeat_delay_ms: Option<i64>,
+            interaction_marker_name: Option<String>,
+        }
+        impl SynthesizeScrollGestureParamsBuilder {
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn x_distance(mut self, x_distance: impl Into<f64>) -> Self {
+                self.x_distance = Some(x_distance.into());
+                self
+            }
+            pub fn y_distance(mut self, y_distance: impl Into<f64>) -> Self {
+                self.y_distance = Some(y_distance.into());
+                self
+            }
+            pub fn x_overscroll(mut self, x_overscroll: impl Into<f64>) -> Self {
+                self.x_overscroll = Some(x_overscroll.into());
+                self
+            }
+            pub fn y_overscroll(mut self, y_overscroll: impl Into<f64>) -> Self {
+                self.y_overscroll = Some(y_overscroll.into());
+                self
+            }
+            pub fn prevent_fling(mut self, prevent_fling: impl Into<bool>) -> Self {
+                self.prevent_fling = Some(prevent_fling.into());
+                self
+            }
+            pub fn speed(mut self, speed: impl Into<i64>) -> Self {
+                self.speed = Some(speed.into());
+                self
+            }
+            pub fn gesture_source_type(
+                mut self,
+                gesture_source_type: impl Into<GestureSourceType>,
+            ) -> Self {
+                self.gesture_source_type = Some(gesture_source_type.into());
+                self
+            }
+            pub fn repeat_count(mut self, repeat_count: impl Into<i64>) -> Self {
+                self.repeat_count = Some(repeat_count.into());
+                self
+            }
+            pub fn repeat_delay_ms(mut self, repeat_delay_ms: impl Into<i64>) -> Self {
+                self.repeat_delay_ms = Some(repeat_delay_ms.into());
+                self
+            }
+            pub fn interaction_marker_name(
+                mut self,
+                interaction_marker_name: impl Into<String>,
+            ) -> Self {
+                self.interaction_marker_name = Some(interaction_marker_name.into());
+                self
+            }
+            pub fn build(self) -> Result<SynthesizeScrollGestureParams, String> {
+                Ok(SynthesizeScrollGestureParams {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    x_distance: self.x_distance,
+                    y_distance: self.y_distance,
+                    x_overscroll: self.x_overscroll,
+                    y_overscroll: self.y_overscroll,
+                    prevent_fling: self.prevent_fling,
+                    speed: self.speed,
+                    gesture_source_type: self.gesture_source_type,
+                    repeat_count: self.repeat_count,
+                    repeat_delay_ms: self.repeat_delay_ms,
+                    interaction_marker_name: self.interaction_marker_name,
+                })
+            }
+        }
+        impl SynthesizeScrollGestureParams {
+            pub const IDENTIFIER: &'static str = "Input.synthesizeScrollGesture";
+        }
+        impl chromiumoxide_types::Method for SynthesizeScrollGestureParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SynthesizeScrollGestureParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Synthesizes a scroll gesture over a time period by issuing appropriate touch events.\n[synthesizeScrollGesture](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-synthesizeScrollGesture)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SynthesizeScrollGestureReturns {}
+        impl chromiumoxide_types::Command for SynthesizeScrollGestureParams {
+            type Response = SynthesizeScrollGestureReturns;
+        }
+        #[doc = "Synthesizes a tap gesture over a time period by issuing appropriate touch events.\n[synthesizeTapGesture](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-synthesizeTapGesture)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SynthesizeTapGestureParams {
+            #[doc = "X coordinate of the start of the gesture in CSS pixels."]
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[doc = "Y coordinate of the start of the gesture in CSS pixels."]
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[doc = "Duration between touchdown and touchup events in ms (default: 50)."]
+            #[serde(rename = "duration")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub duration: Option<i64>,
+            #[doc = "Number of times to perform the tap (e.g. 2 for double tap, default: 1)."]
+            #[serde(rename = "tapCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub tap_count: Option<i64>,
+            #[doc = "Which type of input events to be generated (default: 'default', which queries the platform\nfor the preferred input type)."]
+            #[serde(rename = "gestureSourceType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub gesture_source_type: Option<GestureSourceType>,
+        }
+        impl SynthesizeTapGestureParams {
+            pub fn new(x: impl Into<f64>, y: impl Into<f64>) -> Self {
+                Self {
+                    x: x.into(),
+                    y: y.into(),
+                    duration: None,
+                    tap_count: None,
+                    gesture_source_type: None,
+                }
+            }
+        }
+        impl SynthesizeTapGestureParams {
+            pub fn builder() -> SynthesizeTapGestureParamsBuilder {
+                SynthesizeTapGestureParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SynthesizeTapGestureParamsBuilder {
+            x: Option<f64>,
+            y: Option<f64>,
+            duration: Option<i64>,
+            tap_count: Option<i64>,
+            gesture_source_type: Option<GestureSourceType>,
+        }
+        impl SynthesizeTapGestureParamsBuilder {
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn duration(mut self, duration: impl Into<i64>) -> Self {
+                self.duration = Some(duration.into());
+                self
+            }
+            pub fn tap_count(mut self, tap_count: impl Into<i64>) -> Self {
+                self.tap_count = Some(tap_count.into());
+                self
+            }
+            pub fn gesture_source_type(
+                mut self,
+                gesture_source_type: impl Into<GestureSourceType>,
+            ) -> Self {
+                self.gesture_source_type = Some(gesture_source_type.into());
+                self
+            }
+            pub fn build(self) -> Result<SynthesizeTapGestureParams, String> {
+                Ok(SynthesizeTapGestureParams {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    duration: self.duration,
+                    tap_count: self.tap_count,
+                    gesture_source_type: self.gesture_source_type,
+                })
+            }
+        }
+        impl SynthesizeTapGestureParams {
+            pub const IDENTIFIER: &'static str = "Input.synthesizeTapGesture";
+        }
+        impl chromiumoxide_types::Method for SynthesizeTapGestureParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SynthesizeTapGestureParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Synthesizes a tap gesture over a time period by issuing appropriate touch events.\n[synthesizeTapGesture](https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-synthesizeTapGesture)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SynthesizeTapGestureReturns {}
+        impl chromiumoxide_types::Command for SynthesizeTapGestureParams {
+            type Response = SynthesizeTapGestureReturns;
+        }
+        #[doc = "Emitted only when `Input.setInterceptDrags` is enabled. Use this data with `Input.dispatchDragEvent` to\nrestore normal drag and drop behavior.\n[dragIntercepted](https://chromedevtools.github.io/devtools-protocol/tot/Input/#event-dragIntercepted)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDragIntercepted {
+            #[serde(rename = "data")]
+            pub data: DragData,
+        }
+        impl EventDragIntercepted {
+            pub const IDENTIFIER: &'static str = "Input.dragIntercepted";
+        }
+        impl chromiumoxide_types::Method for EventDragIntercepted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDragIntercepted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod inspector {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Disables inspector domain notifications.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Inspector/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Inspector.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables inspector domain notifications.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Inspector/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables inspector domain notifications.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Inspector/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Inspector.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables inspector domain notifications.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Inspector/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Fired when remote debugging connection is about to be terminated. Contains detach reason.\n[detached](https://chromedevtools.github.io/devtools-protocol/tot/Inspector/#event-detached)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDetached {
+            #[doc = "The reason why connection has been terminated."]
+            #[serde(rename = "reason")]
+            pub reason: String,
+        }
+        impl EventDetached {
+            pub const IDENTIFIER: &'static str = "Inspector.detached";
+        }
+        impl chromiumoxide_types::Method for EventDetached {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDetached {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when debugging target has crashed\n[targetCrashed](https://chromedevtools.github.io/devtools-protocol/tot/Inspector/#event-targetCrashed)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventTargetCrashed {}
+        impl EventTargetCrashed {
+            pub const IDENTIFIER: &'static str = "Inspector.targetCrashed";
+        }
+        impl chromiumoxide_types::Method for EventTargetCrashed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventTargetCrashed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when debugging target has reloaded after crash\n[targetReloadedAfterCrash](https://chromedevtools.github.io/devtools-protocol/tot/Inspector/#event-targetReloadedAfterCrash)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventTargetReloadedAfterCrash {}
+        impl EventTargetReloadedAfterCrash {
+            pub const IDENTIFIER: &'static str = "Inspector.targetReloadedAfterCrash";
+        }
+        impl chromiumoxide_types::Method for EventTargetReloadedAfterCrash {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventTargetReloadedAfterCrash {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired on worker targets when main worker script and any imported scripts have been evaluated.\n[workerScriptLoaded](https://chromedevtools.github.io/devtools-protocol/tot/Inspector/#event-workerScriptLoaded)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventWorkerScriptLoaded {}
+        impl EventWorkerScriptLoaded {
+            pub const IDENTIFIER: &'static str = "Inspector.workerScriptLoaded";
+        }
+        impl chromiumoxide_types::Method for EventWorkerScriptLoaded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWorkerScriptLoaded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod layer_tree {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Unique Layer identifier.\n[LayerId](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#type-LayerId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct LayerId(String);
+        impl LayerId {
+            pub fn new(val: impl Into<String>) -> Self {
+                LayerId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for LayerId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<LayerId> for String {
+            fn from(el: LayerId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for LayerId {
+            fn from(expr: String) -> Self {
+                LayerId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for LayerId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl LayerId {
+            pub const IDENTIFIER: &'static str = "LayerTree.LayerId";
+        }
+        #[doc = "Unique snapshot identifier.\n[SnapshotId](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#type-SnapshotId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct SnapshotId(String);
+        impl SnapshotId {
+            pub fn new(val: impl Into<String>) -> Self {
+                SnapshotId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for SnapshotId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<SnapshotId> for String {
+            fn from(el: SnapshotId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for SnapshotId {
+            fn from(expr: String) -> Self {
+                SnapshotId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for SnapshotId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl SnapshotId {
+            pub const IDENTIFIER: &'static str = "LayerTree.SnapshotId";
+        }
+        #[doc = "Rectangle where scrolling happens on the main thread.\n[ScrollRect](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#type-ScrollRect)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScrollRect {
+            #[doc = "Rectangle itself."]
+            #[serde(rename = "rect")]
+            pub rect: super::dom::Rect,
+            #[doc = "Reason for rectangle to force scrolling on the main thread"]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: ScrollRectType,
+        }
+        #[doc = "Reason for rectangle to force scrolling on the main thread"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ScrollRectType {
+            #[serde(rename = "RepaintsOnScroll")]
+            RepaintsOnScroll,
+            #[serde(rename = "TouchEventHandler")]
+            TouchEventHandler,
+            #[serde(rename = "WheelEventHandler")]
+            WheelEventHandler,
+        }
+        impl AsRef<str> for ScrollRectType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ScrollRectType::RepaintsOnScroll => "RepaintsOnScroll",
+                    ScrollRectType::TouchEventHandler => "TouchEventHandler",
+                    ScrollRectType::WheelEventHandler => "WheelEventHandler",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ScrollRectType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "RepaintsOnScroll" | "repaintsonscroll" => Ok(ScrollRectType::RepaintsOnScroll),
+                    "TouchEventHandler" | "toucheventhandler" => {
+                        Ok(ScrollRectType::TouchEventHandler)
+                    }
+                    "WheelEventHandler" | "wheeleventhandler" => {
+                        Ok(ScrollRectType::WheelEventHandler)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl ScrollRect {
+            pub fn new(
+                rect: impl Into<super::dom::Rect>,
+                r#type: impl Into<ScrollRectType>,
+            ) -> Self {
+                Self {
+                    rect: rect.into(),
+                    r#type: r#type.into(),
+                }
+            }
+        }
+        impl ScrollRect {
+            pub fn builder() -> ScrollRectBuilder {
+                ScrollRectBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScrollRectBuilder {
+            rect: Option<super::dom::Rect>,
+            r#type: Option<ScrollRectType>,
+        }
+        impl ScrollRectBuilder {
+            pub fn rect(mut self, rect: impl Into<super::dom::Rect>) -> Self {
+                self.rect = Some(rect.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<ScrollRectType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<ScrollRect, String> {
+                Ok(ScrollRect {
+                    rect: self.rect.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rect))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                })
+            }
+        }
+        impl ScrollRect {
+            pub const IDENTIFIER: &'static str = "LayerTree.ScrollRect";
+        }
+        #[doc = "Sticky position constraints.\n[StickyPositionConstraint](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#type-StickyPositionConstraint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StickyPositionConstraint {
+            #[doc = "Layout rectangle of the sticky element before being shifted"]
+            #[serde(rename = "stickyBoxRect")]
+            pub sticky_box_rect: super::dom::Rect,
+            #[doc = "Layout rectangle of the containing block of the sticky element"]
+            #[serde(rename = "containingBlockRect")]
+            pub containing_block_rect: super::dom::Rect,
+            #[doc = "The nearest sticky layer that shifts the sticky box"]
+            #[serde(rename = "nearestLayerShiftingStickyBox")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub nearest_layer_shifting_sticky_box: Option<LayerId>,
+            #[doc = "The nearest sticky layer that shifts the containing block"]
+            #[serde(rename = "nearestLayerShiftingContainingBlock")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub nearest_layer_shifting_containing_block: Option<LayerId>,
+        }
+        impl StickyPositionConstraint {
+            pub fn new(
+                sticky_box_rect: impl Into<super::dom::Rect>,
+                containing_block_rect: impl Into<super::dom::Rect>,
+            ) -> Self {
+                Self {
+                    sticky_box_rect: sticky_box_rect.into(),
+                    containing_block_rect: containing_block_rect.into(),
+                    nearest_layer_shifting_sticky_box: None,
+                    nearest_layer_shifting_containing_block: None,
+                }
+            }
+        }
+        impl StickyPositionConstraint {
+            pub fn builder() -> StickyPositionConstraintBuilder {
+                StickyPositionConstraintBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StickyPositionConstraintBuilder {
+            sticky_box_rect: Option<super::dom::Rect>,
+            containing_block_rect: Option<super::dom::Rect>,
+            nearest_layer_shifting_sticky_box: Option<LayerId>,
+            nearest_layer_shifting_containing_block: Option<LayerId>,
+        }
+        impl StickyPositionConstraintBuilder {
+            pub fn sticky_box_rect(mut self, sticky_box_rect: impl Into<super::dom::Rect>) -> Self {
+                self.sticky_box_rect = Some(sticky_box_rect.into());
+                self
+            }
+            pub fn containing_block_rect(
+                mut self,
+                containing_block_rect: impl Into<super::dom::Rect>,
+            ) -> Self {
+                self.containing_block_rect = Some(containing_block_rect.into());
+                self
+            }
+            pub fn nearest_layer_shifting_sticky_box(
+                mut self,
+                nearest_layer_shifting_sticky_box: impl Into<LayerId>,
+            ) -> Self {
+                self.nearest_layer_shifting_sticky_box =
+                    Some(nearest_layer_shifting_sticky_box.into());
+                self
+            }
+            pub fn nearest_layer_shifting_containing_block(
+                mut self,
+                nearest_layer_shifting_containing_block: impl Into<LayerId>,
+            ) -> Self {
+                self.nearest_layer_shifting_containing_block =
+                    Some(nearest_layer_shifting_containing_block.into());
+                self
+            }
+            pub fn build(self) -> Result<StickyPositionConstraint, String> {
+                Ok(StickyPositionConstraint {
+                    sticky_box_rect: self.sticky_box_rect.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(sticky_box_rect))
+                    })?,
+                    containing_block_rect: self.containing_block_rect.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(containing_block_rect)
+                        )
+                    })?,
+                    nearest_layer_shifting_sticky_box: self.nearest_layer_shifting_sticky_box,
+                    nearest_layer_shifting_containing_block: self
+                        .nearest_layer_shifting_containing_block,
+                })
+            }
+        }
+        impl StickyPositionConstraint {
+            pub const IDENTIFIER: &'static str = "LayerTree.StickyPositionConstraint";
+        }
+        #[doc = "Serialized fragment of layer picture along with its offset within the layer.\n[PictureTile](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#type-PictureTile)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PictureTile {
+            #[doc = "Offset from owning layer left boundary"]
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[doc = "Offset from owning layer top boundary"]
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[doc = "Base64-encoded snapshot data."]
+            #[serde(rename = "picture")]
+            pub picture: chromiumoxide_types::Binary,
+        }
+        impl PictureTile {
+            pub fn new(
+                x: impl Into<f64>,
+                y: impl Into<f64>,
+                picture: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                Self {
+                    x: x.into(),
+                    y: y.into(),
+                    picture: picture.into(),
+                }
+            }
+        }
+        impl PictureTile {
+            pub fn builder() -> PictureTileBuilder {
+                PictureTileBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PictureTileBuilder {
+            x: Option<f64>,
+            y: Option<f64>,
+            picture: Option<chromiumoxide_types::Binary>,
+        }
+        impl PictureTileBuilder {
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn picture(mut self, picture: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.picture = Some(picture.into());
+                self
+            }
+            pub fn build(self) -> Result<PictureTile, String> {
+                Ok(PictureTile {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    picture: self.picture.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(picture))
+                    })?,
+                })
+            }
+        }
+        impl PictureTile {
+            pub const IDENTIFIER: &'static str = "LayerTree.PictureTile";
+        }
+        #[doc = "Information about a compositing layer.\n[Layer](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#type-Layer)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Layer {
+            #[doc = "The unique id for this layer."]
+            #[serde(rename = "layerId")]
+            pub layer_id: LayerId,
+            #[doc = "The id of parent (not present for root)."]
+            #[serde(rename = "parentLayerId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent_layer_id: Option<LayerId>,
+            #[doc = "The backend id for the node associated with this layer."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "Offset from parent layer, X coordinate."]
+            #[serde(rename = "offsetX")]
+            pub offset_x: f64,
+            #[doc = "Offset from parent layer, Y coordinate."]
+            #[serde(rename = "offsetY")]
+            pub offset_y: f64,
+            #[doc = "Layer width."]
+            #[serde(rename = "width")]
+            pub width: f64,
+            #[doc = "Layer height."]
+            #[serde(rename = "height")]
+            pub height: f64,
+            #[doc = "Transformation matrix for layer, default is identity matrix"]
+            #[serde(rename = "transform")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub transform: Option<Vec<f64>>,
+            #[doc = "Transform anchor point X, absent if no transform specified"]
+            #[serde(rename = "anchorX")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub anchor_x: Option<f64>,
+            #[doc = "Transform anchor point Y, absent if no transform specified"]
+            #[serde(rename = "anchorY")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub anchor_y: Option<f64>,
+            #[doc = "Transform anchor point Z, absent if no transform specified"]
+            #[serde(rename = "anchorZ")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub anchor_z: Option<f64>,
+            #[doc = "Indicates how many time this layer has painted."]
+            #[serde(rename = "paintCount")]
+            pub paint_count: i64,
+            #[doc = "Indicates whether this layer hosts any content, rather than being used for\ntransform/scrolling purposes only."]
+            #[serde(rename = "drawsContent")]
+            pub draws_content: bool,
+            #[doc = "Set if layer is not visible."]
+            #[serde(rename = "invisible")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub invisible: Option<bool>,
+            #[doc = "Rectangles scrolling on main thread only."]
+            #[serde(rename = "scrollRects")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scroll_rects: Option<Vec<ScrollRect>>,
+            #[doc = "Sticky position constraint information"]
+            #[serde(rename = "stickyPositionConstraint")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub sticky_position_constraint: Option<StickyPositionConstraint>,
+        }
+        impl Layer {
+            pub fn builder() -> LayerBuilder {
+                LayerBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LayerBuilder {
+            layer_id: Option<LayerId>,
+            parent_layer_id: Option<LayerId>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+            offset_x: Option<f64>,
+            offset_y: Option<f64>,
+            width: Option<f64>,
+            height: Option<f64>,
+            transform: Option<Vec<f64>>,
+            anchor_x: Option<f64>,
+            anchor_y: Option<f64>,
+            anchor_z: Option<f64>,
+            paint_count: Option<i64>,
+            draws_content: Option<bool>,
+            invisible: Option<bool>,
+            scroll_rects: Option<Vec<ScrollRect>>,
+            sticky_position_constraint: Option<StickyPositionConstraint>,
+        }
+        impl LayerBuilder {
+            pub fn layer_id(mut self, layer_id: impl Into<LayerId>) -> Self {
+                self.layer_id = Some(layer_id.into());
+                self
+            }
+            pub fn parent_layer_id(mut self, parent_layer_id: impl Into<LayerId>) -> Self {
+                self.parent_layer_id = Some(parent_layer_id.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn offset_x(mut self, offset_x: impl Into<f64>) -> Self {
+                self.offset_x = Some(offset_x.into());
+                self
+            }
+            pub fn offset_y(mut self, offset_y: impl Into<f64>) -> Self {
+                self.offset_y = Some(offset_y.into());
+                self
+            }
+            pub fn width(mut self, width: impl Into<f64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<f64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn transform(mut self, transform: impl Into<f64>) -> Self {
+                let v = self.transform.get_or_insert(Vec::new());
+                v.push(transform.into());
+                self
+            }
+            pub fn transforms<I, S>(mut self, transforms: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<f64>,
+            {
+                let v = self.transform.get_or_insert(Vec::new());
+                for val in transforms {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn anchor_x(mut self, anchor_x: impl Into<f64>) -> Self {
+                self.anchor_x = Some(anchor_x.into());
+                self
+            }
+            pub fn anchor_y(mut self, anchor_y: impl Into<f64>) -> Self {
+                self.anchor_y = Some(anchor_y.into());
+                self
+            }
+            pub fn anchor_z(mut self, anchor_z: impl Into<f64>) -> Self {
+                self.anchor_z = Some(anchor_z.into());
+                self
+            }
+            pub fn paint_count(mut self, paint_count: impl Into<i64>) -> Self {
+                self.paint_count = Some(paint_count.into());
+                self
+            }
+            pub fn draws_content(mut self, draws_content: impl Into<bool>) -> Self {
+                self.draws_content = Some(draws_content.into());
+                self
+            }
+            pub fn invisible(mut self, invisible: impl Into<bool>) -> Self {
+                self.invisible = Some(invisible.into());
+                self
+            }
+            pub fn scroll_rect(mut self, scroll_rect: impl Into<ScrollRect>) -> Self {
+                let v = self.scroll_rects.get_or_insert(Vec::new());
+                v.push(scroll_rect.into());
+                self
+            }
+            pub fn scroll_rects<I, S>(mut self, scroll_rects: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ScrollRect>,
+            {
+                let v = self.scroll_rects.get_or_insert(Vec::new());
+                for val in scroll_rects {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn sticky_position_constraint(
+                mut self,
+                sticky_position_constraint: impl Into<StickyPositionConstraint>,
+            ) -> Self {
+                self.sticky_position_constraint = Some(sticky_position_constraint.into());
+                self
+            }
+            pub fn build(self) -> Result<Layer, String> {
+                Ok(Layer {
+                    layer_id: self.layer_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(layer_id))
+                    })?,
+                    parent_layer_id: self.parent_layer_id,
+                    backend_node_id: self.backend_node_id,
+                    offset_x: self.offset_x.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(offset_x))
+                    })?,
+                    offset_y: self.offset_y.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(offset_y))
+                    })?,
+                    width: self.width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(width))
+                    })?,
+                    height: self.height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(height))
+                    })?,
+                    transform: self.transform,
+                    anchor_x: self.anchor_x,
+                    anchor_y: self.anchor_y,
+                    anchor_z: self.anchor_z,
+                    paint_count: self.paint_count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(paint_count))
+                    })?,
+                    draws_content: self.draws_content.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(draws_content))
+                    })?,
+                    invisible: self.invisible,
+                    scroll_rects: self.scroll_rects,
+                    sticky_position_constraint: self.sticky_position_constraint,
+                })
+            }
+        }
+        impl Layer {
+            pub const IDENTIFIER: &'static str = "LayerTree.Layer";
+        }
+        #[doc = "Array of timings, one per paint step.\n[PaintProfile](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#type-PaintProfile)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct PaintProfile(Vec<f64>);
+        impl PaintProfile {
+            pub fn new(val: impl Into<Vec<f64>>) -> Self {
+                PaintProfile(val.into())
+            }
+            pub fn inner(&self) -> &Vec<f64> {
+                &self.0
+            }
+        }
+        impl PaintProfile {
+            pub const IDENTIFIER: &'static str = "LayerTree.PaintProfile";
+        }
+        #[doc = "Provides the reasons why the given layer was composited.\n[compositingReasons](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-compositingReasons)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CompositingReasonsParams {
+            #[doc = "The id of the layer for which we want to get the reasons it was composited."]
+            #[serde(rename = "layerId")]
+            pub layer_id: LayerId,
+        }
+        impl CompositingReasonsParams {
+            pub fn new(layer_id: impl Into<LayerId>) -> Self {
+                Self {
+                    layer_id: layer_id.into(),
+                }
+            }
+        }
+        impl CompositingReasonsParams {
+            pub fn builder() -> CompositingReasonsParamsBuilder {
+                CompositingReasonsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CompositingReasonsParamsBuilder {
+            layer_id: Option<LayerId>,
+        }
+        impl CompositingReasonsParamsBuilder {
+            pub fn layer_id(mut self, layer_id: impl Into<LayerId>) -> Self {
+                self.layer_id = Some(layer_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CompositingReasonsParams, String> {
+                Ok(CompositingReasonsParams {
+                    layer_id: self.layer_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(layer_id))
+                    })?,
+                })
+            }
+        }
+        impl CompositingReasonsParams {
+            pub const IDENTIFIER: &'static str = "LayerTree.compositingReasons";
+        }
+        impl chromiumoxide_types::Method for CompositingReasonsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CompositingReasonsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Provides the reasons why the given layer was composited.\n[compositingReasons](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-compositingReasons)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CompositingReasonsReturns {
+            #[doc = "A list of strings specifying reasons for the given layer to become composited."]
+            #[serde(rename = "compositingReasons")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub compositing_reasons: Vec<String>,
+            #[doc = "A list of strings specifying reason IDs for the given layer to become composited."]
+            #[serde(rename = "compositingReasonIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub compositing_reason_ids: Vec<String>,
+        }
+        impl CompositingReasonsReturns {
+            pub fn new(
+                compositing_reasons: Vec<String>,
+                compositing_reason_ids: Vec<String>,
+            ) -> Self {
+                Self {
+                    compositing_reasons,
+                    compositing_reason_ids,
+                }
+            }
+        }
+        impl CompositingReasonsReturns {
+            pub fn builder() -> CompositingReasonsReturnsBuilder {
+                CompositingReasonsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CompositingReasonsReturnsBuilder {
+            compositing_reasons: Option<Vec<String>>,
+            compositing_reason_ids: Option<Vec<String>>,
+        }
+        impl CompositingReasonsReturnsBuilder {
+            pub fn compositing_reason(mut self, compositing_reason: impl Into<String>) -> Self {
+                let v = self.compositing_reasons.get_or_insert(Vec::new());
+                v.push(compositing_reason.into());
+                self
+            }
+            pub fn compositing_reasons<I, S>(mut self, compositing_reasons: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.compositing_reasons.get_or_insert(Vec::new());
+                for val in compositing_reasons {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn compositing_reason_id(
+                mut self,
+                compositing_reason_id: impl Into<String>,
+            ) -> Self {
+                let v = self.compositing_reason_ids.get_or_insert(Vec::new());
+                v.push(compositing_reason_id.into());
+                self
+            }
+            pub fn compositing_reason_ids<I, S>(mut self, compositing_reason_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.compositing_reason_ids.get_or_insert(Vec::new());
+                for val in compositing_reason_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<CompositingReasonsReturns, String> {
+                Ok(CompositingReasonsReturns {
+                    compositing_reasons: self.compositing_reasons.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(compositing_reasons)
+                        )
+                    })?,
+                    compositing_reason_ids: self.compositing_reason_ids.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(compositing_reason_ids)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CompositingReasonsParams {
+            type Response = CompositingReasonsReturns;
+        }
+        #[doc = "Disables compositing tree inspection.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "LayerTree.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables compositing tree inspection.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables compositing tree inspection.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "LayerTree.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables compositing tree inspection.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Returns the snapshot identifier.\n[loadSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-loadSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LoadSnapshotParams {
+            #[doc = "An array of tiles composing the snapshot."]
+            #[serde(rename = "tiles")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub tiles: Vec<PictureTile>,
+        }
+        impl LoadSnapshotParams {
+            pub fn new(tiles: Vec<PictureTile>) -> Self {
+                Self { tiles }
+            }
+        }
+        impl LoadSnapshotParams {
+            pub fn builder() -> LoadSnapshotParamsBuilder {
+                LoadSnapshotParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LoadSnapshotParamsBuilder {
+            tiles: Option<Vec<PictureTile>>,
+        }
+        impl LoadSnapshotParamsBuilder {
+            pub fn tile(mut self, tile: impl Into<PictureTile>) -> Self {
+                let v = self.tiles.get_or_insert(Vec::new());
+                v.push(tile.into());
+                self
+            }
+            pub fn tiles<I, S>(mut self, tiles: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PictureTile>,
+            {
+                let v = self.tiles.get_or_insert(Vec::new());
+                for val in tiles {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<LoadSnapshotParams, String> {
+                Ok(LoadSnapshotParams {
+                    tiles: self.tiles.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(tiles))
+                    })?,
+                })
+            }
+        }
+        impl LoadSnapshotParams {
+            pub const IDENTIFIER: &'static str = "LayerTree.loadSnapshot";
+        }
+        impl chromiumoxide_types::Method for LoadSnapshotParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for LoadSnapshotParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the snapshot identifier.\n[loadSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-loadSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LoadSnapshotReturns {
+            #[doc = "The id of the snapshot."]
+            #[serde(rename = "snapshotId")]
+            pub snapshot_id: SnapshotId,
+        }
+        impl LoadSnapshotReturns {
+            pub fn new(snapshot_id: impl Into<SnapshotId>) -> Self {
+                Self {
+                    snapshot_id: snapshot_id.into(),
+                }
+            }
+        }
+        impl LoadSnapshotReturns {
+            pub fn builder() -> LoadSnapshotReturnsBuilder {
+                LoadSnapshotReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LoadSnapshotReturnsBuilder {
+            snapshot_id: Option<SnapshotId>,
+        }
+        impl LoadSnapshotReturnsBuilder {
+            pub fn snapshot_id(mut self, snapshot_id: impl Into<SnapshotId>) -> Self {
+                self.snapshot_id = Some(snapshot_id.into());
+                self
+            }
+            pub fn build(self) -> Result<LoadSnapshotReturns, String> {
+                Ok(LoadSnapshotReturns {
+                    snapshot_id: self.snapshot_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(snapshot_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for LoadSnapshotParams {
+            type Response = LoadSnapshotReturns;
+        }
+        #[doc = "Returns the layer snapshot identifier.\n[makeSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-makeSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct MakeSnapshotParams {
+            #[doc = "The id of the layer."]
+            #[serde(rename = "layerId")]
+            pub layer_id: LayerId,
+        }
+        impl MakeSnapshotParams {
+            pub fn new(layer_id: impl Into<LayerId>) -> Self {
+                Self {
+                    layer_id: layer_id.into(),
+                }
+            }
+        }
+        impl MakeSnapshotParams {
+            pub fn builder() -> MakeSnapshotParamsBuilder {
+                MakeSnapshotParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct MakeSnapshotParamsBuilder {
+            layer_id: Option<LayerId>,
+        }
+        impl MakeSnapshotParamsBuilder {
+            pub fn layer_id(mut self, layer_id: impl Into<LayerId>) -> Self {
+                self.layer_id = Some(layer_id.into());
+                self
+            }
+            pub fn build(self) -> Result<MakeSnapshotParams, String> {
+                Ok(MakeSnapshotParams {
+                    layer_id: self.layer_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(layer_id))
+                    })?,
+                })
+            }
+        }
+        impl MakeSnapshotParams {
+            pub const IDENTIFIER: &'static str = "LayerTree.makeSnapshot";
+        }
+        impl chromiumoxide_types::Method for MakeSnapshotParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for MakeSnapshotParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the layer snapshot identifier.\n[makeSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-makeSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct MakeSnapshotReturns {
+            #[doc = "The id of the layer snapshot."]
+            #[serde(rename = "snapshotId")]
+            pub snapshot_id: SnapshotId,
+        }
+        impl MakeSnapshotReturns {
+            pub fn new(snapshot_id: impl Into<SnapshotId>) -> Self {
+                Self {
+                    snapshot_id: snapshot_id.into(),
+                }
+            }
+        }
+        impl MakeSnapshotReturns {
+            pub fn builder() -> MakeSnapshotReturnsBuilder {
+                MakeSnapshotReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct MakeSnapshotReturnsBuilder {
+            snapshot_id: Option<SnapshotId>,
+        }
+        impl MakeSnapshotReturnsBuilder {
+            pub fn snapshot_id(mut self, snapshot_id: impl Into<SnapshotId>) -> Self {
+                self.snapshot_id = Some(snapshot_id.into());
+                self
+            }
+            pub fn build(self) -> Result<MakeSnapshotReturns, String> {
+                Ok(MakeSnapshotReturns {
+                    snapshot_id: self.snapshot_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(snapshot_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for MakeSnapshotParams {
+            type Response = MakeSnapshotReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ProfileSnapshotParams {
+            #[doc = "The id of the layer snapshot."]
+            #[serde(rename = "snapshotId")]
+            pub snapshot_id: SnapshotId,
+            #[doc = "The maximum number of times to replay the snapshot (1, if not specified)."]
+            #[serde(rename = "minRepeatCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub min_repeat_count: Option<i64>,
+            #[doc = "The minimum duration (in seconds) to replay the snapshot."]
+            #[serde(rename = "minDuration")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub min_duration: Option<f64>,
+            #[doc = "The clip rectangle to apply when replaying the snapshot."]
+            #[serde(rename = "clipRect")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub clip_rect: Option<super::dom::Rect>,
+        }
+        impl ProfileSnapshotParams {
+            pub fn new(snapshot_id: impl Into<SnapshotId>) -> Self {
+                Self {
+                    snapshot_id: snapshot_id.into(),
+                    min_repeat_count: None,
+                    min_duration: None,
+                    clip_rect: None,
+                }
+            }
+        }
+        impl ProfileSnapshotParams {
+            pub fn builder() -> ProfileSnapshotParamsBuilder {
+                ProfileSnapshotParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ProfileSnapshotParamsBuilder {
+            snapshot_id: Option<SnapshotId>,
+            min_repeat_count: Option<i64>,
+            min_duration: Option<f64>,
+            clip_rect: Option<super::dom::Rect>,
+        }
+        impl ProfileSnapshotParamsBuilder {
+            pub fn snapshot_id(mut self, snapshot_id: impl Into<SnapshotId>) -> Self {
+                self.snapshot_id = Some(snapshot_id.into());
+                self
+            }
+            pub fn min_repeat_count(mut self, min_repeat_count: impl Into<i64>) -> Self {
+                self.min_repeat_count = Some(min_repeat_count.into());
+                self
+            }
+            pub fn min_duration(mut self, min_duration: impl Into<f64>) -> Self {
+                self.min_duration = Some(min_duration.into());
+                self
+            }
+            pub fn clip_rect(mut self, clip_rect: impl Into<super::dom::Rect>) -> Self {
+                self.clip_rect = Some(clip_rect.into());
+                self
+            }
+            pub fn build(self) -> Result<ProfileSnapshotParams, String> {
+                Ok(ProfileSnapshotParams {
+                    snapshot_id: self.snapshot_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(snapshot_id))
+                    })?,
+                    min_repeat_count: self.min_repeat_count,
+                    min_duration: self.min_duration,
+                    clip_rect: self.clip_rect,
+                })
+            }
+        }
+        impl ProfileSnapshotParams {
+            pub const IDENTIFIER: &'static str = "LayerTree.profileSnapshot";
+        }
+        impl chromiumoxide_types::Method for ProfileSnapshotParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ProfileSnapshotParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ProfileSnapshotReturns {
+            #[doc = "The array of paint profiles, one per run."]
+            #[serde(rename = "timings")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub timings: Vec<PaintProfile>,
+        }
+        impl ProfileSnapshotReturns {
+            pub fn new(timings: Vec<PaintProfile>) -> Self {
+                Self { timings }
+            }
+        }
+        impl ProfileSnapshotReturns {
+            pub fn builder() -> ProfileSnapshotReturnsBuilder {
+                ProfileSnapshotReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ProfileSnapshotReturnsBuilder {
+            timings: Option<Vec<PaintProfile>>,
+        }
+        impl ProfileSnapshotReturnsBuilder {
+            pub fn timing(mut self, timing: impl Into<PaintProfile>) -> Self {
+                let v = self.timings.get_or_insert(Vec::new());
+                v.push(timing.into());
+                self
+            }
+            pub fn timings<I, S>(mut self, timings: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PaintProfile>,
+            {
+                let v = self.timings.get_or_insert(Vec::new());
+                for val in timings {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ProfileSnapshotReturns, String> {
+                Ok(ProfileSnapshotReturns {
+                    timings: self.timings.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(timings))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for ProfileSnapshotParams {
+            type Response = ProfileSnapshotReturns;
+        }
+        #[doc = "Releases layer snapshot captured by the back-end.\n[releaseSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-releaseSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReleaseSnapshotParams {
+            #[doc = "The id of the layer snapshot."]
+            #[serde(rename = "snapshotId")]
+            pub snapshot_id: SnapshotId,
+        }
+        impl ReleaseSnapshotParams {
+            pub fn new(snapshot_id: impl Into<SnapshotId>) -> Self {
+                Self {
+                    snapshot_id: snapshot_id.into(),
+                }
+            }
+        }
+        impl ReleaseSnapshotParams {
+            pub fn builder() -> ReleaseSnapshotParamsBuilder {
+                ReleaseSnapshotParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReleaseSnapshotParamsBuilder {
+            snapshot_id: Option<SnapshotId>,
+        }
+        impl ReleaseSnapshotParamsBuilder {
+            pub fn snapshot_id(mut self, snapshot_id: impl Into<SnapshotId>) -> Self {
+                self.snapshot_id = Some(snapshot_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ReleaseSnapshotParams, String> {
+                Ok(ReleaseSnapshotParams {
+                    snapshot_id: self.snapshot_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(snapshot_id))
+                    })?,
+                })
+            }
+        }
+        impl ReleaseSnapshotParams {
+            pub const IDENTIFIER: &'static str = "LayerTree.releaseSnapshot";
+        }
+        impl chromiumoxide_types::Method for ReleaseSnapshotParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ReleaseSnapshotParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Releases layer snapshot captured by the back-end.\n[releaseSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-releaseSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ReleaseSnapshotReturns {}
+        impl chromiumoxide_types::Command for ReleaseSnapshotParams {
+            type Response = ReleaseSnapshotReturns;
+        }
+        #[doc = "Replays the layer snapshot and returns the resulting bitmap.\n[replaySnapshot](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-replaySnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReplaySnapshotParams {
+            #[doc = "The id of the layer snapshot."]
+            #[serde(rename = "snapshotId")]
+            pub snapshot_id: SnapshotId,
+            #[doc = "The first step to replay from (replay from the very start if not specified)."]
+            #[serde(rename = "fromStep")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub from_step: Option<i64>,
+            #[doc = "The last step to replay to (replay till the end if not specified)."]
+            #[serde(rename = "toStep")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub to_step: Option<i64>,
+            #[doc = "The scale to apply while replaying (defaults to 1)."]
+            #[serde(rename = "scale")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scale: Option<f64>,
+        }
+        impl ReplaySnapshotParams {
+            pub fn new(snapshot_id: impl Into<SnapshotId>) -> Self {
+                Self {
+                    snapshot_id: snapshot_id.into(),
+                    from_step: None,
+                    to_step: None,
+                    scale: None,
+                }
+            }
+        }
+        impl ReplaySnapshotParams {
+            pub fn builder() -> ReplaySnapshotParamsBuilder {
+                ReplaySnapshotParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReplaySnapshotParamsBuilder {
+            snapshot_id: Option<SnapshotId>,
+            from_step: Option<i64>,
+            to_step: Option<i64>,
+            scale: Option<f64>,
+        }
+        impl ReplaySnapshotParamsBuilder {
+            pub fn snapshot_id(mut self, snapshot_id: impl Into<SnapshotId>) -> Self {
+                self.snapshot_id = Some(snapshot_id.into());
+                self
+            }
+            pub fn from_step(mut self, from_step: impl Into<i64>) -> Self {
+                self.from_step = Some(from_step.into());
+                self
+            }
+            pub fn to_step(mut self, to_step: impl Into<i64>) -> Self {
+                self.to_step = Some(to_step.into());
+                self
+            }
+            pub fn scale(mut self, scale: impl Into<f64>) -> Self {
+                self.scale = Some(scale.into());
+                self
+            }
+            pub fn build(self) -> Result<ReplaySnapshotParams, String> {
+                Ok(ReplaySnapshotParams {
+                    snapshot_id: self.snapshot_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(snapshot_id))
+                    })?,
+                    from_step: self.from_step,
+                    to_step: self.to_step,
+                    scale: self.scale,
+                })
+            }
+        }
+        impl ReplaySnapshotParams {
+            pub const IDENTIFIER: &'static str = "LayerTree.replaySnapshot";
+        }
+        impl chromiumoxide_types::Method for ReplaySnapshotParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ReplaySnapshotParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Replays the layer snapshot and returns the resulting bitmap.\n[replaySnapshot](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-replaySnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReplaySnapshotReturns {
+            #[doc = "A data: URL for resulting image."]
+            #[serde(rename = "dataURL")]
+            pub data_url: String,
+        }
+        impl ReplaySnapshotReturns {
+            pub fn new(data_url: impl Into<String>) -> Self {
+                Self {
+                    data_url: data_url.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for ReplaySnapshotReturns {
+            fn from(url: T) -> Self {
+                ReplaySnapshotReturns::new(url)
+            }
+        }
+        impl ReplaySnapshotReturns {
+            pub fn builder() -> ReplaySnapshotReturnsBuilder {
+                ReplaySnapshotReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReplaySnapshotReturnsBuilder {
+            data_url: Option<String>,
+        }
+        impl ReplaySnapshotReturnsBuilder {
+            pub fn data_url(mut self, data_url: impl Into<String>) -> Self {
+                self.data_url = Some(data_url.into());
+                self
+            }
+            pub fn build(self) -> Result<ReplaySnapshotReturns, String> {
+                Ok(ReplaySnapshotReturns {
+                    data_url: self.data_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data_url))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for ReplaySnapshotParams {
+            type Response = ReplaySnapshotReturns;
+        }
+        #[doc = "Replays the layer snapshot and returns canvas log.\n[snapshotCommandLog](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-snapshotCommandLog)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SnapshotCommandLogParams {
+            #[doc = "The id of the layer snapshot."]
+            #[serde(rename = "snapshotId")]
+            pub snapshot_id: SnapshotId,
+        }
+        impl SnapshotCommandLogParams {
+            pub fn new(snapshot_id: impl Into<SnapshotId>) -> Self {
+                Self {
+                    snapshot_id: snapshot_id.into(),
+                }
+            }
+        }
+        impl SnapshotCommandLogParams {
+            pub fn builder() -> SnapshotCommandLogParamsBuilder {
+                SnapshotCommandLogParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SnapshotCommandLogParamsBuilder {
+            snapshot_id: Option<SnapshotId>,
+        }
+        impl SnapshotCommandLogParamsBuilder {
+            pub fn snapshot_id(mut self, snapshot_id: impl Into<SnapshotId>) -> Self {
+                self.snapshot_id = Some(snapshot_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SnapshotCommandLogParams, String> {
+                Ok(SnapshotCommandLogParams {
+                    snapshot_id: self.snapshot_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(snapshot_id))
+                    })?,
+                })
+            }
+        }
+        impl SnapshotCommandLogParams {
+            pub const IDENTIFIER: &'static str = "LayerTree.snapshotCommandLog";
+        }
+        impl chromiumoxide_types::Method for SnapshotCommandLogParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SnapshotCommandLogParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Replays the layer snapshot and returns canvas log.\n[snapshotCommandLog](https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/#method-snapshotCommandLog)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SnapshotCommandLogReturns {
+            #[doc = "The array of canvas function calls."]
+            #[serde(rename = "commandLog")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub command_log: Vec<serde_json::Value>,
+        }
+        impl SnapshotCommandLogReturns {
+            pub fn new(command_log: Vec<serde_json::Value>) -> Self {
+                Self { command_log }
+            }
+        }
+        impl SnapshotCommandLogReturns {
+            pub fn builder() -> SnapshotCommandLogReturnsBuilder {
+                SnapshotCommandLogReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SnapshotCommandLogReturnsBuilder {
+            command_log: Option<Vec<serde_json::Value>>,
+        }
+        impl SnapshotCommandLogReturnsBuilder {
+            pub fn command_log(mut self, command_log: impl Into<serde_json::Value>) -> Self {
+                let v = self.command_log.get_or_insert(Vec::new());
+                v.push(command_log.into());
+                self
+            }
+            pub fn command_logs<I, S>(mut self, command_logs: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<serde_json::Value>,
+            {
+                let v = self.command_log.get_or_insert(Vec::new());
+                for val in command_logs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SnapshotCommandLogReturns, String> {
+                Ok(SnapshotCommandLogReturns {
+                    command_log: self.command_log.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(command_log))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SnapshotCommandLogParams {
+            type Response = SnapshotCommandLogReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventLayerPainted {
+            #[doc = "The id of the painted layer."]
+            #[serde(rename = "layerId")]
+            pub layer_id: LayerId,
+            #[doc = "Clip rectangle."]
+            #[serde(rename = "clip")]
+            pub clip: super::dom::Rect,
+        }
+        impl EventLayerPainted {
+            pub const IDENTIFIER: &'static str = "LayerTree.layerPainted";
+        }
+        impl chromiumoxide_types::Method for EventLayerPainted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventLayerPainted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventLayerTreeDidChange {
+            #[doc = "Layer tree, absent if not in the compositing mode."]
+            #[serde(rename = "layers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub layers: Option<Vec<Layer>>,
+        }
+        impl EventLayerTreeDidChange {
+            pub const IDENTIFIER: &'static str = "LayerTree.layerTreeDidChange";
+        }
+        impl chromiumoxide_types::Method for EventLayerTreeDidChange {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventLayerTreeDidChange {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "Provides access to log entries."]
+    pub mod log {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Log entry.\n[LogEntry](https://chromedevtools.github.io/devtools-protocol/tot/Log/#type-LogEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LogEntry {
+            #[doc = "Log entry source."]
+            #[serde(rename = "source")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub source: LogEntrySource,
+            #[doc = "Log entry severity."]
+            #[serde(rename = "level")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub level: LogEntryLevel,
+            #[doc = "Logged text."]
+            #[serde(rename = "text")]
+            pub text: String,
+            #[serde(rename = "category")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub category: Option<LogEntryCategory>,
+            #[doc = "Timestamp when this entry was added."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: super::super::js_protocol::runtime::Timestamp,
+            #[doc = "URL of the resource if known."]
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[doc = "Line number in the resource."]
+            #[serde(rename = "lineNumber")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub line_number: Option<i64>,
+            #[doc = "JavaScript stack trace."]
+            #[serde(rename = "stackTrace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stack_trace: Option<super::super::js_protocol::runtime::StackTrace>,
+            #[doc = "Identifier of the network request associated with this entry."]
+            #[serde(rename = "networkRequestId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub network_request_id: Option<super::network::RequestId>,
+            #[doc = "Identifier of the worker associated with this entry."]
+            #[serde(rename = "workerId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub worker_id: Option<String>,
+            #[doc = "Call arguments."]
+            #[serde(rename = "args")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub args: Option<Vec<super::super::js_protocol::runtime::RemoteObject>>,
+        }
+        #[doc = "Log entry source."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum LogEntrySource {
+            #[serde(rename = "xml")]
+            Xml,
+            #[serde(rename = "javascript")]
+            Javascript,
+            #[serde(rename = "network")]
+            Network,
+            #[serde(rename = "storage")]
+            Storage,
+            #[serde(rename = "appcache")]
+            Appcache,
+            #[serde(rename = "rendering")]
+            Rendering,
+            #[serde(rename = "security")]
+            Security,
+            #[serde(rename = "deprecation")]
+            Deprecation,
+            #[serde(rename = "worker")]
+            Worker,
+            #[serde(rename = "violation")]
+            Violation,
+            #[serde(rename = "intervention")]
+            Intervention,
+            #[serde(rename = "recommendation")]
+            Recommendation,
+            #[serde(rename = "other")]
+            Other,
+        }
+        impl AsRef<str> for LogEntrySource {
+            fn as_ref(&self) -> &str {
+                match self {
+                    LogEntrySource::Xml => "xml",
+                    LogEntrySource::Javascript => "javascript",
+                    LogEntrySource::Network => "network",
+                    LogEntrySource::Storage => "storage",
+                    LogEntrySource::Appcache => "appcache",
+                    LogEntrySource::Rendering => "rendering",
+                    LogEntrySource::Security => "security",
+                    LogEntrySource::Deprecation => "deprecation",
+                    LogEntrySource::Worker => "worker",
+                    LogEntrySource::Violation => "violation",
+                    LogEntrySource::Intervention => "intervention",
+                    LogEntrySource::Recommendation => "recommendation",
+                    LogEntrySource::Other => "other",
+                }
+            }
+        }
+        impl ::std::str::FromStr for LogEntrySource {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "xml" | "Xml" => Ok(LogEntrySource::Xml),
+                    "javascript" | "Javascript" => Ok(LogEntrySource::Javascript),
+                    "network" | "Network" => Ok(LogEntrySource::Network),
+                    "storage" | "Storage" => Ok(LogEntrySource::Storage),
+                    "appcache" | "Appcache" => Ok(LogEntrySource::Appcache),
+                    "rendering" | "Rendering" => Ok(LogEntrySource::Rendering),
+                    "security" | "Security" => Ok(LogEntrySource::Security),
+                    "deprecation" | "Deprecation" => Ok(LogEntrySource::Deprecation),
+                    "worker" | "Worker" => Ok(LogEntrySource::Worker),
+                    "violation" | "Violation" => Ok(LogEntrySource::Violation),
+                    "intervention" | "Intervention" => Ok(LogEntrySource::Intervention),
+                    "recommendation" | "Recommendation" => Ok(LogEntrySource::Recommendation),
+                    "other" | "Other" => Ok(LogEntrySource::Other),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Log entry severity."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum LogEntryLevel {
+            #[serde(rename = "verbose")]
+            Verbose,
+            #[serde(rename = "info")]
+            Info,
+            #[serde(rename = "warning")]
+            Warning,
+            #[serde(rename = "error")]
+            Error,
+        }
+        impl AsRef<str> for LogEntryLevel {
+            fn as_ref(&self) -> &str {
+                match self {
+                    LogEntryLevel::Verbose => "verbose",
+                    LogEntryLevel::Info => "info",
+                    LogEntryLevel::Warning => "warning",
+                    LogEntryLevel::Error => "error",
+                }
+            }
+        }
+        impl ::std::str::FromStr for LogEntryLevel {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "verbose" | "Verbose" => Ok(LogEntryLevel::Verbose),
+                    "info" | "Info" => Ok(LogEntryLevel::Info),
+                    "warning" | "Warning" => Ok(LogEntryLevel::Warning),
+                    "error" | "Error" => Ok(LogEntryLevel::Error),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum LogEntryCategory {
+            #[serde(rename = "cors")]
+            Cors,
+        }
+        impl AsRef<str> for LogEntryCategory {
+            fn as_ref(&self) -> &str {
+                match self {
+                    LogEntryCategory::Cors => "cors",
+                }
+            }
+        }
+        impl ::std::str::FromStr for LogEntryCategory {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "cors" | "Cors" => Ok(LogEntryCategory::Cors),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl LogEntry {
+            pub fn new(
+                source: impl Into<LogEntrySource>,
+                level: impl Into<LogEntryLevel>,
+                text: impl Into<String>,
+                timestamp: impl Into<super::super::js_protocol::runtime::Timestamp>,
+            ) -> Self {
+                Self {
+                    source: source.into(),
+                    level: level.into(),
+                    text: text.into(),
+                    timestamp: timestamp.into(),
+                    category: None,
+                    url: None,
+                    line_number: None,
+                    stack_trace: None,
+                    network_request_id: None,
+                    worker_id: None,
+                    args: None,
+                }
+            }
+        }
+        impl LogEntry {
+            pub fn builder() -> LogEntryBuilder {
+                LogEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LogEntryBuilder {
+            source: Option<LogEntrySource>,
+            level: Option<LogEntryLevel>,
+            text: Option<String>,
+            category: Option<LogEntryCategory>,
+            timestamp: Option<super::super::js_protocol::runtime::Timestamp>,
+            url: Option<String>,
+            line_number: Option<i64>,
+            stack_trace: Option<super::super::js_protocol::runtime::StackTrace>,
+            network_request_id: Option<super::network::RequestId>,
+            worker_id: Option<String>,
+            args: Option<Vec<super::super::js_protocol::runtime::RemoteObject>>,
+        }
+        impl LogEntryBuilder {
+            pub fn source(mut self, source: impl Into<LogEntrySource>) -> Self {
+                self.source = Some(source.into());
+                self
+            }
+            pub fn level(mut self, level: impl Into<LogEntryLevel>) -> Self {
+                self.level = Some(level.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn category(mut self, category: impl Into<LogEntryCategory>) -> Self {
+                self.category = Some(category.into());
+                self
+            }
+            pub fn timestamp(
+                mut self,
+                timestamp: impl Into<super::super::js_protocol::runtime::Timestamp>,
+            ) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn stack_trace(
+                mut self,
+                stack_trace: impl Into<super::super::js_protocol::runtime::StackTrace>,
+            ) -> Self {
+                self.stack_trace = Some(stack_trace.into());
+                self
+            }
+            pub fn network_request_id(
+                mut self,
+                network_request_id: impl Into<super::network::RequestId>,
+            ) -> Self {
+                self.network_request_id = Some(network_request_id.into());
+                self
+            }
+            pub fn worker_id(mut self, worker_id: impl Into<String>) -> Self {
+                self.worker_id = Some(worker_id.into());
+                self
+            }
+            pub fn arg(
+                mut self,
+                arg: impl Into<super::super::js_protocol::runtime::RemoteObject>,
+            ) -> Self {
+                let v = self.args.get_or_insert(Vec::new());
+                v.push(arg.into());
+                self
+            }
+            pub fn args<I, S>(mut self, args: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::super::js_protocol::runtime::RemoteObject>,
+            {
+                let v = self.args.get_or_insert(Vec::new());
+                for val in args {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<LogEntry, String> {
+                Ok(LogEntry {
+                    source: self.source.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source))
+                    })?,
+                    level: self.level.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(level))
+                    })?,
+                    text: self.text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(text))
+                    })?,
+                    category: self.category,
+                    timestamp: self.timestamp.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(timestamp))
+                    })?,
+                    url: self.url,
+                    line_number: self.line_number,
+                    stack_trace: self.stack_trace,
+                    network_request_id: self.network_request_id,
+                    worker_id: self.worker_id,
+                    args: self.args,
+                })
+            }
+        }
+        impl LogEntry {
+            pub const IDENTIFIER: &'static str = "Log.LogEntry";
+        }
+        #[doc = "Violation configuration setting.\n[ViolationSetting](https://chromedevtools.github.io/devtools-protocol/tot/Log/#type-ViolationSetting)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ViolationSetting {
+            #[doc = "Violation type."]
+            #[serde(rename = "name")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub name: ViolationSettingName,
+            #[doc = "Time threshold to trigger upon."]
+            #[serde(rename = "threshold")]
+            pub threshold: f64,
+        }
+        #[doc = "Violation type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ViolationSettingName {
+            #[serde(rename = "longTask")]
+            LongTask,
+            #[serde(rename = "longLayout")]
+            LongLayout,
+            #[serde(rename = "blockedEvent")]
+            BlockedEvent,
+            #[serde(rename = "blockedParser")]
+            BlockedParser,
+            #[serde(rename = "discouragedAPIUse")]
+            DiscouragedApiUse,
+            #[serde(rename = "handler")]
+            Handler,
+            #[serde(rename = "recurringHandler")]
+            RecurringHandler,
+        }
+        impl AsRef<str> for ViolationSettingName {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ViolationSettingName::LongTask => "longTask",
+                    ViolationSettingName::LongLayout => "longLayout",
+                    ViolationSettingName::BlockedEvent => "blockedEvent",
+                    ViolationSettingName::BlockedParser => "blockedParser",
+                    ViolationSettingName::DiscouragedApiUse => "discouragedAPIUse",
+                    ViolationSettingName::Handler => "handler",
+                    ViolationSettingName::RecurringHandler => "recurringHandler",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ViolationSettingName {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "longTask" | "LongTask" | "longtask" => Ok(ViolationSettingName::LongTask),
+                    "longLayout" | "LongLayout" | "longlayout" => {
+                        Ok(ViolationSettingName::LongLayout)
+                    }
+                    "blockedEvent" | "BlockedEvent" | "blockedevent" => {
+                        Ok(ViolationSettingName::BlockedEvent)
+                    }
+                    "blockedParser" | "BlockedParser" | "blockedparser" => {
+                        Ok(ViolationSettingName::BlockedParser)
+                    }
+                    "discouragedAPIUse" | "DiscouragedApiUse" | "discouragedapiuse" => {
+                        Ok(ViolationSettingName::DiscouragedApiUse)
+                    }
+                    "handler" | "Handler" => Ok(ViolationSettingName::Handler),
+                    "recurringHandler" | "RecurringHandler" | "recurringhandler" => {
+                        Ok(ViolationSettingName::RecurringHandler)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl ViolationSetting {
+            pub fn new(name: impl Into<ViolationSettingName>, threshold: impl Into<f64>) -> Self {
+                Self {
+                    name: name.into(),
+                    threshold: threshold.into(),
+                }
+            }
+        }
+        impl ViolationSetting {
+            pub fn builder() -> ViolationSettingBuilder {
+                ViolationSettingBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ViolationSettingBuilder {
+            name: Option<ViolationSettingName>,
+            threshold: Option<f64>,
+        }
+        impl ViolationSettingBuilder {
+            pub fn name(mut self, name: impl Into<ViolationSettingName>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn threshold(mut self, threshold: impl Into<f64>) -> Self {
+                self.threshold = Some(threshold.into());
+                self
+            }
+            pub fn build(self) -> Result<ViolationSetting, String> {
+                Ok(ViolationSetting {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    threshold: self.threshold.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(threshold))
+                    })?,
+                })
+            }
+        }
+        impl ViolationSetting {
+            pub const IDENTIFIER: &'static str = "Log.ViolationSetting";
+        }
+        #[doc = "Clears the log.\n[clear](https://chromedevtools.github.io/devtools-protocol/tot/Log/#method-clear)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearParams {}
+        impl ClearParams {
+            pub const IDENTIFIER: &'static str = "Log.clear";
+        }
+        impl chromiumoxide_types::Method for ClearParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears the log.\n[clear](https://chromedevtools.github.io/devtools-protocol/tot/Log/#method-clear)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearReturns {}
+        impl chromiumoxide_types::Command for ClearParams {
+            type Response = ClearReturns;
+        }
+        #[doc = "Disables log domain, prevents further log entries from being reported to the client.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Log/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Log.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables log domain, prevents further log entries from being reported to the client.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Log/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables log domain, sends the entries collected so far to the client by means of the\n`entryAdded` notification.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Log/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Log.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables log domain, sends the entries collected so far to the client by means of the\n`entryAdded` notification.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Log/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "start violation reporting.\n[startViolationsReport](https://chromedevtools.github.io/devtools-protocol/tot/Log/#method-startViolationsReport)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StartViolationsReportParams {
+            #[doc = "Configuration for violations."]
+            #[serde(rename = "config")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub config: Vec<ViolationSetting>,
+        }
+        impl StartViolationsReportParams {
+            pub fn new(config: Vec<ViolationSetting>) -> Self {
+                Self { config }
+            }
+        }
+        impl StartViolationsReportParams {
+            pub fn builder() -> StartViolationsReportParamsBuilder {
+                StartViolationsReportParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartViolationsReportParamsBuilder {
+            config: Option<Vec<ViolationSetting>>,
+        }
+        impl StartViolationsReportParamsBuilder {
+            pub fn config(mut self, config: impl Into<ViolationSetting>) -> Self {
+                let v = self.config.get_or_insert(Vec::new());
+                v.push(config.into());
+                self
+            }
+            pub fn configs<I, S>(mut self, configs: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ViolationSetting>,
+            {
+                let v = self.config.get_or_insert(Vec::new());
+                for val in configs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<StartViolationsReportParams, String> {
+                Ok(StartViolationsReportParams {
+                    config: self.config.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(config))
+                    })?,
+                })
+            }
+        }
+        impl StartViolationsReportParams {
+            pub const IDENTIFIER: &'static str = "Log.startViolationsReport";
+        }
+        impl chromiumoxide_types::Method for StartViolationsReportParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartViolationsReportParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "start violation reporting.\n[startViolationsReport](https://chromedevtools.github.io/devtools-protocol/tot/Log/#method-startViolationsReport)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartViolationsReportReturns {}
+        impl chromiumoxide_types::Command for StartViolationsReportParams {
+            type Response = StartViolationsReportReturns;
+        }
+        #[doc = "Stop violation reporting.\n[stopViolationsReport](https://chromedevtools.github.io/devtools-protocol/tot/Log/#method-stopViolationsReport)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopViolationsReportParams {}
+        impl StopViolationsReportParams {
+            pub const IDENTIFIER: &'static str = "Log.stopViolationsReport";
+        }
+        impl chromiumoxide_types::Method for StopViolationsReportParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopViolationsReportParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Stop violation reporting.\n[stopViolationsReport](https://chromedevtools.github.io/devtools-protocol/tot/Log/#method-stopViolationsReport)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopViolationsReportReturns {}
+        impl chromiumoxide_types::Command for StopViolationsReportParams {
+            type Response = StopViolationsReportReturns;
+        }
+        #[doc = "Issued when new message was logged.\n[entryAdded](https://chromedevtools.github.io/devtools-protocol/tot/Log/#event-entryAdded)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventEntryAdded {
+            #[doc = "The entry."]
+            #[serde(rename = "entry")]
+            pub entry: LogEntry,
+        }
+        impl EventEntryAdded {
+            pub const IDENTIFIER: &'static str = "Log.entryAdded";
+        }
+        impl chromiumoxide_types::Method for EventEntryAdded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventEntryAdded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "This domain allows detailed inspection of media elements."]
+    pub mod media {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Players will get an ID that is unique within the agent context.\n[PlayerId](https://chromedevtools.github.io/devtools-protocol/tot/Media/#type-PlayerId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct PlayerId(String);
+        impl PlayerId {
+            pub fn new(val: impl Into<String>) -> Self {
+                PlayerId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for PlayerId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<PlayerId> for String {
+            fn from(el: PlayerId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for PlayerId {
+            fn from(expr: String) -> Self {
+                PlayerId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for PlayerId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl PlayerId {
+            pub const IDENTIFIER: &'static str = "Media.PlayerId";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct Timestamp(f64);
+        impl Timestamp {
+            pub fn new(val: impl Into<f64>) -> Self {
+                Timestamp(val.into())
+            }
+            pub fn inner(&self) -> &f64 {
+                &self.0
+            }
+        }
+        impl Timestamp {
+            pub const IDENTIFIER: &'static str = "Media.Timestamp";
+        }
+        #[doc = "Have one type per entry in MediaLogRecord::Type\nCorresponds to kMessage\n[PlayerMessage](https://chromedevtools.github.io/devtools-protocol/tot/Media/#type-PlayerMessage)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PlayerMessage {
+            #[doc = "Keep in sync with MediaLogMessageLevel\nWe are currently keeping the message level 'error' separate from the\nPlayerError type because right now they represent different things,\nthis one being a DVLOG(ERROR) style log message that gets printed\nbased on what log level is selected in the UI, and the other is a\nrepresentation of a media::PipelineStatus object. Soon however we're\ngoing to be moving away from using PipelineStatus for errors and\nintroducing a new error type which should hopefully let us integrate\nthe error log level into the PlayerError type."]
+            #[serde(rename = "level")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub level: PlayerMessageLevel,
+            #[serde(rename = "message")]
+            pub message: String,
+        }
+        #[doc = "Keep in sync with MediaLogMessageLevel\nWe are currently keeping the message level 'error' separate from the\nPlayerError type because right now they represent different things,\nthis one being a DVLOG(ERROR) style log message that gets printed\nbased on what log level is selected in the UI, and the other is a\nrepresentation of a media::PipelineStatus object. Soon however we're\ngoing to be moving away from using PipelineStatus for errors and\nintroducing a new error type which should hopefully let us integrate\nthe error log level into the PlayerError type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PlayerMessageLevel {
+            #[serde(rename = "error")]
+            Error,
+            #[serde(rename = "warning")]
+            Warning,
+            #[serde(rename = "info")]
+            Info,
+            #[serde(rename = "debug")]
+            Debug,
+        }
+        impl AsRef<str> for PlayerMessageLevel {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PlayerMessageLevel::Error => "error",
+                    PlayerMessageLevel::Warning => "warning",
+                    PlayerMessageLevel::Info => "info",
+                    PlayerMessageLevel::Debug => "debug",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PlayerMessageLevel {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "error" | "Error" => Ok(PlayerMessageLevel::Error),
+                    "warning" | "Warning" => Ok(PlayerMessageLevel::Warning),
+                    "info" | "Info" => Ok(PlayerMessageLevel::Info),
+                    "debug" | "Debug" => Ok(PlayerMessageLevel::Debug),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl PlayerMessage {
+            pub fn new(level: impl Into<PlayerMessageLevel>, message: impl Into<String>) -> Self {
+                Self {
+                    level: level.into(),
+                    message: message.into(),
+                }
+            }
+        }
+        impl PlayerMessage {
+            pub fn builder() -> PlayerMessageBuilder {
+                PlayerMessageBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PlayerMessageBuilder {
+            level: Option<PlayerMessageLevel>,
+            message: Option<String>,
+        }
+        impl PlayerMessageBuilder {
+            pub fn level(mut self, level: impl Into<PlayerMessageLevel>) -> Self {
+                self.level = Some(level.into());
+                self
+            }
+            pub fn message(mut self, message: impl Into<String>) -> Self {
+                self.message = Some(message.into());
+                self
+            }
+            pub fn build(self) -> Result<PlayerMessage, String> {
+                Ok(PlayerMessage {
+                    level: self.level.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(level))
+                    })?,
+                    message: self.message.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(message))
+                    })?,
+                })
+            }
+        }
+        impl PlayerMessage {
+            pub const IDENTIFIER: &'static str = "Media.PlayerMessage";
+        }
+        #[doc = "Corresponds to kMediaPropertyChange\n[PlayerProperty](https://chromedevtools.github.io/devtools-protocol/tot/Media/#type-PlayerProperty)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PlayerProperty {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl PlayerProperty {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl PlayerProperty {
+            pub fn builder() -> PlayerPropertyBuilder {
+                PlayerPropertyBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PlayerPropertyBuilder {
+            name: Option<String>,
+            value: Option<String>,
+        }
+        impl PlayerPropertyBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<PlayerProperty, String> {
+                Ok(PlayerProperty {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl PlayerProperty {
+            pub const IDENTIFIER: &'static str = "Media.PlayerProperty";
+        }
+        #[doc = "Corresponds to kMediaEventTriggered\n[PlayerEvent](https://chromedevtools.github.io/devtools-protocol/tot/Media/#type-PlayerEvent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PlayerEvent {
+            #[serde(rename = "timestamp")]
+            pub timestamp: Timestamp,
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl PlayerEvent {
+            pub fn new(timestamp: impl Into<Timestamp>, value: impl Into<String>) -> Self {
+                Self {
+                    timestamp: timestamp.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl PlayerEvent {
+            pub fn builder() -> PlayerEventBuilder {
+                PlayerEventBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PlayerEventBuilder {
+            timestamp: Option<Timestamp>,
+            value: Option<String>,
+        }
+        impl PlayerEventBuilder {
+            pub fn timestamp(mut self, timestamp: impl Into<Timestamp>) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<PlayerEvent, String> {
+                Ok(PlayerEvent {
+                    timestamp: self.timestamp.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(timestamp))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl PlayerEvent {
+            pub const IDENTIFIER: &'static str = "Media.PlayerEvent";
+        }
+        #[doc = "Represents logged source line numbers reported in an error.\nNOTE: file and line are from chromium c++ implementation code, not js.\n[PlayerErrorSourceLocation](https://chromedevtools.github.io/devtools-protocol/tot/Media/#type-PlayerErrorSourceLocation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PlayerErrorSourceLocation {
+            #[serde(rename = "file")]
+            pub file: String,
+            #[serde(rename = "line")]
+            pub line: i64,
+        }
+        impl PlayerErrorSourceLocation {
+            pub fn new(file: impl Into<String>, line: impl Into<i64>) -> Self {
+                Self {
+                    file: file.into(),
+                    line: line.into(),
+                }
+            }
+        }
+        impl PlayerErrorSourceLocation {
+            pub fn builder() -> PlayerErrorSourceLocationBuilder {
+                PlayerErrorSourceLocationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PlayerErrorSourceLocationBuilder {
+            file: Option<String>,
+            line: Option<i64>,
+        }
+        impl PlayerErrorSourceLocationBuilder {
+            pub fn file(mut self, file: impl Into<String>) -> Self {
+                self.file = Some(file.into());
+                self
+            }
+            pub fn line(mut self, line: impl Into<i64>) -> Self {
+                self.line = Some(line.into());
+                self
+            }
+            pub fn build(self) -> Result<PlayerErrorSourceLocation, String> {
+                Ok(PlayerErrorSourceLocation {
+                    file: self.file.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(file))
+                    })?,
+                    line: self.line.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line))
+                    })?,
+                })
+            }
+        }
+        impl PlayerErrorSourceLocation {
+            pub const IDENTIFIER: &'static str = "Media.PlayerErrorSourceLocation";
+        }
+        #[doc = "Corresponds to kMediaError\n[PlayerError](https://chromedevtools.github.io/devtools-protocol/tot/Media/#type-PlayerError)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PlayerError {
+            #[serde(rename = "errorType")]
+            pub error_type: String,
+            #[doc = "Code is the numeric enum entry for a specific set of error codes, such\nas PipelineStatusCodes in media/base/pipeline_status.h"]
+            #[serde(rename = "code")]
+            pub code: i64,
+            #[doc = "A trace of where this error was caused / where it passed through."]
+            #[serde(rename = "stack")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub stack: Vec<PlayerErrorSourceLocation>,
+            #[doc = "Errors potentially have a root cause error, ie, a DecoderError might be\ncaused by an WindowsError"]
+            #[serde(rename = "cause")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub cause: Vec<PlayerError>,
+            #[doc = "Extra data attached to an error, such as an HRESULT, Video Codec, etc."]
+            #[serde(rename = "data")]
+            pub data: serde_json::Value,
+        }
+        impl PlayerError {
+            pub fn builder() -> PlayerErrorBuilder {
+                PlayerErrorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PlayerErrorBuilder {
+            error_type: Option<String>,
+            code: Option<i64>,
+            stack: Option<Vec<PlayerErrorSourceLocation>>,
+            cause: Option<Vec<PlayerError>>,
+            data: Option<serde_json::Value>,
+        }
+        impl PlayerErrorBuilder {
+            pub fn error_type(mut self, error_type: impl Into<String>) -> Self {
+                self.error_type = Some(error_type.into());
+                self
+            }
+            pub fn code(mut self, code: impl Into<i64>) -> Self {
+                self.code = Some(code.into());
+                self
+            }
+            pub fn stack(mut self, stack: impl Into<PlayerErrorSourceLocation>) -> Self {
+                let v = self.stack.get_or_insert(Vec::new());
+                v.push(stack.into());
+                self
+            }
+            pub fn stacks<I, S>(mut self, stacks: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PlayerErrorSourceLocation>,
+            {
+                let v = self.stack.get_or_insert(Vec::new());
+                for val in stacks {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn cause(mut self, cause: impl Into<PlayerError>) -> Self {
+                let v = self.cause.get_or_insert(Vec::new());
+                v.push(cause.into());
+                self
+            }
+            pub fn causes<I, S>(mut self, causes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PlayerError>,
+            {
+                let v = self.cause.get_or_insert(Vec::new());
+                for val in causes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn data(mut self, data: impl Into<serde_json::Value>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn build(self) -> Result<PlayerError, String> {
+                Ok(PlayerError {
+                    error_type: self.error_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(error_type))
+                    })?,
+                    code: self.code.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(code))
+                    })?,
+                    stack: self.stack.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(stack))
+                    })?,
+                    cause: self.cause.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cause))
+                    })?,
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                })
+            }
+        }
+        impl PlayerError {
+            pub const IDENTIFIER: &'static str = "Media.PlayerError";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Player {
+            #[serde(rename = "playerId")]
+            pub player_id: PlayerId,
+            #[serde(rename = "domNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub dom_node_id: Option<super::dom::BackendNodeId>,
+        }
+        impl Player {
+            pub fn new(player_id: impl Into<PlayerId>) -> Self {
+                Self {
+                    player_id: player_id.into(),
+                    dom_node_id: None,
+                }
+            }
+        }
+        impl Player {
+            pub fn builder() -> PlayerBuilder {
+                PlayerBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PlayerBuilder {
+            player_id: Option<PlayerId>,
+            dom_node_id: Option<super::dom::BackendNodeId>,
+        }
+        impl PlayerBuilder {
+            pub fn player_id(mut self, player_id: impl Into<PlayerId>) -> Self {
+                self.player_id = Some(player_id.into());
+                self
+            }
+            pub fn dom_node_id(
+                mut self,
+                dom_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.dom_node_id = Some(dom_node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<Player, String> {
+                Ok(Player {
+                    player_id: self.player_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(player_id))
+                    })?,
+                    dom_node_id: self.dom_node_id,
+                })
+            }
+        }
+        impl Player {
+            pub const IDENTIFIER: &'static str = "Media.Player";
+        }
+        #[doc = "Enables the Media domain\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Media/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Media.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables the Media domain\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Media/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Disables the Media domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Media/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Media.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables the Media domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Media/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "This can be called multiple times, and can be used to set / override /\nremove player properties. A null propValue indicates removal.\n[playerPropertiesChanged](https://chromedevtools.github.io/devtools-protocol/tot/Media/#event-playerPropertiesChanged)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPlayerPropertiesChanged {
+            #[serde(rename = "playerId")]
+            pub player_id: PlayerId,
+            #[serde(rename = "properties")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub properties: Vec<PlayerProperty>,
+        }
+        impl EventPlayerPropertiesChanged {
+            pub const IDENTIFIER: &'static str = "Media.playerPropertiesChanged";
+        }
+        impl chromiumoxide_types::Method for EventPlayerPropertiesChanged {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPlayerPropertiesChanged {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Send events as a list, allowing them to be batched on the browser for less\ncongestion. If batched, events must ALWAYS be in chronological order.\n[playerEventsAdded](https://chromedevtools.github.io/devtools-protocol/tot/Media/#event-playerEventsAdded)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPlayerEventsAdded {
+            #[serde(rename = "playerId")]
+            pub player_id: PlayerId,
+            #[serde(rename = "events")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub events: Vec<PlayerEvent>,
+        }
+        impl EventPlayerEventsAdded {
+            pub const IDENTIFIER: &'static str = "Media.playerEventsAdded";
+        }
+        impl chromiumoxide_types::Method for EventPlayerEventsAdded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPlayerEventsAdded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Send a list of any messages that need to be delivered.\n[playerMessagesLogged](https://chromedevtools.github.io/devtools-protocol/tot/Media/#event-playerMessagesLogged)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPlayerMessagesLogged {
+            #[serde(rename = "playerId")]
+            pub player_id: PlayerId,
+            #[serde(rename = "messages")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub messages: Vec<PlayerMessage>,
+        }
+        impl EventPlayerMessagesLogged {
+            pub const IDENTIFIER: &'static str = "Media.playerMessagesLogged";
+        }
+        impl chromiumoxide_types::Method for EventPlayerMessagesLogged {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPlayerMessagesLogged {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Send a list of any errors that need to be delivered.\n[playerErrorsRaised](https://chromedevtools.github.io/devtools-protocol/tot/Media/#event-playerErrorsRaised)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPlayerErrorsRaised {
+            #[serde(rename = "playerId")]
+            pub player_id: PlayerId,
+            #[serde(rename = "errors")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub errors: Vec<PlayerError>,
+        }
+        impl EventPlayerErrorsRaised {
+            pub const IDENTIFIER: &'static str = "Media.playerErrorsRaised";
+        }
+        impl chromiumoxide_types::Method for EventPlayerErrorsRaised {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPlayerErrorsRaised {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Called whenever a player is created, or when a new agent joins and receives\na list of active players. If an agent is restored, it will receive one\nevent for each active player.\n[playerCreated](https://chromedevtools.github.io/devtools-protocol/tot/Media/#event-playerCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPlayerCreated {
+            #[serde(rename = "player")]
+            pub player: Player,
+        }
+        impl EventPlayerCreated {
+            pub const IDENTIFIER: &'static str = "Media.playerCreated";
+        }
+        impl chromiumoxide_types::Method for EventPlayerCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPlayerCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod memory {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Memory pressure level."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PressureLevel {
+            #[serde(rename = "moderate")]
+            Moderate,
+            #[serde(rename = "critical")]
+            Critical,
+        }
+        impl AsRef<str> for PressureLevel {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PressureLevel::Moderate => "moderate",
+                    PressureLevel::Critical => "critical",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PressureLevel {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "moderate" | "Moderate" => Ok(PressureLevel::Moderate),
+                    "critical" | "Critical" => Ok(PressureLevel::Critical),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Heap profile sample.\n[SamplingProfileNode](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#type-SamplingProfileNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SamplingProfileNode {
+            #[doc = "Size of the sampled allocation."]
+            #[serde(rename = "size")]
+            pub size: f64,
+            #[doc = "Total bytes attributed to this sample."]
+            #[serde(rename = "total")]
+            pub total: f64,
+            #[doc = "Execution stack at the point of allocation."]
+            #[serde(rename = "stack")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub stack: Vec<String>,
+        }
+        impl SamplingProfileNode {
+            pub fn new(size: impl Into<f64>, total: impl Into<f64>, stack: Vec<String>) -> Self {
+                Self {
+                    size: size.into(),
+                    total: total.into(),
+                    stack,
+                }
+            }
+        }
+        impl SamplingProfileNode {
+            pub fn builder() -> SamplingProfileNodeBuilder {
+                SamplingProfileNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SamplingProfileNodeBuilder {
+            size: Option<f64>,
+            total: Option<f64>,
+            stack: Option<Vec<String>>,
+        }
+        impl SamplingProfileNodeBuilder {
+            pub fn size(mut self, size: impl Into<f64>) -> Self {
+                self.size = Some(size.into());
+                self
+            }
+            pub fn total(mut self, total: impl Into<f64>) -> Self {
+                self.total = Some(total.into());
+                self
+            }
+            pub fn stack(mut self, stack: impl Into<String>) -> Self {
+                let v = self.stack.get_or_insert(Vec::new());
+                v.push(stack.into());
+                self
+            }
+            pub fn stacks<I, S>(mut self, stacks: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.stack.get_or_insert(Vec::new());
+                for val in stacks {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SamplingProfileNode, String> {
+                Ok(SamplingProfileNode {
+                    size: self.size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(size))
+                    })?,
+                    total: self.total.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(total))
+                    })?,
+                    stack: self.stack.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(stack))
+                    })?,
+                })
+            }
+        }
+        impl SamplingProfileNode {
+            pub const IDENTIFIER: &'static str = "Memory.SamplingProfileNode";
+        }
+        #[doc = "Array of heap profile samples.\n[SamplingProfile](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#type-SamplingProfile)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SamplingProfile {
+            #[serde(rename = "samples")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub samples: Vec<SamplingProfileNode>,
+            #[serde(rename = "modules")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub modules: Vec<Module>,
+        }
+        impl SamplingProfile {
+            pub fn new(samples: Vec<SamplingProfileNode>, modules: Vec<Module>) -> Self {
+                Self { samples, modules }
+            }
+        }
+        impl SamplingProfile {
+            pub fn builder() -> SamplingProfileBuilder {
+                SamplingProfileBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SamplingProfileBuilder {
+            samples: Option<Vec<SamplingProfileNode>>,
+            modules: Option<Vec<Module>>,
+        }
+        impl SamplingProfileBuilder {
+            pub fn sample(mut self, sample: impl Into<SamplingProfileNode>) -> Self {
+                let v = self.samples.get_or_insert(Vec::new());
+                v.push(sample.into());
+                self
+            }
+            pub fn samples<I, S>(mut self, samples: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SamplingProfileNode>,
+            {
+                let v = self.samples.get_or_insert(Vec::new());
+                for val in samples {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn module(mut self, module: impl Into<Module>) -> Self {
+                let v = self.modules.get_or_insert(Vec::new());
+                v.push(module.into());
+                self
+            }
+            pub fn modules<I, S>(mut self, modules: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Module>,
+            {
+                let v = self.modules.get_or_insert(Vec::new());
+                for val in modules {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SamplingProfile, String> {
+                Ok(SamplingProfile {
+                    samples: self.samples.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(samples))
+                    })?,
+                    modules: self.modules.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(modules))
+                    })?,
+                })
+            }
+        }
+        impl SamplingProfile {
+            pub const IDENTIFIER: &'static str = "Memory.SamplingProfile";
+        }
+        #[doc = "Executable module information\n[Module](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#type-Module)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Module {
+            #[doc = "Name of the module."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "UUID of the module."]
+            #[serde(rename = "uuid")]
+            pub uuid: String,
+            #[doc = "Base address where the module is loaded into memory. Encoded as a decimal\nor hexadecimal (0x prefixed) string."]
+            #[serde(rename = "baseAddress")]
+            pub base_address: String,
+            #[doc = "Size of the module in bytes."]
+            #[serde(rename = "size")]
+            pub size: f64,
+        }
+        impl Module {
+            pub fn new(
+                name: impl Into<String>,
+                uuid: impl Into<String>,
+                base_address: impl Into<String>,
+                size: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    name: name.into(),
+                    uuid: uuid.into(),
+                    base_address: base_address.into(),
+                    size: size.into(),
+                }
+            }
+        }
+        impl Module {
+            pub fn builder() -> ModuleBuilder {
+                ModuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ModuleBuilder {
+            name: Option<String>,
+            uuid: Option<String>,
+            base_address: Option<String>,
+            size: Option<f64>,
+        }
+        impl ModuleBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn uuid(mut self, uuid: impl Into<String>) -> Self {
+                self.uuid = Some(uuid.into());
+                self
+            }
+            pub fn base_address(mut self, base_address: impl Into<String>) -> Self {
+                self.base_address = Some(base_address.into());
+                self
+            }
+            pub fn size(mut self, size: impl Into<f64>) -> Self {
+                self.size = Some(size.into());
+                self
+            }
+            pub fn build(self) -> Result<Module, String> {
+                Ok(Module {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    uuid: self.uuid.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(uuid))
+                    })?,
+                    base_address: self.base_address.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(base_address))
+                    })?,
+                    size: self.size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(size))
+                    })?,
+                })
+            }
+        }
+        impl Module {
+            pub const IDENTIFIER: &'static str = "Memory.Module";
+        }
+        #[doc = "DOM object counter data.\n[DOMCounter](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#type-DOMCounter)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DomCounter {
+            #[doc = "Object name. Note: object names should be presumed volatile and clients should not expect\nthe returned names to be consistent across runs."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Object count."]
+            #[serde(rename = "count")]
+            pub count: i64,
+        }
+        impl DomCounter {
+            pub fn new(name: impl Into<String>, count: impl Into<i64>) -> Self {
+                Self {
+                    name: name.into(),
+                    count: count.into(),
+                }
+            }
+        }
+        impl DomCounter {
+            pub fn builder() -> DomCounterBuilder {
+                DomCounterBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DomCounterBuilder {
+            name: Option<String>,
+            count: Option<i64>,
+        }
+        impl DomCounterBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn count(mut self, count: impl Into<i64>) -> Self {
+                self.count = Some(count.into());
+                self
+            }
+            pub fn build(self) -> Result<DomCounter, String> {
+                Ok(DomCounter {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    count: self.count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(count))
+                    })?,
+                })
+            }
+        }
+        impl DomCounter {
+            pub const IDENTIFIER: &'static str = "Memory.DOMCounter";
+        }
+        #[doc = "Retruns current DOM object counters.\n[getDOMCounters](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-getDOMCounters)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetDomCountersParams {}
+        impl GetDomCountersParams {
+            pub const IDENTIFIER: &'static str = "Memory.getDOMCounters";
+        }
+        impl chromiumoxide_types::Method for GetDomCountersParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetDomCountersParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Retruns current DOM object counters.\n[getDOMCounters](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-getDOMCounters)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetDomCountersReturns {
+            #[serde(rename = "documents")]
+            pub documents: i64,
+            #[serde(rename = "nodes")]
+            pub nodes: i64,
+            #[serde(rename = "jsEventListeners")]
+            pub js_event_listeners: i64,
+        }
+        impl GetDomCountersReturns {
+            pub fn new(
+                documents: impl Into<i64>,
+                nodes: impl Into<i64>,
+                js_event_listeners: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    documents: documents.into(),
+                    nodes: nodes.into(),
+                    js_event_listeners: js_event_listeners.into(),
+                }
+            }
+        }
+        impl GetDomCountersReturns {
+            pub fn builder() -> GetDomCountersReturnsBuilder {
+                GetDomCountersReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDomCountersReturnsBuilder {
+            documents: Option<i64>,
+            nodes: Option<i64>,
+            js_event_listeners: Option<i64>,
+        }
+        impl GetDomCountersReturnsBuilder {
+            pub fn documents(mut self, documents: impl Into<i64>) -> Self {
+                self.documents = Some(documents.into());
+                self
+            }
+            pub fn nodes(mut self, nodes: impl Into<i64>) -> Self {
+                self.nodes = Some(nodes.into());
+                self
+            }
+            pub fn js_event_listeners(mut self, js_event_listeners: impl Into<i64>) -> Self {
+                self.js_event_listeners = Some(js_event_listeners.into());
+                self
+            }
+            pub fn build(self) -> Result<GetDomCountersReturns, String> {
+                Ok(GetDomCountersReturns {
+                    documents: self.documents.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(documents))
+                    })?,
+                    nodes: self.nodes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(nodes))
+                    })?,
+                    js_event_listeners: self.js_event_listeners.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(js_event_listeners)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetDomCountersParams {
+            type Response = GetDomCountersReturns;
+        }
+        #[doc = "Retruns DOM object counters after preparing renderer for leak detection.\n[getDOMCountersForLeakDetection](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-getDOMCountersForLeakDetection)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetDomCountersForLeakDetectionParams {}
+        impl GetDomCountersForLeakDetectionParams {
+            pub const IDENTIFIER: &'static str = "Memory.getDOMCountersForLeakDetection";
+        }
+        impl chromiumoxide_types::Method for GetDomCountersForLeakDetectionParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetDomCountersForLeakDetectionParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Retruns DOM object counters after preparing renderer for leak detection.\n[getDOMCountersForLeakDetection](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-getDOMCountersForLeakDetection)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetDomCountersForLeakDetectionReturns {
+            #[doc = "DOM object counters."]
+            #[serde(rename = "counters")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub counters: Vec<DomCounter>,
+        }
+        impl GetDomCountersForLeakDetectionReturns {
+            pub fn new(counters: Vec<DomCounter>) -> Self {
+                Self { counters }
+            }
+        }
+        impl GetDomCountersForLeakDetectionReturns {
+            pub fn builder() -> GetDomCountersForLeakDetectionReturnsBuilder {
+                GetDomCountersForLeakDetectionReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDomCountersForLeakDetectionReturnsBuilder {
+            counters: Option<Vec<DomCounter>>,
+        }
+        impl GetDomCountersForLeakDetectionReturnsBuilder {
+            pub fn counter(mut self, counter: impl Into<DomCounter>) -> Self {
+                let v = self.counters.get_or_insert(Vec::new());
+                v.push(counter.into());
+                self
+            }
+            pub fn counters<I, S>(mut self, counters: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<DomCounter>,
+            {
+                let v = self.counters.get_or_insert(Vec::new());
+                for val in counters {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetDomCountersForLeakDetectionReturns, String> {
+                Ok(GetDomCountersForLeakDetectionReturns {
+                    counters: self.counters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(counters))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetDomCountersForLeakDetectionParams {
+            type Response = GetDomCountersForLeakDetectionReturns;
+        }
+        #[doc = "Prepares for leak detection by terminating workers, stopping spellcheckers,\ndropping non-essential internal caches, running garbage collections, etc.\n[prepareForLeakDetection](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-prepareForLeakDetection)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct PrepareForLeakDetectionParams {}
+        impl PrepareForLeakDetectionParams {
+            pub const IDENTIFIER: &'static str = "Memory.prepareForLeakDetection";
+        }
+        impl chromiumoxide_types::Method for PrepareForLeakDetectionParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for PrepareForLeakDetectionParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Prepares for leak detection by terminating workers, stopping spellcheckers,\ndropping non-essential internal caches, running garbage collections, etc.\n[prepareForLeakDetection](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-prepareForLeakDetection)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct PrepareForLeakDetectionReturns {}
+        impl chromiumoxide_types::Command for PrepareForLeakDetectionParams {
+            type Response = PrepareForLeakDetectionReturns;
+        }
+        #[doc = "Simulate OomIntervention by purging V8 memory.\n[forciblyPurgeJavaScriptMemory](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-forciblyPurgeJavaScriptMemory)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ForciblyPurgeJavaScriptMemoryParams {}
+        impl ForciblyPurgeJavaScriptMemoryParams {
+            pub const IDENTIFIER: &'static str = "Memory.forciblyPurgeJavaScriptMemory";
+        }
+        impl chromiumoxide_types::Method for ForciblyPurgeJavaScriptMemoryParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ForciblyPurgeJavaScriptMemoryParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Simulate OomIntervention by purging V8 memory.\n[forciblyPurgeJavaScriptMemory](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-forciblyPurgeJavaScriptMemory)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ForciblyPurgeJavaScriptMemoryReturns {}
+        impl chromiumoxide_types::Command for ForciblyPurgeJavaScriptMemoryParams {
+            type Response = ForciblyPurgeJavaScriptMemoryReturns;
+        }
+        #[doc = "Enable/disable suppressing memory pressure notifications in all processes.\n[setPressureNotificationsSuppressed](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-setPressureNotificationsSuppressed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPressureNotificationsSuppressedParams {
+            #[doc = "If true, memory pressure notifications will be suppressed."]
+            #[serde(rename = "suppressed")]
+            pub suppressed: bool,
+        }
+        impl SetPressureNotificationsSuppressedParams {
+            pub fn new(suppressed: impl Into<bool>) -> Self {
+                Self {
+                    suppressed: suppressed.into(),
+                }
+            }
+        }
+        impl SetPressureNotificationsSuppressedParams {
+            pub fn builder() -> SetPressureNotificationsSuppressedParamsBuilder {
+                SetPressureNotificationsSuppressedParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPressureNotificationsSuppressedParamsBuilder {
+            suppressed: Option<bool>,
+        }
+        impl SetPressureNotificationsSuppressedParamsBuilder {
+            pub fn suppressed(mut self, suppressed: impl Into<bool>) -> Self {
+                self.suppressed = Some(suppressed.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPressureNotificationsSuppressedParams, String> {
+                Ok(SetPressureNotificationsSuppressedParams {
+                    suppressed: self.suppressed.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(suppressed))
+                    })?,
+                })
+            }
+        }
+        impl SetPressureNotificationsSuppressedParams {
+            pub const IDENTIFIER: &'static str = "Memory.setPressureNotificationsSuppressed";
+        }
+        impl chromiumoxide_types::Method for SetPressureNotificationsSuppressedParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPressureNotificationsSuppressedParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enable/disable suppressing memory pressure notifications in all processes.\n[setPressureNotificationsSuppressed](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-setPressureNotificationsSuppressed)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPressureNotificationsSuppressedReturns {}
+        impl chromiumoxide_types::Command for SetPressureNotificationsSuppressedParams {
+            type Response = SetPressureNotificationsSuppressedReturns;
+        }
+        #[doc = "Simulate a memory pressure notification in all processes.\n[simulatePressureNotification](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-simulatePressureNotification)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SimulatePressureNotificationParams {
+            #[doc = "Memory pressure level of the notification."]
+            #[serde(rename = "level")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub level: PressureLevel,
+        }
+        impl SimulatePressureNotificationParams {
+            pub fn new(level: impl Into<PressureLevel>) -> Self {
+                Self {
+                    level: level.into(),
+                }
+            }
+        }
+        impl SimulatePressureNotificationParams {
+            pub fn builder() -> SimulatePressureNotificationParamsBuilder {
+                SimulatePressureNotificationParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SimulatePressureNotificationParamsBuilder {
+            level: Option<PressureLevel>,
+        }
+        impl SimulatePressureNotificationParamsBuilder {
+            pub fn level(mut self, level: impl Into<PressureLevel>) -> Self {
+                self.level = Some(level.into());
+                self
+            }
+            pub fn build(self) -> Result<SimulatePressureNotificationParams, String> {
+                Ok(SimulatePressureNotificationParams {
+                    level: self.level.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(level))
+                    })?,
+                })
+            }
+        }
+        impl SimulatePressureNotificationParams {
+            pub const IDENTIFIER: &'static str = "Memory.simulatePressureNotification";
+        }
+        impl chromiumoxide_types::Method for SimulatePressureNotificationParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SimulatePressureNotificationParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Simulate a memory pressure notification in all processes.\n[simulatePressureNotification](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-simulatePressureNotification)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SimulatePressureNotificationReturns {}
+        impl chromiumoxide_types::Command for SimulatePressureNotificationParams {
+            type Response = SimulatePressureNotificationReturns;
+        }
+        #[doc = "Start collecting native memory profile.\n[startSampling](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-startSampling)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartSamplingParams {
+            #[doc = "Average number of bytes between samples."]
+            #[serde(rename = "samplingInterval")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub sampling_interval: Option<i64>,
+            #[doc = "Do not randomize intervals between samples."]
+            #[serde(rename = "suppressRandomness")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub suppress_randomness: Option<bool>,
+        }
+        impl StartSamplingParams {
+            pub fn builder() -> StartSamplingParamsBuilder {
+                StartSamplingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartSamplingParamsBuilder {
+            sampling_interval: Option<i64>,
+            suppress_randomness: Option<bool>,
+        }
+        impl StartSamplingParamsBuilder {
+            pub fn sampling_interval(mut self, sampling_interval: impl Into<i64>) -> Self {
+                self.sampling_interval = Some(sampling_interval.into());
+                self
+            }
+            pub fn suppress_randomness(mut self, suppress_randomness: impl Into<bool>) -> Self {
+                self.suppress_randomness = Some(suppress_randomness.into());
+                self
+            }
+            pub fn build(self) -> StartSamplingParams {
+                StartSamplingParams {
+                    sampling_interval: self.sampling_interval,
+                    suppress_randomness: self.suppress_randomness,
+                }
+            }
+        }
+        impl StartSamplingParams {
+            pub const IDENTIFIER: &'static str = "Memory.startSampling";
+        }
+        impl chromiumoxide_types::Method for StartSamplingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartSamplingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Start collecting native memory profile.\n[startSampling](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-startSampling)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartSamplingReturns {}
+        impl chromiumoxide_types::Command for StartSamplingParams {
+            type Response = StartSamplingReturns;
+        }
+        #[doc = "Stop collecting native memory profile.\n[stopSampling](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-stopSampling)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopSamplingParams {}
+        impl StopSamplingParams {
+            pub const IDENTIFIER: &'static str = "Memory.stopSampling";
+        }
+        impl chromiumoxide_types::Method for StopSamplingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopSamplingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Stop collecting native memory profile.\n[stopSampling](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-stopSampling)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopSamplingReturns {}
+        impl chromiumoxide_types::Command for StopSamplingParams {
+            type Response = StopSamplingReturns;
+        }
+        #[doc = "Retrieve native memory allocations profile\ncollected since renderer process startup.\n[getAllTimeSamplingProfile](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-getAllTimeSamplingProfile)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetAllTimeSamplingProfileParams {}
+        impl GetAllTimeSamplingProfileParams {
+            pub const IDENTIFIER: &'static str = "Memory.getAllTimeSamplingProfile";
+        }
+        impl chromiumoxide_types::Method for GetAllTimeSamplingProfileParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetAllTimeSamplingProfileParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Retrieve native memory allocations profile\ncollected since renderer process startup.\n[getAllTimeSamplingProfile](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-getAllTimeSamplingProfile)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAllTimeSamplingProfileReturns {
+            #[serde(rename = "profile")]
+            pub profile: SamplingProfile,
+        }
+        impl GetAllTimeSamplingProfileReturns {
+            pub fn new(profile: impl Into<SamplingProfile>) -> Self {
+                Self {
+                    profile: profile.into(),
+                }
+            }
+        }
+        impl GetAllTimeSamplingProfileReturns {
+            pub fn builder() -> GetAllTimeSamplingProfileReturnsBuilder {
+                GetAllTimeSamplingProfileReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAllTimeSamplingProfileReturnsBuilder {
+            profile: Option<SamplingProfile>,
+        }
+        impl GetAllTimeSamplingProfileReturnsBuilder {
+            pub fn profile(mut self, profile: impl Into<SamplingProfile>) -> Self {
+                self.profile = Some(profile.into());
+                self
+            }
+            pub fn build(self) -> Result<GetAllTimeSamplingProfileReturns, String> {
+                Ok(GetAllTimeSamplingProfileReturns {
+                    profile: self.profile.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(profile))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetAllTimeSamplingProfileParams {
+            type Response = GetAllTimeSamplingProfileReturns;
+        }
+        #[doc = "Retrieve native memory allocations profile\ncollected since browser process startup.\n[getBrowserSamplingProfile](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-getBrowserSamplingProfile)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetBrowserSamplingProfileParams {}
+        impl GetBrowserSamplingProfileParams {
+            pub const IDENTIFIER: &'static str = "Memory.getBrowserSamplingProfile";
+        }
+        impl chromiumoxide_types::Method for GetBrowserSamplingProfileParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetBrowserSamplingProfileParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Retrieve native memory allocations profile\ncollected since browser process startup.\n[getBrowserSamplingProfile](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-getBrowserSamplingProfile)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetBrowserSamplingProfileReturns {
+            #[serde(rename = "profile")]
+            pub profile: SamplingProfile,
+        }
+        impl GetBrowserSamplingProfileReturns {
+            pub fn new(profile: impl Into<SamplingProfile>) -> Self {
+                Self {
+                    profile: profile.into(),
+                }
+            }
+        }
+        impl GetBrowserSamplingProfileReturns {
+            pub fn builder() -> GetBrowserSamplingProfileReturnsBuilder {
+                GetBrowserSamplingProfileReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetBrowserSamplingProfileReturnsBuilder {
+            profile: Option<SamplingProfile>,
+        }
+        impl GetBrowserSamplingProfileReturnsBuilder {
+            pub fn profile(mut self, profile: impl Into<SamplingProfile>) -> Self {
+                self.profile = Some(profile.into());
+                self
+            }
+            pub fn build(self) -> Result<GetBrowserSamplingProfileReturns, String> {
+                Ok(GetBrowserSamplingProfileReturns {
+                    profile: self.profile.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(profile))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetBrowserSamplingProfileParams {
+            type Response = GetBrowserSamplingProfileReturns;
+        }
+        #[doc = "Retrieve native memory allocations profile collected since last\n`startSampling` call.\n[getSamplingProfile](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-getSamplingProfile)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetSamplingProfileParams {}
+        impl GetSamplingProfileParams {
+            pub const IDENTIFIER: &'static str = "Memory.getSamplingProfile";
+        }
+        impl chromiumoxide_types::Method for GetSamplingProfileParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetSamplingProfileParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Retrieve native memory allocations profile collected since last\n`startSampling` call.\n[getSamplingProfile](https://chromedevtools.github.io/devtools-protocol/tot/Memory/#method-getSamplingProfile)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSamplingProfileReturns {
+            #[serde(rename = "profile")]
+            pub profile: SamplingProfile,
+        }
+        impl GetSamplingProfileReturns {
+            pub fn new(profile: impl Into<SamplingProfile>) -> Self {
+                Self {
+                    profile: profile.into(),
+                }
+            }
+        }
+        impl GetSamplingProfileReturns {
+            pub fn builder() -> GetSamplingProfileReturnsBuilder {
+                GetSamplingProfileReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSamplingProfileReturnsBuilder {
+            profile: Option<SamplingProfile>,
+        }
+        impl GetSamplingProfileReturnsBuilder {
+            pub fn profile(mut self, profile: impl Into<SamplingProfile>) -> Self {
+                self.profile = Some(profile.into());
+                self
+            }
+            pub fn build(self) -> Result<GetSamplingProfileReturns, String> {
+                Ok(GetSamplingProfileReturns {
+                    profile: self.profile.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(profile))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetSamplingProfileParams {
+            type Response = GetSamplingProfileReturns;
+        }
+    }
+    #[doc = "Network domain allows tracking network activities of the page. It exposes information about http,\nfile, data and other requests and responses, their headers, bodies, timing, etc."]
+    pub mod network {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Resource type as it was perceived by the rendering engine."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ResourceType {
+            #[serde(rename = "Document")]
+            Document,
+            #[serde(rename = "Stylesheet")]
+            Stylesheet,
+            #[serde(rename = "Image")]
+            Image,
+            #[serde(rename = "Media")]
+            Media,
+            #[serde(rename = "Font")]
+            Font,
+            #[serde(rename = "Script")]
+            Script,
+            #[serde(rename = "TextTrack")]
+            TextTrack,
+            #[serde(rename = "XHR")]
+            Xhr,
+            #[serde(rename = "Fetch")]
+            Fetch,
+            #[serde(rename = "Prefetch")]
+            Prefetch,
+            #[serde(rename = "EventSource")]
+            EventSource,
+            #[serde(rename = "WebSocket")]
+            WebSocket,
+            #[serde(rename = "Manifest")]
+            Manifest,
+            #[serde(rename = "SignedExchange")]
+            SignedExchange,
+            #[serde(rename = "Ping")]
+            Ping,
+            #[serde(rename = "CSPViolationReport")]
+            CspViolationReport,
+            #[serde(rename = "Preflight")]
+            Preflight,
+            #[serde(rename = "FedCM")]
+            FedCm,
+            #[serde(rename = "Other")]
+            Other,
+        }
+        impl AsRef<str> for ResourceType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ResourceType::Document => "Document",
+                    ResourceType::Stylesheet => "Stylesheet",
+                    ResourceType::Image => "Image",
+                    ResourceType::Media => "Media",
+                    ResourceType::Font => "Font",
+                    ResourceType::Script => "Script",
+                    ResourceType::TextTrack => "TextTrack",
+                    ResourceType::Xhr => "XHR",
+                    ResourceType::Fetch => "Fetch",
+                    ResourceType::Prefetch => "Prefetch",
+                    ResourceType::EventSource => "EventSource",
+                    ResourceType::WebSocket => "WebSocket",
+                    ResourceType::Manifest => "Manifest",
+                    ResourceType::SignedExchange => "SignedExchange",
+                    ResourceType::Ping => "Ping",
+                    ResourceType::CspViolationReport => "CSPViolationReport",
+                    ResourceType::Preflight => "Preflight",
+                    ResourceType::FedCm => "FedCM",
+                    ResourceType::Other => "Other",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ResourceType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Document" | "document" => Ok(ResourceType::Document),
+                    "Stylesheet" | "stylesheet" => Ok(ResourceType::Stylesheet),
+                    "Image" | "image" => Ok(ResourceType::Image),
+                    "Media" | "media" => Ok(ResourceType::Media),
+                    "Font" | "font" => Ok(ResourceType::Font),
+                    "Script" | "script" => Ok(ResourceType::Script),
+                    "TextTrack" | "texttrack" => Ok(ResourceType::TextTrack),
+                    "XHR" | "Xhr" | "xhr" => Ok(ResourceType::Xhr),
+                    "Fetch" | "fetch" => Ok(ResourceType::Fetch),
+                    "Prefetch" | "prefetch" => Ok(ResourceType::Prefetch),
+                    "EventSource" | "eventsource" => Ok(ResourceType::EventSource),
+                    "WebSocket" | "websocket" => Ok(ResourceType::WebSocket),
+                    "Manifest" | "manifest" => Ok(ResourceType::Manifest),
+                    "SignedExchange" | "signedexchange" => Ok(ResourceType::SignedExchange),
+                    "Ping" | "ping" => Ok(ResourceType::Ping),
+                    "CSPViolationReport" | "CspViolationReport" | "cspviolationreport" => {
+                        Ok(ResourceType::CspViolationReport)
+                    }
+                    "Preflight" | "preflight" => Ok(ResourceType::Preflight),
+                    "FedCM" | "FedCm" | "fedcm" => Ok(ResourceType::FedCm),
+                    "Other" | "other" => Ok(ResourceType::Other),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Unique loader identifier.\n[LoaderId](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-LoaderId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct LoaderId(String);
+        impl LoaderId {
+            pub fn new(val: impl Into<String>) -> Self {
+                LoaderId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for LoaderId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<LoaderId> for String {
+            fn from(el: LoaderId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for LoaderId {
+            fn from(expr: String) -> Self {
+                LoaderId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for LoaderId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl LoaderId {
+            pub const IDENTIFIER: &'static str = "Network.LoaderId";
+        }
+        #[doc = "Unique network request identifier.\nNote that this does not identify individual HTTP requests that are part of\na network request.\n[RequestId](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-RequestId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct RequestId(String);
+        impl RequestId {
+            pub fn new(val: impl Into<String>) -> Self {
+                RequestId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for RequestId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<RequestId> for String {
+            fn from(el: RequestId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for RequestId {
+            fn from(expr: String) -> Self {
+                RequestId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for RequestId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl RequestId {
+            pub const IDENTIFIER: &'static str = "Network.RequestId";
+        }
+        #[doc = "Unique intercepted request identifier.\n[InterceptionId](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-InterceptionId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct InterceptionId(String);
+        impl InterceptionId {
+            pub fn new(val: impl Into<String>) -> Self {
+                InterceptionId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for InterceptionId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<InterceptionId> for String {
+            fn from(el: InterceptionId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for InterceptionId {
+            fn from(expr: String) -> Self {
+                InterceptionId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for InterceptionId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl InterceptionId {
+            pub const IDENTIFIER: &'static str = "Network.InterceptionId";
+        }
+        #[doc = "Network level fetch failure reason."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ErrorReason {
+            #[serde(rename = "Failed")]
+            Failed,
+            #[serde(rename = "Aborted")]
+            Aborted,
+            #[serde(rename = "TimedOut")]
+            TimedOut,
+            #[serde(rename = "AccessDenied")]
+            AccessDenied,
+            #[serde(rename = "ConnectionClosed")]
+            ConnectionClosed,
+            #[serde(rename = "ConnectionReset")]
+            ConnectionReset,
+            #[serde(rename = "ConnectionRefused")]
+            ConnectionRefused,
+            #[serde(rename = "ConnectionAborted")]
+            ConnectionAborted,
+            #[serde(rename = "ConnectionFailed")]
+            ConnectionFailed,
+            #[serde(rename = "NameNotResolved")]
+            NameNotResolved,
+            #[serde(rename = "InternetDisconnected")]
+            InternetDisconnected,
+            #[serde(rename = "AddressUnreachable")]
+            AddressUnreachable,
+            #[serde(rename = "BlockedByClient")]
+            BlockedByClient,
+            #[serde(rename = "BlockedByResponse")]
+            BlockedByResponse,
+        }
+        impl AsRef<str> for ErrorReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ErrorReason::Failed => "Failed",
+                    ErrorReason::Aborted => "Aborted",
+                    ErrorReason::TimedOut => "TimedOut",
+                    ErrorReason::AccessDenied => "AccessDenied",
+                    ErrorReason::ConnectionClosed => "ConnectionClosed",
+                    ErrorReason::ConnectionReset => "ConnectionReset",
+                    ErrorReason::ConnectionRefused => "ConnectionRefused",
+                    ErrorReason::ConnectionAborted => "ConnectionAborted",
+                    ErrorReason::ConnectionFailed => "ConnectionFailed",
+                    ErrorReason::NameNotResolved => "NameNotResolved",
+                    ErrorReason::InternetDisconnected => "InternetDisconnected",
+                    ErrorReason::AddressUnreachable => "AddressUnreachable",
+                    ErrorReason::BlockedByClient => "BlockedByClient",
+                    ErrorReason::BlockedByResponse => "BlockedByResponse",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ErrorReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Failed" | "failed" => Ok(ErrorReason::Failed),
+                    "Aborted" | "aborted" => Ok(ErrorReason::Aborted),
+                    "TimedOut" | "timedout" => Ok(ErrorReason::TimedOut),
+                    "AccessDenied" | "accessdenied" => Ok(ErrorReason::AccessDenied),
+                    "ConnectionClosed" | "connectionclosed" => Ok(ErrorReason::ConnectionClosed),
+                    "ConnectionReset" | "connectionreset" => Ok(ErrorReason::ConnectionReset),
+                    "ConnectionRefused" | "connectionrefused" => Ok(ErrorReason::ConnectionRefused),
+                    "ConnectionAborted" | "connectionaborted" => Ok(ErrorReason::ConnectionAborted),
+                    "ConnectionFailed" | "connectionfailed" => Ok(ErrorReason::ConnectionFailed),
+                    "NameNotResolved" | "namenotresolved" => Ok(ErrorReason::NameNotResolved),
+                    "InternetDisconnected" | "internetdisconnected" => {
+                        Ok(ErrorReason::InternetDisconnected)
+                    }
+                    "AddressUnreachable" | "addressunreachable" => {
+                        Ok(ErrorReason::AddressUnreachable)
+                    }
+                    "BlockedByClient" | "blockedbyclient" => Ok(ErrorReason::BlockedByClient),
+                    "BlockedByResponse" | "blockedbyresponse" => Ok(ErrorReason::BlockedByResponse),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "UTC time in seconds, counted from January 1, 1970.\n[TimeSinceEpoch](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-TimeSinceEpoch)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TimeSinceEpoch(f64);
+        impl TimeSinceEpoch {
+            pub fn new(val: impl Into<f64>) -> Self {
+                TimeSinceEpoch(val.into())
+            }
+            pub fn inner(&self) -> &f64 {
+                &self.0
+            }
+        }
+        impl TimeSinceEpoch {
+            pub const IDENTIFIER: &'static str = "Network.TimeSinceEpoch";
+        }
+        #[doc = "Monotonically increasing time in seconds since an arbitrary point in the past.\n[MonotonicTime](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-MonotonicTime)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct MonotonicTime(f64);
+        impl MonotonicTime {
+            pub fn new(val: impl Into<f64>) -> Self {
+                MonotonicTime(val.into())
+            }
+            pub fn inner(&self) -> &f64 {
+                &self.0
+            }
+        }
+        impl MonotonicTime {
+            pub const IDENTIFIER: &'static str = "Network.MonotonicTime";
+        }
+        #[doc = "Request / response headers as keys / values of JSON object.\n[Headers](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-Headers)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct Headers(serde_json::Value);
+        impl Headers {
+            pub fn new(val: impl Into<serde_json::Value>) -> Self {
+                Headers(val.into())
+            }
+            pub fn inner(&self) -> &serde_json::Value {
+                &self.0
+            }
+        }
+        impl Headers {
+            pub const IDENTIFIER: &'static str = "Network.Headers";
+        }
+        #[doc = "The underlying connection technology that the browser is supposedly using."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ConnectionType {
+            #[serde(rename = "none")]
+            None,
+            #[serde(rename = "cellular2g")]
+            Cellular2g,
+            #[serde(rename = "cellular3g")]
+            Cellular3g,
+            #[serde(rename = "cellular4g")]
+            Cellular4g,
+            #[serde(rename = "bluetooth")]
+            Bluetooth,
+            #[serde(rename = "ethernet")]
+            Ethernet,
+            #[serde(rename = "wifi")]
+            Wifi,
+            #[serde(rename = "wimax")]
+            Wimax,
+            #[serde(rename = "other")]
+            Other,
+        }
+        impl AsRef<str> for ConnectionType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ConnectionType::None => "none",
+                    ConnectionType::Cellular2g => "cellular2g",
+                    ConnectionType::Cellular3g => "cellular3g",
+                    ConnectionType::Cellular4g => "cellular4g",
+                    ConnectionType::Bluetooth => "bluetooth",
+                    ConnectionType::Ethernet => "ethernet",
+                    ConnectionType::Wifi => "wifi",
+                    ConnectionType::Wimax => "wimax",
+                    ConnectionType::Other => "other",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ConnectionType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "none" | "None" => Ok(ConnectionType::None),
+                    "cellular2g" | "Cellular2g" => Ok(ConnectionType::Cellular2g),
+                    "cellular3g" | "Cellular3g" => Ok(ConnectionType::Cellular3g),
+                    "cellular4g" | "Cellular4g" => Ok(ConnectionType::Cellular4g),
+                    "bluetooth" | "Bluetooth" => Ok(ConnectionType::Bluetooth),
+                    "ethernet" | "Ethernet" => Ok(ConnectionType::Ethernet),
+                    "wifi" | "Wifi" => Ok(ConnectionType::Wifi),
+                    "wimax" | "Wimax" => Ok(ConnectionType::Wimax),
+                    "other" | "Other" => Ok(ConnectionType::Other),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Represents the cookie's 'SameSite' status:\nhttps://tools.ietf.org/html/draft-west-first-party-cookies"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CookieSameSite {
+            #[serde(rename = "Strict")]
+            Strict,
+            #[serde(rename = "Lax")]
+            Lax,
+            #[serde(rename = "None")]
+            None,
+        }
+        impl AsRef<str> for CookieSameSite {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CookieSameSite::Strict => "Strict",
+                    CookieSameSite::Lax => "Lax",
+                    CookieSameSite::None => "None",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CookieSameSite {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Strict" | "strict" => Ok(CookieSameSite::Strict),
+                    "Lax" | "lax" => Ok(CookieSameSite::Lax),
+                    "None" | "none" => Ok(CookieSameSite::None),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Represents the cookie's 'Priority' status:\nhttps://tools.ietf.org/html/draft-west-cookie-priority-00"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CookiePriority {
+            #[serde(rename = "Low")]
+            Low,
+            #[serde(rename = "Medium")]
+            Medium,
+            #[serde(rename = "High")]
+            High,
+        }
+        impl AsRef<str> for CookiePriority {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CookiePriority::Low => "Low",
+                    CookiePriority::Medium => "Medium",
+                    CookiePriority::High => "High",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CookiePriority {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Low" | "low" => Ok(CookiePriority::Low),
+                    "Medium" | "medium" => Ok(CookiePriority::Medium),
+                    "High" | "high" => Ok(CookiePriority::High),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Represents the source scheme of the origin that originally set the cookie.\nA value of \"Unset\" allows protocol clients to emulate legacy cookie scope for the scheme.\nThis is a temporary ability and it will be removed in the future."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CookieSourceScheme {
+            #[serde(rename = "Unset")]
+            Unset,
+            #[serde(rename = "NonSecure")]
+            NonSecure,
+            #[serde(rename = "Secure")]
+            Secure,
+        }
+        impl AsRef<str> for CookieSourceScheme {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CookieSourceScheme::Unset => "Unset",
+                    CookieSourceScheme::NonSecure => "NonSecure",
+                    CookieSourceScheme::Secure => "Secure",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CookieSourceScheme {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Unset" | "unset" => Ok(CookieSourceScheme::Unset),
+                    "NonSecure" | "nonsecure" => Ok(CookieSourceScheme::NonSecure),
+                    "Secure" | "secure" => Ok(CookieSourceScheme::Secure),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Timing information for the request.\n[ResourceTiming](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-ResourceTiming)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ResourceTiming {
+            #[doc = "Timing's requestTime is a baseline in seconds, while the other numbers are ticks in\nmilliseconds relatively to this requestTime."]
+            #[serde(rename = "requestTime")]
+            pub request_time: f64,
+            #[doc = "Started resolving proxy."]
+            #[serde(rename = "proxyStart")]
+            pub proxy_start: f64,
+            #[doc = "Finished resolving proxy."]
+            #[serde(rename = "proxyEnd")]
+            pub proxy_end: f64,
+            #[doc = "Started DNS address resolve."]
+            #[serde(rename = "dnsStart")]
+            pub dns_start: f64,
+            #[doc = "Finished DNS address resolve."]
+            #[serde(rename = "dnsEnd")]
+            pub dns_end: f64,
+            #[doc = "Started connecting to the remote host."]
+            #[serde(rename = "connectStart")]
+            pub connect_start: f64,
+            #[doc = "Connected to the remote host."]
+            #[serde(rename = "connectEnd")]
+            pub connect_end: f64,
+            #[doc = "Started SSL handshake."]
+            #[serde(rename = "sslStart")]
+            pub ssl_start: f64,
+            #[doc = "Finished SSL handshake."]
+            #[serde(rename = "sslEnd")]
+            pub ssl_end: f64,
+            #[doc = "Started running ServiceWorker."]
+            #[serde(rename = "workerStart")]
+            pub worker_start: f64,
+            #[doc = "Finished Starting ServiceWorker."]
+            #[serde(rename = "workerReady")]
+            pub worker_ready: f64,
+            #[doc = "Started fetch event."]
+            #[serde(rename = "workerFetchStart")]
+            pub worker_fetch_start: f64,
+            #[doc = "Settled fetch event respondWith promise."]
+            #[serde(rename = "workerRespondWithSettled")]
+            pub worker_respond_with_settled: f64,
+            #[doc = "Started ServiceWorker static routing source evaluation."]
+            #[serde(rename = "workerRouterEvaluationStart")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub worker_router_evaluation_start: Option<f64>,
+            #[doc = "Started cache lookup when the source was evaluated to `cache`."]
+            #[serde(rename = "workerCacheLookupStart")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub worker_cache_lookup_start: Option<f64>,
+            #[doc = "Started sending request."]
+            #[serde(rename = "sendStart")]
+            pub send_start: f64,
+            #[doc = "Finished sending request."]
+            #[serde(rename = "sendEnd")]
+            pub send_end: f64,
+            #[doc = "Time the server started pushing request."]
+            #[serde(rename = "pushStart")]
+            pub push_start: f64,
+            #[doc = "Time the server finished pushing request."]
+            #[serde(rename = "pushEnd")]
+            pub push_end: f64,
+            #[doc = "Started receiving response headers."]
+            #[serde(rename = "receiveHeadersStart")]
+            pub receive_headers_start: f64,
+            #[doc = "Finished receiving response headers."]
+            #[serde(rename = "receiveHeadersEnd")]
+            pub receive_headers_end: f64,
+        }
+        impl ResourceTiming {
+            pub fn builder() -> ResourceTimingBuilder {
+                ResourceTimingBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResourceTimingBuilder {
+            request_time: Option<f64>,
+            proxy_start: Option<f64>,
+            proxy_end: Option<f64>,
+            dns_start: Option<f64>,
+            dns_end: Option<f64>,
+            connect_start: Option<f64>,
+            connect_end: Option<f64>,
+            ssl_start: Option<f64>,
+            ssl_end: Option<f64>,
+            worker_start: Option<f64>,
+            worker_ready: Option<f64>,
+            worker_fetch_start: Option<f64>,
+            worker_respond_with_settled: Option<f64>,
+            worker_router_evaluation_start: Option<f64>,
+            worker_cache_lookup_start: Option<f64>,
+            send_start: Option<f64>,
+            send_end: Option<f64>,
+            push_start: Option<f64>,
+            push_end: Option<f64>,
+            receive_headers_start: Option<f64>,
+            receive_headers_end: Option<f64>,
+        }
+        impl ResourceTimingBuilder {
+            pub fn request_time(mut self, request_time: impl Into<f64>) -> Self {
+                self.request_time = Some(request_time.into());
+                self
+            }
+            pub fn proxy_start(mut self, proxy_start: impl Into<f64>) -> Self {
+                self.proxy_start = Some(proxy_start.into());
+                self
+            }
+            pub fn proxy_end(mut self, proxy_end: impl Into<f64>) -> Self {
+                self.proxy_end = Some(proxy_end.into());
+                self
+            }
+            pub fn dns_start(mut self, dns_start: impl Into<f64>) -> Self {
+                self.dns_start = Some(dns_start.into());
+                self
+            }
+            pub fn dns_end(mut self, dns_end: impl Into<f64>) -> Self {
+                self.dns_end = Some(dns_end.into());
+                self
+            }
+            pub fn connect_start(mut self, connect_start: impl Into<f64>) -> Self {
+                self.connect_start = Some(connect_start.into());
+                self
+            }
+            pub fn connect_end(mut self, connect_end: impl Into<f64>) -> Self {
+                self.connect_end = Some(connect_end.into());
+                self
+            }
+            pub fn ssl_start(mut self, ssl_start: impl Into<f64>) -> Self {
+                self.ssl_start = Some(ssl_start.into());
+                self
+            }
+            pub fn ssl_end(mut self, ssl_end: impl Into<f64>) -> Self {
+                self.ssl_end = Some(ssl_end.into());
+                self
+            }
+            pub fn worker_start(mut self, worker_start: impl Into<f64>) -> Self {
+                self.worker_start = Some(worker_start.into());
+                self
+            }
+            pub fn worker_ready(mut self, worker_ready: impl Into<f64>) -> Self {
+                self.worker_ready = Some(worker_ready.into());
+                self
+            }
+            pub fn worker_fetch_start(mut self, worker_fetch_start: impl Into<f64>) -> Self {
+                self.worker_fetch_start = Some(worker_fetch_start.into());
+                self
+            }
+            pub fn worker_respond_with_settled(
+                mut self,
+                worker_respond_with_settled: impl Into<f64>,
+            ) -> Self {
+                self.worker_respond_with_settled = Some(worker_respond_with_settled.into());
+                self
+            }
+            pub fn worker_router_evaluation_start(
+                mut self,
+                worker_router_evaluation_start: impl Into<f64>,
+            ) -> Self {
+                self.worker_router_evaluation_start = Some(worker_router_evaluation_start.into());
+                self
+            }
+            pub fn worker_cache_lookup_start(
+                mut self,
+                worker_cache_lookup_start: impl Into<f64>,
+            ) -> Self {
+                self.worker_cache_lookup_start = Some(worker_cache_lookup_start.into());
+                self
+            }
+            pub fn send_start(mut self, send_start: impl Into<f64>) -> Self {
+                self.send_start = Some(send_start.into());
+                self
+            }
+            pub fn send_end(mut self, send_end: impl Into<f64>) -> Self {
+                self.send_end = Some(send_end.into());
+                self
+            }
+            pub fn push_start(mut self, push_start: impl Into<f64>) -> Self {
+                self.push_start = Some(push_start.into());
+                self
+            }
+            pub fn push_end(mut self, push_end: impl Into<f64>) -> Self {
+                self.push_end = Some(push_end.into());
+                self
+            }
+            pub fn receive_headers_start(mut self, receive_headers_start: impl Into<f64>) -> Self {
+                self.receive_headers_start = Some(receive_headers_start.into());
+                self
+            }
+            pub fn receive_headers_end(mut self, receive_headers_end: impl Into<f64>) -> Self {
+                self.receive_headers_end = Some(receive_headers_end.into());
+                self
+            }
+            pub fn build(self) -> Result<ResourceTiming, String> {
+                Ok(ResourceTiming {
+                    request_time: self.request_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_time))
+                    })?,
+                    proxy_start: self.proxy_start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(proxy_start))
+                    })?,
+                    proxy_end: self.proxy_end.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(proxy_end))
+                    })?,
+                    dns_start: self.dns_start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(dns_start))
+                    })?,
+                    dns_end: self.dns_end.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(dns_end))
+                    })?,
+                    connect_start: self.connect_start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(connect_start))
+                    })?,
+                    connect_end: self.connect_end.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(connect_end))
+                    })?,
+                    ssl_start: self.ssl_start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ssl_start))
+                    })?,
+                    ssl_end: self.ssl_end.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ssl_end))
+                    })?,
+                    worker_start: self.worker_start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(worker_start))
+                    })?,
+                    worker_ready: self.worker_ready.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(worker_ready))
+                    })?,
+                    worker_fetch_start: self.worker_fetch_start.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(worker_fetch_start)
+                        )
+                    })?,
+                    worker_respond_with_settled: self.worker_respond_with_settled.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(worker_respond_with_settled)
+                            )
+                        },
+                    )?,
+                    worker_router_evaluation_start: self.worker_router_evaluation_start,
+                    worker_cache_lookup_start: self.worker_cache_lookup_start,
+                    send_start: self.send_start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(send_start))
+                    })?,
+                    send_end: self.send_end.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(send_end))
+                    })?,
+                    push_start: self.push_start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(push_start))
+                    })?,
+                    push_end: self.push_end.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(push_end))
+                    })?,
+                    receive_headers_start: self.receive_headers_start.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(receive_headers_start)
+                        )
+                    })?,
+                    receive_headers_end: self.receive_headers_end.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(receive_headers_end)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl ResourceTiming {
+            pub const IDENTIFIER: &'static str = "Network.ResourceTiming";
+        }
+        #[doc = "Loading priority of a resource request."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ResourcePriority {
+            #[serde(rename = "VeryLow")]
+            VeryLow,
+            #[serde(rename = "Low")]
+            Low,
+            #[serde(rename = "Medium")]
+            Medium,
+            #[serde(rename = "High")]
+            High,
+            #[serde(rename = "VeryHigh")]
+            VeryHigh,
+        }
+        impl AsRef<str> for ResourcePriority {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ResourcePriority::VeryLow => "VeryLow",
+                    ResourcePriority::Low => "Low",
+                    ResourcePriority::Medium => "Medium",
+                    ResourcePriority::High => "High",
+                    ResourcePriority::VeryHigh => "VeryHigh",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ResourcePriority {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "VeryLow" | "verylow" => Ok(ResourcePriority::VeryLow),
+                    "Low" | "low" => Ok(ResourcePriority::Low),
+                    "Medium" | "medium" => Ok(ResourcePriority::Medium),
+                    "High" | "high" => Ok(ResourcePriority::High),
+                    "VeryHigh" | "veryhigh" => Ok(ResourcePriority::VeryHigh),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "The render blocking behavior of a resource request."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum RenderBlockingBehavior {
+            #[serde(rename = "Blocking")]
+            Blocking,
+            #[serde(rename = "InBodyParserBlocking")]
+            InBodyParserBlocking,
+            #[serde(rename = "NonBlocking")]
+            NonBlocking,
+            #[serde(rename = "NonBlockingDynamic")]
+            NonBlockingDynamic,
+            #[serde(rename = "PotentiallyBlocking")]
+            PotentiallyBlocking,
+        }
+        impl AsRef<str> for RenderBlockingBehavior {
+            fn as_ref(&self) -> &str {
+                match self {
+                    RenderBlockingBehavior::Blocking => "Blocking",
+                    RenderBlockingBehavior::InBodyParserBlocking => "InBodyParserBlocking",
+                    RenderBlockingBehavior::NonBlocking => "NonBlocking",
+                    RenderBlockingBehavior::NonBlockingDynamic => "NonBlockingDynamic",
+                    RenderBlockingBehavior::PotentiallyBlocking => "PotentiallyBlocking",
+                }
+            }
+        }
+        impl ::std::str::FromStr for RenderBlockingBehavior {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Blocking" | "blocking" => Ok(RenderBlockingBehavior::Blocking),
+                    "InBodyParserBlocking" | "inbodyparserblocking" => {
+                        Ok(RenderBlockingBehavior::InBodyParserBlocking)
+                    }
+                    "NonBlocking" | "nonblocking" => Ok(RenderBlockingBehavior::NonBlocking),
+                    "NonBlockingDynamic" | "nonblockingdynamic" => {
+                        Ok(RenderBlockingBehavior::NonBlockingDynamic)
+                    }
+                    "PotentiallyBlocking" | "potentiallyblocking" => {
+                        Ok(RenderBlockingBehavior::PotentiallyBlocking)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Post data entry for HTTP request\n[PostDataEntry](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-PostDataEntry)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct PostDataEntry {
+            #[serde(rename = "bytes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub bytes: Option<chromiumoxide_types::Binary>,
+        }
+        impl PostDataEntry {
+            pub fn builder() -> PostDataEntryBuilder {
+                PostDataEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PostDataEntryBuilder {
+            bytes: Option<chromiumoxide_types::Binary>,
+        }
+        impl PostDataEntryBuilder {
+            pub fn bytes(mut self, bytes: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.bytes = Some(bytes.into());
+                self
+            }
+            pub fn build(self) -> PostDataEntry {
+                PostDataEntry { bytes: self.bytes }
+            }
+        }
+        impl PostDataEntry {
+            pub const IDENTIFIER: &'static str = "Network.PostDataEntry";
+        }
+        #[doc = "HTTP request data.\n[Request](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-Request)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Request {
+            #[doc = "Request URL (without fragment)."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Fragment of the requested URL starting with hash, if present."]
+            #[serde(rename = "urlFragment")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url_fragment: Option<String>,
+            #[doc = "HTTP request method."]
+            #[serde(rename = "method")]
+            pub method: String,
+            #[doc = "HTTP request headers."]
+            #[serde(rename = "headers")]
+            pub headers: Headers,
+            #[doc = "True when the request has POST data. Note that postData might still be omitted when this flag is true when the data is too long."]
+            #[serde(rename = "hasPostData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_post_data: Option<bool>,
+            #[doc = "Request body elements (post data broken into individual entries)."]
+            #[serde(rename = "postDataEntries")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub post_data_entries: Option<Vec<PostDataEntry>>,
+            #[doc = "The mixed content type of the request."]
+            #[serde(rename = "mixedContentType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub mixed_content_type: Option<super::security::MixedContentType>,
+            #[doc = "Priority of the resource request at the time request is sent."]
+            #[serde(rename = "initialPriority")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub initial_priority: ResourcePriority,
+            #[doc = "The referrer policy of the request, as defined in https://www.w3.org/TR/referrer-policy/"]
+            #[serde(rename = "referrerPolicy")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub referrer_policy: RequestReferrerPolicy,
+            #[doc = "Whether is loaded via link preload."]
+            #[serde(rename = "isLinkPreload")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_link_preload: Option<bool>,
+            #[doc = "Set for requests when the TrustToken API is used. Contains the parameters\npassed by the developer (e.g. via \"fetch\") as understood by the backend."]
+            #[serde(rename = "trustTokenParams")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub trust_token_params: Option<TrustTokenParams>,
+            #[doc = "True if this resource request is considered to be the 'same site' as the\nrequest corresponding to the main frame."]
+            #[serde(rename = "isSameSite")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_same_site: Option<bool>,
+            #[doc = "True when the resource request is ad-related."]
+            #[serde(rename = "isAdRelated")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_ad_related: Option<bool>,
+        }
+        #[doc = "The referrer policy of the request, as defined in https://www.w3.org/TR/referrer-policy/"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum RequestReferrerPolicy {
+            #[serde(rename = "unsafe-url")]
+            UnsafeUrl,
+            #[serde(rename = "no-referrer-when-downgrade")]
+            NoReferrerWhenDowngrade,
+            #[serde(rename = "no-referrer")]
+            NoReferrer,
+            #[serde(rename = "origin")]
+            Origin,
+            #[serde(rename = "origin-when-cross-origin")]
+            OriginWhenCrossOrigin,
+            #[serde(rename = "same-origin")]
+            SameOrigin,
+            #[serde(rename = "strict-origin")]
+            StrictOrigin,
+            #[serde(rename = "strict-origin-when-cross-origin")]
+            StrictOriginWhenCrossOrigin,
+        }
+        impl AsRef<str> for RequestReferrerPolicy {
+            fn as_ref(&self) -> &str {
+                match self {
+                    RequestReferrerPolicy::UnsafeUrl => "unsafe-url",
+                    RequestReferrerPolicy::NoReferrerWhenDowngrade => "no-referrer-when-downgrade",
+                    RequestReferrerPolicy::NoReferrer => "no-referrer",
+                    RequestReferrerPolicy::Origin => "origin",
+                    RequestReferrerPolicy::OriginWhenCrossOrigin => "origin-when-cross-origin",
+                    RequestReferrerPolicy::SameOrigin => "same-origin",
+                    RequestReferrerPolicy::StrictOrigin => "strict-origin",
+                    RequestReferrerPolicy::StrictOriginWhenCrossOrigin => {
+                        "strict-origin-when-cross-origin"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for RequestReferrerPolicy {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "unsafe-url" | "UnsafeUrl" => Ok(RequestReferrerPolicy::UnsafeUrl),
+                    "no-referrer-when-downgrade" | "NoReferrerWhenDowngrade" => {
+                        Ok(RequestReferrerPolicy::NoReferrerWhenDowngrade)
+                    }
+                    "no-referrer" | "NoReferrer" => Ok(RequestReferrerPolicy::NoReferrer),
+                    "origin" | "Origin" => Ok(RequestReferrerPolicy::Origin),
+                    "origin-when-cross-origin" | "OriginWhenCrossOrigin" => {
+                        Ok(RequestReferrerPolicy::OriginWhenCrossOrigin)
+                    }
+                    "same-origin" | "SameOrigin" => Ok(RequestReferrerPolicy::SameOrigin),
+                    "strict-origin" | "StrictOrigin" => Ok(RequestReferrerPolicy::StrictOrigin),
+                    "strict-origin-when-cross-origin" | "StrictOriginWhenCrossOrigin" => {
+                        Ok(RequestReferrerPolicy::StrictOriginWhenCrossOrigin)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl Request {
+            pub fn builder() -> RequestBuilder {
+                RequestBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestBuilder {
+            url: Option<String>,
+            url_fragment: Option<String>,
+            method: Option<String>,
+            headers: Option<Headers>,
+            has_post_data: Option<bool>,
+            post_data_entries: Option<Vec<PostDataEntry>>,
+            mixed_content_type: Option<super::security::MixedContentType>,
+            initial_priority: Option<ResourcePriority>,
+            referrer_policy: Option<RequestReferrerPolicy>,
+            is_link_preload: Option<bool>,
+            trust_token_params: Option<TrustTokenParams>,
+            is_same_site: Option<bool>,
+            is_ad_related: Option<bool>,
+        }
+        impl RequestBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn url_fragment(mut self, url_fragment: impl Into<String>) -> Self {
+                self.url_fragment = Some(url_fragment.into());
+                self
+            }
+            pub fn method(mut self, method: impl Into<String>) -> Self {
+                self.method = Some(method.into());
+                self
+            }
+            pub fn headers(mut self, headers: impl Into<Headers>) -> Self {
+                self.headers = Some(headers.into());
+                self
+            }
+            pub fn has_post_data(mut self, has_post_data: impl Into<bool>) -> Self {
+                self.has_post_data = Some(has_post_data.into());
+                self
+            }
+            pub fn post_data_entrie(mut self, post_data_entrie: impl Into<PostDataEntry>) -> Self {
+                let v = self.post_data_entries.get_or_insert(Vec::new());
+                v.push(post_data_entrie.into());
+                self
+            }
+            pub fn post_data_entries<I, S>(mut self, post_data_entries: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PostDataEntry>,
+            {
+                let v = self.post_data_entries.get_or_insert(Vec::new());
+                for val in post_data_entries {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn mixed_content_type(
+                mut self,
+                mixed_content_type: impl Into<super::security::MixedContentType>,
+            ) -> Self {
+                self.mixed_content_type = Some(mixed_content_type.into());
+                self
+            }
+            pub fn initial_priority(
+                mut self,
+                initial_priority: impl Into<ResourcePriority>,
+            ) -> Self {
+                self.initial_priority = Some(initial_priority.into());
+                self
+            }
+            pub fn referrer_policy(
+                mut self,
+                referrer_policy: impl Into<RequestReferrerPolicy>,
+            ) -> Self {
+                self.referrer_policy = Some(referrer_policy.into());
+                self
+            }
+            pub fn is_link_preload(mut self, is_link_preload: impl Into<bool>) -> Self {
+                self.is_link_preload = Some(is_link_preload.into());
+                self
+            }
+            pub fn trust_token_params(
+                mut self,
+                trust_token_params: impl Into<TrustTokenParams>,
+            ) -> Self {
+                self.trust_token_params = Some(trust_token_params.into());
+                self
+            }
+            pub fn is_same_site(mut self, is_same_site: impl Into<bool>) -> Self {
+                self.is_same_site = Some(is_same_site.into());
+                self
+            }
+            pub fn is_ad_related(mut self, is_ad_related: impl Into<bool>) -> Self {
+                self.is_ad_related = Some(is_ad_related.into());
+                self
+            }
+            pub fn build(self) -> Result<Request, String> {
+                Ok(Request {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    url_fragment: self.url_fragment,
+                    method: self.method.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(method))
+                    })?,
+                    headers: self.headers.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(headers))
+                    })?,
+                    has_post_data: self.has_post_data,
+                    post_data_entries: self.post_data_entries,
+                    mixed_content_type: self.mixed_content_type,
+                    initial_priority: self.initial_priority.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(initial_priority)
+                        )
+                    })?,
+                    referrer_policy: self.referrer_policy.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(referrer_policy))
+                    })?,
+                    is_link_preload: self.is_link_preload,
+                    trust_token_params: self.trust_token_params,
+                    is_same_site: self.is_same_site,
+                    is_ad_related: self.is_ad_related,
+                })
+            }
+        }
+        impl Request {
+            pub const IDENTIFIER: &'static str = "Network.Request";
+        }
+        #[doc = "Details of a signed certificate timestamp (SCT).\n[SignedCertificateTimestamp](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-SignedCertificateTimestamp)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SignedCertificateTimestamp {
+            #[doc = "Validation status."]
+            #[serde(rename = "status")]
+            pub status: String,
+            #[doc = "Origin."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "Log name / description."]
+            #[serde(rename = "logDescription")]
+            pub log_description: String,
+            #[doc = "Log ID."]
+            #[serde(rename = "logId")]
+            pub log_id: String,
+            #[doc = "Issuance date. Unlike TimeSinceEpoch, this contains the number of\nmilliseconds since January 1, 1970, UTC, not the number of seconds."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: f64,
+            #[doc = "Hash algorithm."]
+            #[serde(rename = "hashAlgorithm")]
+            pub hash_algorithm: String,
+            #[doc = "Signature algorithm."]
+            #[serde(rename = "signatureAlgorithm")]
+            pub signature_algorithm: String,
+            #[doc = "Signature data."]
+            #[serde(rename = "signatureData")]
+            pub signature_data: String,
+        }
+        impl SignedCertificateTimestamp {
+            pub fn builder() -> SignedCertificateTimestampBuilder {
+                SignedCertificateTimestampBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SignedCertificateTimestampBuilder {
+            status: Option<String>,
+            origin: Option<String>,
+            log_description: Option<String>,
+            log_id: Option<String>,
+            timestamp: Option<f64>,
+            hash_algorithm: Option<String>,
+            signature_algorithm: Option<String>,
+            signature_data: Option<String>,
+        }
+        impl SignedCertificateTimestampBuilder {
+            pub fn status(mut self, status: impl Into<String>) -> Self {
+                self.status = Some(status.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn log_description(mut self, log_description: impl Into<String>) -> Self {
+                self.log_description = Some(log_description.into());
+                self
+            }
+            pub fn log_id(mut self, log_id: impl Into<String>) -> Self {
+                self.log_id = Some(log_id.into());
+                self
+            }
+            pub fn timestamp(mut self, timestamp: impl Into<f64>) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn hash_algorithm(mut self, hash_algorithm: impl Into<String>) -> Self {
+                self.hash_algorithm = Some(hash_algorithm.into());
+                self
+            }
+            pub fn signature_algorithm(mut self, signature_algorithm: impl Into<String>) -> Self {
+                self.signature_algorithm = Some(signature_algorithm.into());
+                self
+            }
+            pub fn signature_data(mut self, signature_data: impl Into<String>) -> Self {
+                self.signature_data = Some(signature_data.into());
+                self
+            }
+            pub fn build(self) -> Result<SignedCertificateTimestamp, String> {
+                Ok(SignedCertificateTimestamp {
+                    status: self.status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status))
+                    })?,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    log_description: self.log_description.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(log_description))
+                    })?,
+                    log_id: self.log_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(log_id))
+                    })?,
+                    timestamp: self.timestamp.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(timestamp))
+                    })?,
+                    hash_algorithm: self.hash_algorithm.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(hash_algorithm))
+                    })?,
+                    signature_algorithm: self.signature_algorithm.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(signature_algorithm)
+                        )
+                    })?,
+                    signature_data: self.signature_data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(signature_data))
+                    })?,
+                })
+            }
+        }
+        impl SignedCertificateTimestamp {
+            pub const IDENTIFIER: &'static str = "Network.SignedCertificateTimestamp";
+        }
+        #[doc = "Security details about a request.\n[SecurityDetails](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-SecurityDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SecurityDetails {
+            #[doc = "Protocol name (e.g. \"TLS 1.2\" or \"QUIC\")."]
+            #[serde(rename = "protocol")]
+            pub protocol: String,
+            #[doc = "Key Exchange used by the connection, or the empty string if not applicable."]
+            #[serde(rename = "keyExchange")]
+            pub key_exchange: String,
+            #[doc = "(EC)DH group used by the connection, if applicable."]
+            #[serde(rename = "keyExchangeGroup")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub key_exchange_group: Option<String>,
+            #[doc = "Cipher name."]
+            #[serde(rename = "cipher")]
+            pub cipher: String,
+            #[doc = "TLS MAC. Note that AEAD ciphers do not have separate MACs."]
+            #[serde(rename = "mac")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub mac: Option<String>,
+            #[doc = "Certificate ID value."]
+            #[serde(rename = "certificateId")]
+            pub certificate_id: super::security::CertificateId,
+            #[doc = "Certificate subject name."]
+            #[serde(rename = "subjectName")]
+            pub subject_name: String,
+            #[doc = "Subject Alternative Name (SAN) DNS names and IP addresses."]
+            #[serde(rename = "sanList")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub san_list: Vec<String>,
+            #[doc = "Name of the issuing CA."]
+            #[serde(rename = "issuer")]
+            pub issuer: String,
+            #[doc = "Certificate valid from date."]
+            #[serde(rename = "validFrom")]
+            pub valid_from: TimeSinceEpoch,
+            #[doc = "Certificate valid to (expiration) date"]
+            #[serde(rename = "validTo")]
+            pub valid_to: TimeSinceEpoch,
+            #[doc = "List of signed certificate timestamps (SCTs)."]
+            #[serde(rename = "signedCertificateTimestampList")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub signed_certificate_timestamp_list: Vec<SignedCertificateTimestamp>,
+            #[doc = "Whether the request complied with Certificate Transparency policy"]
+            #[serde(rename = "certificateTransparencyCompliance")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub certificate_transparency_compliance: CertificateTransparencyCompliance,
+            #[doc = "The signature algorithm used by the server in the TLS server signature,\nrepresented as a TLS SignatureScheme code point. Omitted if not\napplicable or not known."]
+            #[serde(rename = "serverSignatureAlgorithm")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub server_signature_algorithm: Option<i64>,
+            #[doc = "Whether the connection used Encrypted ClientHello"]
+            #[serde(rename = "encryptedClientHello")]
+            pub encrypted_client_hello: bool,
+        }
+        impl SecurityDetails {
+            pub fn builder() -> SecurityDetailsBuilder {
+                SecurityDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SecurityDetailsBuilder {
+            protocol: Option<String>,
+            key_exchange: Option<String>,
+            key_exchange_group: Option<String>,
+            cipher: Option<String>,
+            mac: Option<String>,
+            certificate_id: Option<super::security::CertificateId>,
+            subject_name: Option<String>,
+            san_list: Option<Vec<String>>,
+            issuer: Option<String>,
+            valid_from: Option<TimeSinceEpoch>,
+            valid_to: Option<TimeSinceEpoch>,
+            signed_certificate_timestamp_list: Option<Vec<SignedCertificateTimestamp>>,
+            certificate_transparency_compliance: Option<CertificateTransparencyCompliance>,
+            server_signature_algorithm: Option<i64>,
+            encrypted_client_hello: Option<bool>,
+        }
+        impl SecurityDetailsBuilder {
+            pub fn protocol(mut self, protocol: impl Into<String>) -> Self {
+                self.protocol = Some(protocol.into());
+                self
+            }
+            pub fn key_exchange(mut self, key_exchange: impl Into<String>) -> Self {
+                self.key_exchange = Some(key_exchange.into());
+                self
+            }
+            pub fn key_exchange_group(mut self, key_exchange_group: impl Into<String>) -> Self {
+                self.key_exchange_group = Some(key_exchange_group.into());
+                self
+            }
+            pub fn cipher(mut self, cipher: impl Into<String>) -> Self {
+                self.cipher = Some(cipher.into());
+                self
+            }
+            pub fn mac(mut self, mac: impl Into<String>) -> Self {
+                self.mac = Some(mac.into());
+                self
+            }
+            pub fn certificate_id(
+                mut self,
+                certificate_id: impl Into<super::security::CertificateId>,
+            ) -> Self {
+                self.certificate_id = Some(certificate_id.into());
+                self
+            }
+            pub fn subject_name(mut self, subject_name: impl Into<String>) -> Self {
+                self.subject_name = Some(subject_name.into());
+                self
+            }
+            pub fn san_list(mut self, san_list: impl Into<String>) -> Self {
+                let v = self.san_list.get_or_insert(Vec::new());
+                v.push(san_list.into());
+                self
+            }
+            pub fn san_lists<I, S>(mut self, san_lists: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.san_list.get_or_insert(Vec::new());
+                for val in san_lists {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn issuer(mut self, issuer: impl Into<String>) -> Self {
+                self.issuer = Some(issuer.into());
+                self
+            }
+            pub fn valid_from(mut self, valid_from: impl Into<TimeSinceEpoch>) -> Self {
+                self.valid_from = Some(valid_from.into());
+                self
+            }
+            pub fn valid_to(mut self, valid_to: impl Into<TimeSinceEpoch>) -> Self {
+                self.valid_to = Some(valid_to.into());
+                self
+            }
+            pub fn signed_certificate_timestamp_list(
+                mut self,
+                signed_certificate_timestamp_list: impl Into<SignedCertificateTimestamp>,
+            ) -> Self {
+                let v = self
+                    .signed_certificate_timestamp_list
+                    .get_or_insert(Vec::new());
+                v.push(signed_certificate_timestamp_list.into());
+                self
+            }
+            pub fn signed_certificate_timestamp_lists<I, S>(
+                mut self,
+                signed_certificate_timestamp_lists: I,
+            ) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SignedCertificateTimestamp>,
+            {
+                let v = self
+                    .signed_certificate_timestamp_list
+                    .get_or_insert(Vec::new());
+                for val in signed_certificate_timestamp_lists {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn certificate_transparency_compliance(
+                mut self,
+                certificate_transparency_compliance: impl Into<CertificateTransparencyCompliance>,
+            ) -> Self {
+                self.certificate_transparency_compliance =
+                    Some(certificate_transparency_compliance.into());
+                self
+            }
+            pub fn server_signature_algorithm(
+                mut self,
+                server_signature_algorithm: impl Into<i64>,
+            ) -> Self {
+                self.server_signature_algorithm = Some(server_signature_algorithm.into());
+                self
+            }
+            pub fn encrypted_client_hello(
+                mut self,
+                encrypted_client_hello: impl Into<bool>,
+            ) -> Self {
+                self.encrypted_client_hello = Some(encrypted_client_hello.into());
+                self
+            }
+            pub fn build(self) -> Result<SecurityDetails, String> {
+                Ok(SecurityDetails {
+                    protocol: self.protocol.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(protocol))
+                    })?,
+                    key_exchange: self.key_exchange.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_exchange))
+                    })?,
+                    key_exchange_group: self.key_exchange_group,
+                    cipher: self.cipher.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cipher))
+                    })?,
+                    mac: self.mac,
+                    certificate_id: self.certificate_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(certificate_id))
+                    })?,
+                    subject_name: self.subject_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(subject_name))
+                    })?,
+                    san_list: self.san_list.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(san_list))
+                    })?,
+                    issuer: self.issuer.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(issuer))
+                    })?,
+                    valid_from: self.valid_from.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(valid_from))
+                    })?,
+                    valid_to: self.valid_to.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(valid_to))
+                    })?,
+                    signed_certificate_timestamp_list: self
+                        .signed_certificate_timestamp_list
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(signed_certificate_timestamp_list)
+                            )
+                        })?,
+                    certificate_transparency_compliance: self
+                        .certificate_transparency_compliance
+                        .ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(certificate_transparency_compliance)
+                        )
+                    })?,
+                    server_signature_algorithm: self.server_signature_algorithm,
+                    encrypted_client_hello: self.encrypted_client_hello.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(encrypted_client_hello)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl SecurityDetails {
+            pub const IDENTIFIER: &'static str = "Network.SecurityDetails";
+        }
+        #[doc = "Whether the request complied with Certificate Transparency policy."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CertificateTransparencyCompliance {
+            #[serde(rename = "unknown")]
+            Unknown,
+            #[serde(rename = "not-compliant")]
+            NotCompliant,
+            #[serde(rename = "compliant")]
+            Compliant,
+        }
+        impl AsRef<str> for CertificateTransparencyCompliance {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CertificateTransparencyCompliance::Unknown => "unknown",
+                    CertificateTransparencyCompliance::NotCompliant => "not-compliant",
+                    CertificateTransparencyCompliance::Compliant => "compliant",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CertificateTransparencyCompliance {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "unknown" | "Unknown" => Ok(CertificateTransparencyCompliance::Unknown),
+                    "not-compliant" | "NotCompliant" => {
+                        Ok(CertificateTransparencyCompliance::NotCompliant)
+                    }
+                    "compliant" | "Compliant" => Ok(CertificateTransparencyCompliance::Compliant),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "The reason why request was blocked."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum BlockedReason {
+            #[serde(rename = "other")]
+            Other,
+            #[serde(rename = "csp")]
+            Csp,
+            #[serde(rename = "mixed-content")]
+            MixedContent,
+            #[serde(rename = "origin")]
+            Origin,
+            #[serde(rename = "inspector")]
+            Inspector,
+            #[serde(rename = "integrity")]
+            Integrity,
+            #[serde(rename = "subresource-filter")]
+            SubresourceFilter,
+            #[serde(rename = "content-type")]
+            ContentType,
+            #[serde(rename = "coep-frame-resource-needs-coep-header")]
+            CoepFrameResourceNeedsCoepHeader,
+            #[serde(rename = "coop-sandboxed-iframe-cannot-navigate-to-coop-page")]
+            CoopSandboxedIframeCannotNavigateToCoopPage,
+            #[serde(rename = "corp-not-same-origin")]
+            CorpNotSameOrigin,
+            #[serde(rename = "corp-not-same-origin-after-defaulted-to-same-origin-by-coep")]
+            CorpNotSameOriginAfterDefaultedToSameOriginByCoep,
+            #[serde(rename = "corp-not-same-origin-after-defaulted-to-same-origin-by-dip")]
+            CorpNotSameOriginAfterDefaultedToSameOriginByDip,
+            #[serde(
+                rename = "corp-not-same-origin-after-defaulted-to-same-origin-by-coep-and-dip"
+            )]
+            CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip,
+            #[serde(rename = "corp-not-same-site")]
+            CorpNotSameSite,
+            #[serde(rename = "sri-message-signature-mismatch")]
+            SriMessageSignatureMismatch,
+        }
+        impl AsRef<str> for BlockedReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    BlockedReason::Other => "other",
+                    BlockedReason::Csp => "csp",
+                    BlockedReason::MixedContent => "mixed-content",
+                    BlockedReason::Origin => "origin",
+                    BlockedReason::Inspector => "inspector",
+                    BlockedReason::Integrity => "integrity",
+                    BlockedReason::SubresourceFilter => "subresource-filter",
+                    BlockedReason::ContentType => "content-type",
+                    BlockedReason::CoepFrameResourceNeedsCoepHeader => {
+                        "coep-frame-resource-needs-coep-header"
+                    }
+                    BlockedReason::CoopSandboxedIframeCannotNavigateToCoopPage => {
+                        "coop-sandboxed-iframe-cannot-navigate-to-coop-page"
+                    }
+                    BlockedReason::CorpNotSameOrigin => "corp-not-same-origin",
+                    BlockedReason::CorpNotSameOriginAfterDefaultedToSameOriginByCoep => {
+                        "corp-not-same-origin-after-defaulted-to-same-origin-by-coep"
+                    }
+                    BlockedReason::CorpNotSameOriginAfterDefaultedToSameOriginByDip => {
+                        "corp-not-same-origin-after-defaulted-to-same-origin-by-dip"
+                    }
+                    BlockedReason::CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip => {
+                        "corp-not-same-origin-after-defaulted-to-same-origin-by-coep-and-dip"
+                    }
+                    BlockedReason::CorpNotSameSite => "corp-not-same-site",
+                    BlockedReason::SriMessageSignatureMismatch => "sri-message-signature-mismatch",
+                }
+            }
+        }
+        impl ::std::str::FromStr for BlockedReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "other" | "Other" => Ok(BlockedReason::Other),
+                    "csp" | "Csp" => Ok(BlockedReason::Csp),
+                    "mixed-content" | "MixedContent" => Ok(BlockedReason::MixedContent),
+                    "origin" | "Origin" => Ok(BlockedReason::Origin),
+                    "inspector" | "Inspector" => Ok(BlockedReason::Inspector),
+                    "integrity" | "Integrity" => Ok(BlockedReason::Integrity),
+                    "subresource-filter" | "SubresourceFilter" => {
+                        Ok(BlockedReason::SubresourceFilter)
+                    }
+                    "content-type" | "ContentType" => Ok(BlockedReason::ContentType),
+                    "coep-frame-resource-needs-coep-header"
+                    | "CoepFrameResourceNeedsCoepHeader" => {
+                        Ok(BlockedReason::CoepFrameResourceNeedsCoepHeader)
+                    }
+                    "coop-sandboxed-iframe-cannot-navigate-to-coop-page"
+                    | "CoopSandboxedIframeCannotNavigateToCoopPage" => {
+                        Ok(BlockedReason::CoopSandboxedIframeCannotNavigateToCoopPage)
+                    }
+                    "corp-not-same-origin" | "CorpNotSameOrigin" => {
+                        Ok(BlockedReason::CorpNotSameOrigin)
+                    }
+                    "corp-not-same-origin-after-defaulted-to-same-origin-by-coep"
+                    | "CorpNotSameOriginAfterDefaultedToSameOriginByCoep" => {
+                        Ok(BlockedReason::CorpNotSameOriginAfterDefaultedToSameOriginByCoep)
+                    }
+                    "corp-not-same-origin-after-defaulted-to-same-origin-by-dip"
+                    | "CorpNotSameOriginAfterDefaultedToSameOriginByDip" => {
+                        Ok(BlockedReason::CorpNotSameOriginAfterDefaultedToSameOriginByDip)
+                    }
+                    "corp-not-same-origin-after-defaulted-to-same-origin-by-coep-and-dip"
+                    | "CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip" => {
+                        Ok(BlockedReason::CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip)
+                    }
+                    "corp-not-same-site" | "CorpNotSameSite" => Ok(BlockedReason::CorpNotSameSite),
+                    "sri-message-signature-mismatch" | "SriMessageSignatureMismatch" => {
+                        Ok(BlockedReason::SriMessageSignatureMismatch)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "The reason why request was blocked."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CorsError {
+            #[serde(rename = "DisallowedByMode")]
+            DisallowedByMode,
+            #[serde(rename = "InvalidResponse")]
+            InvalidResponse,
+            #[serde(rename = "WildcardOriginNotAllowed")]
+            WildcardOriginNotAllowed,
+            #[serde(rename = "MissingAllowOriginHeader")]
+            MissingAllowOriginHeader,
+            #[serde(rename = "MultipleAllowOriginValues")]
+            MultipleAllowOriginValues,
+            #[serde(rename = "InvalidAllowOriginValue")]
+            InvalidAllowOriginValue,
+            #[serde(rename = "AllowOriginMismatch")]
+            AllowOriginMismatch,
+            #[serde(rename = "InvalidAllowCredentials")]
+            InvalidAllowCredentials,
+            #[serde(rename = "CorsDisabledScheme")]
+            CorsDisabledScheme,
+            #[serde(rename = "PreflightInvalidStatus")]
+            PreflightInvalidStatus,
+            #[serde(rename = "PreflightDisallowedRedirect")]
+            PreflightDisallowedRedirect,
+            #[serde(rename = "PreflightWildcardOriginNotAllowed")]
+            PreflightWildcardOriginNotAllowed,
+            #[serde(rename = "PreflightMissingAllowOriginHeader")]
+            PreflightMissingAllowOriginHeader,
+            #[serde(rename = "PreflightMultipleAllowOriginValues")]
+            PreflightMultipleAllowOriginValues,
+            #[serde(rename = "PreflightInvalidAllowOriginValue")]
+            PreflightInvalidAllowOriginValue,
+            #[serde(rename = "PreflightAllowOriginMismatch")]
+            PreflightAllowOriginMismatch,
+            #[serde(rename = "PreflightInvalidAllowCredentials")]
+            PreflightInvalidAllowCredentials,
+            #[doc = "TODO(https://crbug.com/1263483): Remove this once frontend code does\nnot reference it anymore."]
+            #[serde(rename = "PreflightMissingAllowExternal")]
+            PreflightMissingAllowExternal,
+            #[doc = "TODO(https://crbug.com/1263483): Remove this once frontend code does\nnot reference it anymore."]
+            #[serde(rename = "PreflightInvalidAllowExternal")]
+            PreflightInvalidAllowExternal,
+            #[serde(rename = "PreflightMissingAllowPrivateNetwork")]
+            PreflightMissingAllowPrivateNetwork,
+            #[serde(rename = "PreflightInvalidAllowPrivateNetwork")]
+            PreflightInvalidAllowPrivateNetwork,
+            #[serde(rename = "InvalidAllowMethodsPreflightResponse")]
+            InvalidAllowMethodsPreflightResponse,
+            #[serde(rename = "InvalidAllowHeadersPreflightResponse")]
+            InvalidAllowHeadersPreflightResponse,
+            #[serde(rename = "MethodDisallowedByPreflightResponse")]
+            MethodDisallowedByPreflightResponse,
+            #[serde(rename = "HeaderDisallowedByPreflightResponse")]
+            HeaderDisallowedByPreflightResponse,
+            #[serde(rename = "RedirectContainsCredentials")]
+            RedirectContainsCredentials,
+            #[doc = "Request was a private network request initiated by a non-secure context."]
+            #[serde(rename = "InsecurePrivateNetwork")]
+            InsecurePrivateNetwork,
+            #[doc = "Request carried a target IP address space property that did not match\nthe target resource's address space."]
+            #[serde(rename = "InvalidPrivateNetworkAccess")]
+            InvalidPrivateNetworkAccess,
+            #[doc = "Request was a private network request yet did not carry a target IP\naddress space."]
+            #[serde(rename = "UnexpectedPrivateNetworkAccess")]
+            UnexpectedPrivateNetworkAccess,
+            #[serde(rename = "NoCorsRedirectModeNotFollow")]
+            NoCorsRedirectModeNotFollow,
+            #[doc = "Request was a private network request and needed user permission yet did\nnot carry `Private-Network-Access-Id` in the preflight response.\nhttps://github.com/WICG/private-network-access/blob/main/permission_prompt/explainer.md"]
+            #[serde(rename = "PreflightMissingPrivateNetworkAccessId")]
+            PreflightMissingPrivateNetworkAccessId,
+            #[doc = "Request was a private network request and needed user permission yet did\nnot carry `Private-Network-Access-Name` in the preflight response.\nhttps://github.com/WICG/private-network-access/blob/main/permission_prompt/explainer.md"]
+            #[serde(rename = "PreflightMissingPrivateNetworkAccessName")]
+            PreflightMissingPrivateNetworkAccessName,
+            #[doc = "Request was a private network request and needed user permission yet not\nable to request for permission.\nhttps://github.com/WICG/private-network-access/blob/main/permission_prompt/explainer.md"]
+            #[serde(rename = "PrivateNetworkAccessPermissionUnavailable")]
+            PrivateNetworkAccessPermissionUnavailable,
+            #[doc = "Request was a private network request and is denied by user permission.\nhttps://github.com/WICG/private-network-access/blob/main/permission_prompt/explainer.md"]
+            #[serde(rename = "PrivateNetworkAccessPermissionDenied")]
+            PrivateNetworkAccessPermissionDenied,
+            #[doc = "Request was a local network request and is denied by user permission.\nhttps://wicg.github.io/local-network-access/"]
+            #[serde(rename = "LocalNetworkAccessPermissionDenied")]
+            LocalNetworkAccessPermissionDenied,
+        }
+        impl AsRef<str> for CorsError {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CorsError::DisallowedByMode => "DisallowedByMode",
+                    CorsError::InvalidResponse => "InvalidResponse",
+                    CorsError::WildcardOriginNotAllowed => "WildcardOriginNotAllowed",
+                    CorsError::MissingAllowOriginHeader => "MissingAllowOriginHeader",
+                    CorsError::MultipleAllowOriginValues => "MultipleAllowOriginValues",
+                    CorsError::InvalidAllowOriginValue => "InvalidAllowOriginValue",
+                    CorsError::AllowOriginMismatch => "AllowOriginMismatch",
+                    CorsError::InvalidAllowCredentials => "InvalidAllowCredentials",
+                    CorsError::CorsDisabledScheme => "CorsDisabledScheme",
+                    CorsError::PreflightInvalidStatus => "PreflightInvalidStatus",
+                    CorsError::PreflightDisallowedRedirect => "PreflightDisallowedRedirect",
+                    CorsError::PreflightWildcardOriginNotAllowed => {
+                        "PreflightWildcardOriginNotAllowed"
+                    }
+                    CorsError::PreflightMissingAllowOriginHeader => {
+                        "PreflightMissingAllowOriginHeader"
+                    }
+                    CorsError::PreflightMultipleAllowOriginValues => {
+                        "PreflightMultipleAllowOriginValues"
+                    }
+                    CorsError::PreflightInvalidAllowOriginValue => {
+                        "PreflightInvalidAllowOriginValue"
+                    }
+                    CorsError::PreflightAllowOriginMismatch => "PreflightAllowOriginMismatch",
+                    CorsError::PreflightInvalidAllowCredentials => {
+                        "PreflightInvalidAllowCredentials"
+                    }
+                    CorsError::PreflightMissingAllowExternal => "PreflightMissingAllowExternal",
+                    CorsError::PreflightInvalidAllowExternal => "PreflightInvalidAllowExternal",
+                    CorsError::PreflightMissingAllowPrivateNetwork => {
+                        "PreflightMissingAllowPrivateNetwork"
+                    }
+                    CorsError::PreflightInvalidAllowPrivateNetwork => {
+                        "PreflightInvalidAllowPrivateNetwork"
+                    }
+                    CorsError::InvalidAllowMethodsPreflightResponse => {
+                        "InvalidAllowMethodsPreflightResponse"
+                    }
+                    CorsError::InvalidAllowHeadersPreflightResponse => {
+                        "InvalidAllowHeadersPreflightResponse"
+                    }
+                    CorsError::MethodDisallowedByPreflightResponse => {
+                        "MethodDisallowedByPreflightResponse"
+                    }
+                    CorsError::HeaderDisallowedByPreflightResponse => {
+                        "HeaderDisallowedByPreflightResponse"
+                    }
+                    CorsError::RedirectContainsCredentials => "RedirectContainsCredentials",
+                    CorsError::InsecurePrivateNetwork => "InsecurePrivateNetwork",
+                    CorsError::InvalidPrivateNetworkAccess => "InvalidPrivateNetworkAccess",
+                    CorsError::UnexpectedPrivateNetworkAccess => "UnexpectedPrivateNetworkAccess",
+                    CorsError::NoCorsRedirectModeNotFollow => "NoCorsRedirectModeNotFollow",
+                    CorsError::PreflightMissingPrivateNetworkAccessId => {
+                        "PreflightMissingPrivateNetworkAccessId"
+                    }
+                    CorsError::PreflightMissingPrivateNetworkAccessName => {
+                        "PreflightMissingPrivateNetworkAccessName"
+                    }
+                    CorsError::PrivateNetworkAccessPermissionUnavailable => {
+                        "PrivateNetworkAccessPermissionUnavailable"
+                    }
+                    CorsError::PrivateNetworkAccessPermissionDenied => {
+                        "PrivateNetworkAccessPermissionDenied"
+                    }
+                    CorsError::LocalNetworkAccessPermissionDenied => {
+                        "LocalNetworkAccessPermissionDenied"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for CorsError {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "DisallowedByMode" | "disallowedbymode" => Ok(CorsError::DisallowedByMode),
+                    "InvalidResponse" | "invalidresponse" => Ok(CorsError::InvalidResponse),
+                    "WildcardOriginNotAllowed" | "wildcardoriginnotallowed" => {
+                        Ok(CorsError::WildcardOriginNotAllowed)
+                    }
+                    "MissingAllowOriginHeader" | "missingalloworiginheader" => {
+                        Ok(CorsError::MissingAllowOriginHeader)
+                    }
+                    "MultipleAllowOriginValues" | "multiplealloworiginvalues" => {
+                        Ok(CorsError::MultipleAllowOriginValues)
+                    }
+                    "InvalidAllowOriginValue" | "invalidalloworiginvalue" => {
+                        Ok(CorsError::InvalidAllowOriginValue)
+                    }
+                    "AllowOriginMismatch" | "alloworiginmismatch" => {
+                        Ok(CorsError::AllowOriginMismatch)
+                    }
+                    "InvalidAllowCredentials" | "invalidallowcredentials" => {
+                        Ok(CorsError::InvalidAllowCredentials)
+                    }
+                    "CorsDisabledScheme" | "corsdisabledscheme" => {
+                        Ok(CorsError::CorsDisabledScheme)
+                    }
+                    "PreflightInvalidStatus" | "preflightinvalidstatus" => {
+                        Ok(CorsError::PreflightInvalidStatus)
+                    }
+                    "PreflightDisallowedRedirect" | "preflightdisallowedredirect" => {
+                        Ok(CorsError::PreflightDisallowedRedirect)
+                    }
+                    "PreflightWildcardOriginNotAllowed" | "preflightwildcardoriginnotallowed" => {
+                        Ok(CorsError::PreflightWildcardOriginNotAllowed)
+                    }
+                    "PreflightMissingAllowOriginHeader" | "preflightmissingalloworiginheader" => {
+                        Ok(CorsError::PreflightMissingAllowOriginHeader)
+                    }
+                    "PreflightMultipleAllowOriginValues" | "preflightmultiplealloworiginvalues" => {
+                        Ok(CorsError::PreflightMultipleAllowOriginValues)
+                    }
+                    "PreflightInvalidAllowOriginValue" | "preflightinvalidalloworiginvalue" => {
+                        Ok(CorsError::PreflightInvalidAllowOriginValue)
+                    }
+                    "PreflightAllowOriginMismatch" | "preflightalloworiginmismatch" => {
+                        Ok(CorsError::PreflightAllowOriginMismatch)
+                    }
+                    "PreflightInvalidAllowCredentials" | "preflightinvalidallowcredentials" => {
+                        Ok(CorsError::PreflightInvalidAllowCredentials)
+                    }
+                    "PreflightMissingAllowExternal" | "preflightmissingallowexternal" => {
+                        Ok(CorsError::PreflightMissingAllowExternal)
+                    }
+                    "PreflightInvalidAllowExternal" | "preflightinvalidallowexternal" => {
+                        Ok(CorsError::PreflightInvalidAllowExternal)
+                    }
+                    "PreflightMissingAllowPrivateNetwork"
+                    | "preflightmissingallowprivatenetwork" => {
+                        Ok(CorsError::PreflightMissingAllowPrivateNetwork)
+                    }
+                    "PreflightInvalidAllowPrivateNetwork"
+                    | "preflightinvalidallowprivatenetwork" => {
+                        Ok(CorsError::PreflightInvalidAllowPrivateNetwork)
+                    }
+                    "InvalidAllowMethodsPreflightResponse"
+                    | "invalidallowmethodspreflightresponse" => {
+                        Ok(CorsError::InvalidAllowMethodsPreflightResponse)
+                    }
+                    "InvalidAllowHeadersPreflightResponse"
+                    | "invalidallowheaderspreflightresponse" => {
+                        Ok(CorsError::InvalidAllowHeadersPreflightResponse)
+                    }
+                    "MethodDisallowedByPreflightResponse"
+                    | "methoddisallowedbypreflightresponse" => {
+                        Ok(CorsError::MethodDisallowedByPreflightResponse)
+                    }
+                    "HeaderDisallowedByPreflightResponse"
+                    | "headerdisallowedbypreflightresponse" => {
+                        Ok(CorsError::HeaderDisallowedByPreflightResponse)
+                    }
+                    "RedirectContainsCredentials" | "redirectcontainscredentials" => {
+                        Ok(CorsError::RedirectContainsCredentials)
+                    }
+                    "InsecurePrivateNetwork" | "insecureprivatenetwork" => {
+                        Ok(CorsError::InsecurePrivateNetwork)
+                    }
+                    "InvalidPrivateNetworkAccess" | "invalidprivatenetworkaccess" => {
+                        Ok(CorsError::InvalidPrivateNetworkAccess)
+                    }
+                    "UnexpectedPrivateNetworkAccess" | "unexpectedprivatenetworkaccess" => {
+                        Ok(CorsError::UnexpectedPrivateNetworkAccess)
+                    }
+                    "NoCorsRedirectModeNotFollow" | "nocorsredirectmodenotfollow" => {
+                        Ok(CorsError::NoCorsRedirectModeNotFollow)
+                    }
+                    "PreflightMissingPrivateNetworkAccessId"
+                    | "preflightmissingprivatenetworkaccessid" => {
+                        Ok(CorsError::PreflightMissingPrivateNetworkAccessId)
+                    }
+                    "PreflightMissingPrivateNetworkAccessName"
+                    | "preflightmissingprivatenetworkaccessname" => {
+                        Ok(CorsError::PreflightMissingPrivateNetworkAccessName)
+                    }
+                    "PrivateNetworkAccessPermissionUnavailable"
+                    | "privatenetworkaccesspermissionunavailable" => {
+                        Ok(CorsError::PrivateNetworkAccessPermissionUnavailable)
+                    }
+                    "PrivateNetworkAccessPermissionDenied"
+                    | "privatenetworkaccesspermissiondenied" => {
+                        Ok(CorsError::PrivateNetworkAccessPermissionDenied)
+                    }
+                    "LocalNetworkAccessPermissionDenied" | "localnetworkaccesspermissiondenied" => {
+                        Ok(CorsError::LocalNetworkAccessPermissionDenied)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CorsErrorStatus {
+            #[serde(rename = "corsError")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub cors_error: CorsError,
+            #[serde(rename = "failedParameter")]
+            pub failed_parameter: String,
+        }
+        impl CorsErrorStatus {
+            pub fn new(
+                cors_error: impl Into<CorsError>,
+                failed_parameter: impl Into<String>,
+            ) -> Self {
+                Self {
+                    cors_error: cors_error.into(),
+                    failed_parameter: failed_parameter.into(),
+                }
+            }
+        }
+        impl CorsErrorStatus {
+            pub fn builder() -> CorsErrorStatusBuilder {
+                CorsErrorStatusBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CorsErrorStatusBuilder {
+            cors_error: Option<CorsError>,
+            failed_parameter: Option<String>,
+        }
+        impl CorsErrorStatusBuilder {
+            pub fn cors_error(mut self, cors_error: impl Into<CorsError>) -> Self {
+                self.cors_error = Some(cors_error.into());
+                self
+            }
+            pub fn failed_parameter(mut self, failed_parameter: impl Into<String>) -> Self {
+                self.failed_parameter = Some(failed_parameter.into());
+                self
+            }
+            pub fn build(self) -> Result<CorsErrorStatus, String> {
+                Ok(CorsErrorStatus {
+                    cors_error: self.cors_error.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cors_error))
+                    })?,
+                    failed_parameter: self.failed_parameter.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(failed_parameter)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl CorsErrorStatus {
+            pub const IDENTIFIER: &'static str = "Network.CorsErrorStatus";
+        }
+        #[doc = "Source of serviceworker response."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ServiceWorkerResponseSource {
+            #[serde(rename = "cache-storage")]
+            CacheStorage,
+            #[serde(rename = "http-cache")]
+            HttpCache,
+            #[serde(rename = "fallback-code")]
+            FallbackCode,
+            #[serde(rename = "network")]
+            Network,
+        }
+        impl AsRef<str> for ServiceWorkerResponseSource {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ServiceWorkerResponseSource::CacheStorage => "cache-storage",
+                    ServiceWorkerResponseSource::HttpCache => "http-cache",
+                    ServiceWorkerResponseSource::FallbackCode => "fallback-code",
+                    ServiceWorkerResponseSource::Network => "network",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ServiceWorkerResponseSource {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "cache-storage" | "CacheStorage" => {
+                        Ok(ServiceWorkerResponseSource::CacheStorage)
+                    }
+                    "http-cache" | "HttpCache" => Ok(ServiceWorkerResponseSource::HttpCache),
+                    "fallback-code" | "FallbackCode" => {
+                        Ok(ServiceWorkerResponseSource::FallbackCode)
+                    }
+                    "network" | "Network" => Ok(ServiceWorkerResponseSource::Network),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Determines what type of Trust Token operation is executed and\ndepending on the type, some additional parameters. The values\nare specified in third_party/blink/renderer/core/fetch/trust_token.idl.\n[TrustTokenParams](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-TrustTokenParams)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TrustTokenParams {
+            #[serde(rename = "operation")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub operation: TrustTokenOperationType,
+            #[doc = "Only set for \"token-redemption\" operation and determine whether\nto request a fresh SRR or use a still valid cached SRR."]
+            #[serde(rename = "refreshPolicy")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub refresh_policy: TrustTokenParamsRefreshPolicy,
+            #[doc = "Origins of issuers from whom to request tokens or redemption\nrecords."]
+            #[serde(rename = "issuers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub issuers: Option<Vec<String>>,
+        }
+        #[doc = "Only set for \"token-redemption\" operation and determine whether\nto request a fresh SRR or use a still valid cached SRR."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum TrustTokenParamsRefreshPolicy {
+            #[serde(rename = "UseCached")]
+            UseCached,
+            #[serde(rename = "Refresh")]
+            Refresh,
+        }
+        impl AsRef<str> for TrustTokenParamsRefreshPolicy {
+            fn as_ref(&self) -> &str {
+                match self {
+                    TrustTokenParamsRefreshPolicy::UseCached => "UseCached",
+                    TrustTokenParamsRefreshPolicy::Refresh => "Refresh",
+                }
+            }
+        }
+        impl ::std::str::FromStr for TrustTokenParamsRefreshPolicy {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "UseCached" | "usecached" => Ok(TrustTokenParamsRefreshPolicy::UseCached),
+                    "Refresh" | "refresh" => Ok(TrustTokenParamsRefreshPolicy::Refresh),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl TrustTokenParams {
+            pub fn new(
+                operation: impl Into<TrustTokenOperationType>,
+                refresh_policy: impl Into<TrustTokenParamsRefreshPolicy>,
+            ) -> Self {
+                Self {
+                    operation: operation.into(),
+                    refresh_policy: refresh_policy.into(),
+                    issuers: None,
+                }
+            }
+        }
+        impl TrustTokenParams {
+            pub fn builder() -> TrustTokenParamsBuilder {
+                TrustTokenParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TrustTokenParamsBuilder {
+            operation: Option<TrustTokenOperationType>,
+            refresh_policy: Option<TrustTokenParamsRefreshPolicy>,
+            issuers: Option<Vec<String>>,
+        }
+        impl TrustTokenParamsBuilder {
+            pub fn operation(mut self, operation: impl Into<TrustTokenOperationType>) -> Self {
+                self.operation = Some(operation.into());
+                self
+            }
+            pub fn refresh_policy(
+                mut self,
+                refresh_policy: impl Into<TrustTokenParamsRefreshPolicy>,
+            ) -> Self {
+                self.refresh_policy = Some(refresh_policy.into());
+                self
+            }
+            pub fn issuer(mut self, issuer: impl Into<String>) -> Self {
+                let v = self.issuers.get_or_insert(Vec::new());
+                v.push(issuer.into());
+                self
+            }
+            pub fn issuers<I, S>(mut self, issuers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.issuers.get_or_insert(Vec::new());
+                for val in issuers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<TrustTokenParams, String> {
+                Ok(TrustTokenParams {
+                    operation: self.operation.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(operation))
+                    })?,
+                    refresh_policy: self.refresh_policy.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(refresh_policy))
+                    })?,
+                    issuers: self.issuers,
+                })
+            }
+        }
+        impl TrustTokenParams {
+            pub const IDENTIFIER: &'static str = "Network.TrustTokenParams";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum TrustTokenOperationType {
+            #[doc = "Type \"token-request\" in the Trust Token API."]
+            #[serde(rename = "Issuance")]
+            Issuance,
+            #[doc = "Type \"token-redemption\" in the Trust Token API."]
+            #[serde(rename = "Redemption")]
+            Redemption,
+            #[doc = "Type \"send-redemption-record\" in the Trust Token API."]
+            #[serde(rename = "Signing")]
+            Signing,
+        }
+        impl AsRef<str> for TrustTokenOperationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    TrustTokenOperationType::Issuance => "Issuance",
+                    TrustTokenOperationType::Redemption => "Redemption",
+                    TrustTokenOperationType::Signing => "Signing",
+                }
+            }
+        }
+        impl ::std::str::FromStr for TrustTokenOperationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Issuance" | "issuance" => Ok(TrustTokenOperationType::Issuance),
+                    "Redemption" | "redemption" => Ok(TrustTokenOperationType::Redemption),
+                    "Signing" | "signing" => Ok(TrustTokenOperationType::Signing),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "The reason why Chrome uses a specific transport protocol for HTTP semantics."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AlternateProtocolUsage {
+            #[doc = "Alternate Protocol was used without racing a normal connection."]
+            #[serde(rename = "alternativeJobWonWithoutRace")]
+            AlternativeJobWonWithoutRace,
+            #[doc = "Alternate Protocol was used by winning a race with a normal connection."]
+            #[serde(rename = "alternativeJobWonRace")]
+            AlternativeJobWonRace,
+            #[doc = "Alternate Protocol was not used by losing a race with a normal connection."]
+            #[serde(rename = "mainJobWonRace")]
+            MainJobWonRace,
+            #[doc = "Alternate Protocol was not used because no Alternate-Protocol information\nwas available when the request was issued, but an Alternate-Protocol header\nwas present in the response."]
+            #[serde(rename = "mappingMissing")]
+            MappingMissing,
+            #[doc = "Alternate Protocol was not used because it was marked broken."]
+            #[serde(rename = "broken")]
+            Broken,
+            #[doc = "HTTPS DNS protocol upgrade job was used without racing with a normal\nconnection and an Alternate Protocol job."]
+            #[serde(rename = "dnsAlpnH3JobWonWithoutRace")]
+            DnsAlpnH3JobWonWithoutRace,
+            #[doc = "HTTPS DNS protocol upgrade job won a race with a normal connection and\nan Alternate Protocol job."]
+            #[serde(rename = "dnsAlpnH3JobWonRace")]
+            DnsAlpnH3JobWonRace,
+            #[doc = "This value is used when the reason is unknown."]
+            #[serde(rename = "unspecifiedReason")]
+            UnspecifiedReason,
+        }
+        impl AsRef<str> for AlternateProtocolUsage {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AlternateProtocolUsage::AlternativeJobWonWithoutRace => {
+                        "alternativeJobWonWithoutRace"
+                    }
+                    AlternateProtocolUsage::AlternativeJobWonRace => "alternativeJobWonRace",
+                    AlternateProtocolUsage::MainJobWonRace => "mainJobWonRace",
+                    AlternateProtocolUsage::MappingMissing => "mappingMissing",
+                    AlternateProtocolUsage::Broken => "broken",
+                    AlternateProtocolUsage::DnsAlpnH3JobWonWithoutRace => {
+                        "dnsAlpnH3JobWonWithoutRace"
+                    }
+                    AlternateProtocolUsage::DnsAlpnH3JobWonRace => "dnsAlpnH3JobWonRace",
+                    AlternateProtocolUsage::UnspecifiedReason => "unspecifiedReason",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AlternateProtocolUsage {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "alternativeJobWonWithoutRace"
+                    | "AlternativeJobWonWithoutRace"
+                    | "alternativejobwonwithoutrace" => {
+                        Ok(AlternateProtocolUsage::AlternativeJobWonWithoutRace)
+                    }
+                    "alternativeJobWonRace" | "AlternativeJobWonRace" | "alternativejobwonrace" => {
+                        Ok(AlternateProtocolUsage::AlternativeJobWonRace)
+                    }
+                    "mainJobWonRace" | "MainJobWonRace" | "mainjobwonrace" => {
+                        Ok(AlternateProtocolUsage::MainJobWonRace)
+                    }
+                    "mappingMissing" | "MappingMissing" | "mappingmissing" => {
+                        Ok(AlternateProtocolUsage::MappingMissing)
+                    }
+                    "broken" | "Broken" => Ok(AlternateProtocolUsage::Broken),
+                    "dnsAlpnH3JobWonWithoutRace"
+                    | "DnsAlpnH3JobWonWithoutRace"
+                    | "dnsalpnh3jobwonwithoutrace" => {
+                        Ok(AlternateProtocolUsage::DnsAlpnH3JobWonWithoutRace)
+                    }
+                    "dnsAlpnH3JobWonRace" | "DnsAlpnH3JobWonRace" | "dnsalpnh3jobwonrace" => {
+                        Ok(AlternateProtocolUsage::DnsAlpnH3JobWonRace)
+                    }
+                    "unspecifiedReason" | "UnspecifiedReason" | "unspecifiedreason" => {
+                        Ok(AlternateProtocolUsage::UnspecifiedReason)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Source of service worker router."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ServiceWorkerRouterSource {
+            #[serde(rename = "network")]
+            Network,
+            #[serde(rename = "cache")]
+            Cache,
+            #[serde(rename = "fetch-event")]
+            FetchEvent,
+            #[serde(rename = "race-network-and-fetch-handler")]
+            RaceNetworkAndFetchHandler,
+            #[serde(rename = "race-network-and-cache")]
+            RaceNetworkAndCache,
+        }
+        impl AsRef<str> for ServiceWorkerRouterSource {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ServiceWorkerRouterSource::Network => "network",
+                    ServiceWorkerRouterSource::Cache => "cache",
+                    ServiceWorkerRouterSource::FetchEvent => "fetch-event",
+                    ServiceWorkerRouterSource::RaceNetworkAndFetchHandler => {
+                        "race-network-and-fetch-handler"
+                    }
+                    ServiceWorkerRouterSource::RaceNetworkAndCache => "race-network-and-cache",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ServiceWorkerRouterSource {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "network" | "Network" => Ok(ServiceWorkerRouterSource::Network),
+                    "cache" | "Cache" => Ok(ServiceWorkerRouterSource::Cache),
+                    "fetch-event" | "FetchEvent" => Ok(ServiceWorkerRouterSource::FetchEvent),
+                    "race-network-and-fetch-handler" | "RaceNetworkAndFetchHandler" => {
+                        Ok(ServiceWorkerRouterSource::RaceNetworkAndFetchHandler)
+                    }
+                    "race-network-and-cache" | "RaceNetworkAndCache" => {
+                        Ok(ServiceWorkerRouterSource::RaceNetworkAndCache)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ServiceWorkerRouterInfo {
+            #[doc = "ID of the rule matched. If there is a matched rule, this field will\nbe set, otherwiser no value will be set."]
+            #[serde(rename = "ruleIdMatched")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub rule_id_matched: Option<i64>,
+            #[doc = "The router source of the matched rule. If there is a matched rule, this\nfield will be set, otherwise no value will be set."]
+            #[serde(rename = "matchedSourceType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub matched_source_type: Option<ServiceWorkerRouterSource>,
+            #[doc = "The actual router source used."]
+            #[serde(rename = "actualSourceType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub actual_source_type: Option<ServiceWorkerRouterSource>,
+        }
+        impl ServiceWorkerRouterInfo {
+            pub fn builder() -> ServiceWorkerRouterInfoBuilder {
+                ServiceWorkerRouterInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ServiceWorkerRouterInfoBuilder {
+            rule_id_matched: Option<i64>,
+            matched_source_type: Option<ServiceWorkerRouterSource>,
+            actual_source_type: Option<ServiceWorkerRouterSource>,
+        }
+        impl ServiceWorkerRouterInfoBuilder {
+            pub fn rule_id_matched(mut self, rule_id_matched: impl Into<i64>) -> Self {
+                self.rule_id_matched = Some(rule_id_matched.into());
+                self
+            }
+            pub fn matched_source_type(
+                mut self,
+                matched_source_type: impl Into<ServiceWorkerRouterSource>,
+            ) -> Self {
+                self.matched_source_type = Some(matched_source_type.into());
+                self
+            }
+            pub fn actual_source_type(
+                mut self,
+                actual_source_type: impl Into<ServiceWorkerRouterSource>,
+            ) -> Self {
+                self.actual_source_type = Some(actual_source_type.into());
+                self
+            }
+            pub fn build(self) -> ServiceWorkerRouterInfo {
+                ServiceWorkerRouterInfo {
+                    rule_id_matched: self.rule_id_matched,
+                    matched_source_type: self.matched_source_type,
+                    actual_source_type: self.actual_source_type,
+                }
+            }
+        }
+        impl ServiceWorkerRouterInfo {
+            pub const IDENTIFIER: &'static str = "Network.ServiceWorkerRouterInfo";
+        }
+        #[doc = "HTTP response data.\n[Response](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-Response)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Response {
+            #[doc = "Response URL. This URL can be different from CachedResource.url in case of redirect."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "HTTP response status code."]
+            #[serde(rename = "status")]
+            pub status: i64,
+            #[doc = "HTTP response status text."]
+            #[serde(rename = "statusText")]
+            pub status_text: String,
+            #[doc = "HTTP response headers."]
+            #[serde(rename = "headers")]
+            pub headers: Headers,
+            #[doc = "Resource mimeType as determined by the browser."]
+            #[serde(rename = "mimeType")]
+            pub mime_type: String,
+            #[doc = "Resource charset as determined by the browser (if applicable)."]
+            #[serde(rename = "charset")]
+            pub charset: String,
+            #[doc = "Refined HTTP request headers that were actually transmitted over the network."]
+            #[serde(rename = "requestHeaders")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request_headers: Option<Headers>,
+            #[doc = "Specifies whether physical connection was actually reused for this request."]
+            #[serde(rename = "connectionReused")]
+            pub connection_reused: bool,
+            #[doc = "Physical connection id that was actually used for this request."]
+            #[serde(rename = "connectionId")]
+            pub connection_id: f64,
+            #[doc = "Remote IP address."]
+            #[serde(rename = "remoteIPAddress")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub remote_ip_address: Option<String>,
+            #[doc = "Remote port."]
+            #[serde(rename = "remotePort")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub remote_port: Option<i64>,
+            #[doc = "Specifies that the request was served from the disk cache."]
+            #[serde(rename = "fromDiskCache")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub from_disk_cache: Option<bool>,
+            #[doc = "Specifies that the request was served from the ServiceWorker."]
+            #[serde(rename = "fromServiceWorker")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub from_service_worker: Option<bool>,
+            #[doc = "Specifies that the request was served from the prefetch cache."]
+            #[serde(rename = "fromPrefetchCache")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub from_prefetch_cache: Option<bool>,
+            #[doc = "Specifies that the request was served from the prefetch cache."]
+            #[serde(rename = "fromEarlyHints")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub from_early_hints: Option<bool>,
+            #[doc = "Information about how ServiceWorker Static Router API was used. If this\nfield is set with `matchedSourceType` field, a matching rule is found.\nIf this field is set without `matchedSource`, no matching rule is found.\nOtherwise, the API is not used."]
+            #[serde(rename = "serviceWorkerRouterInfo")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub service_worker_router_info: Option<ServiceWorkerRouterInfo>,
+            #[doc = "Total number of bytes received for this request so far."]
+            #[serde(rename = "encodedDataLength")]
+            pub encoded_data_length: f64,
+            #[doc = "Timing information for the given request."]
+            #[serde(rename = "timing")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub timing: Option<ResourceTiming>,
+            #[doc = "Response source of response from ServiceWorker."]
+            #[serde(rename = "serviceWorkerResponseSource")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub service_worker_response_source: Option<ServiceWorkerResponseSource>,
+            #[doc = "The time at which the returned response was generated."]
+            #[serde(rename = "responseTime")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub response_time: Option<TimeSinceEpoch>,
+            #[doc = "Cache Storage Cache Name."]
+            #[serde(rename = "cacheStorageCacheName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cache_storage_cache_name: Option<String>,
+            #[doc = "Protocol used to fetch this request."]
+            #[serde(rename = "protocol")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub protocol: Option<String>,
+            #[doc = "The reason why Chrome uses a specific transport protocol for HTTP semantics."]
+            #[serde(rename = "alternateProtocolUsage")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub alternate_protocol_usage: Option<AlternateProtocolUsage>,
+            #[doc = "Security state of the request resource."]
+            #[serde(rename = "securityState")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub security_state: super::security::SecurityState,
+            #[doc = "Security details for the request."]
+            #[serde(rename = "securityDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_details: Option<SecurityDetails>,
+        }
+        impl Response {
+            pub fn builder() -> ResponseBuilder {
+                ResponseBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResponseBuilder {
+            url: Option<String>,
+            status: Option<i64>,
+            status_text: Option<String>,
+            headers: Option<Headers>,
+            mime_type: Option<String>,
+            charset: Option<String>,
+            request_headers: Option<Headers>,
+            connection_reused: Option<bool>,
+            connection_id: Option<f64>,
+            remote_ip_address: Option<String>,
+            remote_port: Option<i64>,
+            from_disk_cache: Option<bool>,
+            from_service_worker: Option<bool>,
+            from_prefetch_cache: Option<bool>,
+            from_early_hints: Option<bool>,
+            service_worker_router_info: Option<ServiceWorkerRouterInfo>,
+            encoded_data_length: Option<f64>,
+            timing: Option<ResourceTiming>,
+            service_worker_response_source: Option<ServiceWorkerResponseSource>,
+            response_time: Option<TimeSinceEpoch>,
+            cache_storage_cache_name: Option<String>,
+            protocol: Option<String>,
+            alternate_protocol_usage: Option<AlternateProtocolUsage>,
+            security_state: Option<super::security::SecurityState>,
+            security_details: Option<SecurityDetails>,
+        }
+        impl ResponseBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn status(mut self, status: impl Into<i64>) -> Self {
+                self.status = Some(status.into());
+                self
+            }
+            pub fn status_text(mut self, status_text: impl Into<String>) -> Self {
+                self.status_text = Some(status_text.into());
+                self
+            }
+            pub fn headers(mut self, headers: impl Into<Headers>) -> Self {
+                self.headers = Some(headers.into());
+                self
+            }
+            pub fn mime_type(mut self, mime_type: impl Into<String>) -> Self {
+                self.mime_type = Some(mime_type.into());
+                self
+            }
+            pub fn charset(mut self, charset: impl Into<String>) -> Self {
+                self.charset = Some(charset.into());
+                self
+            }
+            pub fn request_headers(mut self, request_headers: impl Into<Headers>) -> Self {
+                self.request_headers = Some(request_headers.into());
+                self
+            }
+            pub fn connection_reused(mut self, connection_reused: impl Into<bool>) -> Self {
+                self.connection_reused = Some(connection_reused.into());
+                self
+            }
+            pub fn connection_id(mut self, connection_id: impl Into<f64>) -> Self {
+                self.connection_id = Some(connection_id.into());
+                self
+            }
+            pub fn remote_ip_address(mut self, remote_ip_address: impl Into<String>) -> Self {
+                self.remote_ip_address = Some(remote_ip_address.into());
+                self
+            }
+            pub fn remote_port(mut self, remote_port: impl Into<i64>) -> Self {
+                self.remote_port = Some(remote_port.into());
+                self
+            }
+            pub fn from_disk_cache(mut self, from_disk_cache: impl Into<bool>) -> Self {
+                self.from_disk_cache = Some(from_disk_cache.into());
+                self
+            }
+            pub fn from_service_worker(mut self, from_service_worker: impl Into<bool>) -> Self {
+                self.from_service_worker = Some(from_service_worker.into());
+                self
+            }
+            pub fn from_prefetch_cache(mut self, from_prefetch_cache: impl Into<bool>) -> Self {
+                self.from_prefetch_cache = Some(from_prefetch_cache.into());
+                self
+            }
+            pub fn from_early_hints(mut self, from_early_hints: impl Into<bool>) -> Self {
+                self.from_early_hints = Some(from_early_hints.into());
+                self
+            }
+            pub fn service_worker_router_info(
+                mut self,
+                service_worker_router_info: impl Into<ServiceWorkerRouterInfo>,
+            ) -> Self {
+                self.service_worker_router_info = Some(service_worker_router_info.into());
+                self
+            }
+            pub fn encoded_data_length(mut self, encoded_data_length: impl Into<f64>) -> Self {
+                self.encoded_data_length = Some(encoded_data_length.into());
+                self
+            }
+            pub fn timing(mut self, timing: impl Into<ResourceTiming>) -> Self {
+                self.timing = Some(timing.into());
+                self
+            }
+            pub fn service_worker_response_source(
+                mut self,
+                service_worker_response_source: impl Into<ServiceWorkerResponseSource>,
+            ) -> Self {
+                self.service_worker_response_source = Some(service_worker_response_source.into());
+                self
+            }
+            pub fn response_time(mut self, response_time: impl Into<TimeSinceEpoch>) -> Self {
+                self.response_time = Some(response_time.into());
+                self
+            }
+            pub fn cache_storage_cache_name(
+                mut self,
+                cache_storage_cache_name: impl Into<String>,
+            ) -> Self {
+                self.cache_storage_cache_name = Some(cache_storage_cache_name.into());
+                self
+            }
+            pub fn protocol(mut self, protocol: impl Into<String>) -> Self {
+                self.protocol = Some(protocol.into());
+                self
+            }
+            pub fn alternate_protocol_usage(
+                mut self,
+                alternate_protocol_usage: impl Into<AlternateProtocolUsage>,
+            ) -> Self {
+                self.alternate_protocol_usage = Some(alternate_protocol_usage.into());
+                self
+            }
+            pub fn security_state(
+                mut self,
+                security_state: impl Into<super::security::SecurityState>,
+            ) -> Self {
+                self.security_state = Some(security_state.into());
+                self
+            }
+            pub fn security_details(
+                mut self,
+                security_details: impl Into<SecurityDetails>,
+            ) -> Self {
+                self.security_details = Some(security_details.into());
+                self
+            }
+            pub fn build(self) -> Result<Response, String> {
+                Ok(Response {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    status: self.status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status))
+                    })?,
+                    status_text: self.status_text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status_text))
+                    })?,
+                    headers: self.headers.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(headers))
+                    })?,
+                    mime_type: self.mime_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mime_type))
+                    })?,
+                    charset: self.charset.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(charset))
+                    })?,
+                    request_headers: self.request_headers,
+                    connection_reused: self.connection_reused.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(connection_reused)
+                        )
+                    })?,
+                    connection_id: self.connection_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(connection_id))
+                    })?,
+                    remote_ip_address: self.remote_ip_address,
+                    remote_port: self.remote_port,
+                    from_disk_cache: self.from_disk_cache,
+                    from_service_worker: self.from_service_worker,
+                    from_prefetch_cache: self.from_prefetch_cache,
+                    from_early_hints: self.from_early_hints,
+                    service_worker_router_info: self.service_worker_router_info,
+                    encoded_data_length: self.encoded_data_length.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(encoded_data_length)
+                        )
+                    })?,
+                    timing: self.timing,
+                    service_worker_response_source: self.service_worker_response_source,
+                    response_time: self.response_time,
+                    cache_storage_cache_name: self.cache_storage_cache_name,
+                    protocol: self.protocol,
+                    alternate_protocol_usage: self.alternate_protocol_usage,
+                    security_state: self.security_state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(security_state))
+                    })?,
+                    security_details: self.security_details,
+                })
+            }
+        }
+        impl Response {
+            pub const IDENTIFIER: &'static str = "Network.Response";
+        }
+        #[doc = "WebSocket request data.\n[WebSocketRequest](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-WebSocketRequest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct WebSocketRequest {
+            #[doc = "HTTP request headers."]
+            #[serde(rename = "headers")]
+            pub headers: Headers,
+        }
+        impl WebSocketRequest {
+            pub fn new(headers: impl Into<Headers>) -> Self {
+                Self {
+                    headers: headers.into(),
+                }
+            }
+        }
+        impl WebSocketRequest {
+            pub fn builder() -> WebSocketRequestBuilder {
+                WebSocketRequestBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct WebSocketRequestBuilder {
+            headers: Option<Headers>,
+        }
+        impl WebSocketRequestBuilder {
+            pub fn headers(mut self, headers: impl Into<Headers>) -> Self {
+                self.headers = Some(headers.into());
+                self
+            }
+            pub fn build(self) -> Result<WebSocketRequest, String> {
+                Ok(WebSocketRequest {
+                    headers: self.headers.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(headers))
+                    })?,
+                })
+            }
+        }
+        impl WebSocketRequest {
+            pub const IDENTIFIER: &'static str = "Network.WebSocketRequest";
+        }
+        #[doc = "WebSocket response data.\n[WebSocketResponse](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-WebSocketResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct WebSocketResponse {
+            #[doc = "HTTP response status code."]
+            #[serde(rename = "status")]
+            pub status: i64,
+            #[doc = "HTTP response status text."]
+            #[serde(rename = "statusText")]
+            pub status_text: String,
+            #[doc = "HTTP response headers."]
+            #[serde(rename = "headers")]
+            pub headers: Headers,
+            #[doc = "HTTP response headers text."]
+            #[serde(rename = "headersText")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub headers_text: Option<String>,
+            #[doc = "HTTP request headers."]
+            #[serde(rename = "requestHeaders")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request_headers: Option<Headers>,
+            #[doc = "HTTP request headers text."]
+            #[serde(rename = "requestHeadersText")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request_headers_text: Option<String>,
+        }
+        impl WebSocketResponse {
+            pub fn new(
+                status: impl Into<i64>,
+                status_text: impl Into<String>,
+                headers: impl Into<Headers>,
+            ) -> Self {
+                Self {
+                    status: status.into(),
+                    status_text: status_text.into(),
+                    headers: headers.into(),
+                    headers_text: None,
+                    request_headers: None,
+                    request_headers_text: None,
+                }
+            }
+        }
+        impl WebSocketResponse {
+            pub fn builder() -> WebSocketResponseBuilder {
+                WebSocketResponseBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct WebSocketResponseBuilder {
+            status: Option<i64>,
+            status_text: Option<String>,
+            headers: Option<Headers>,
+            headers_text: Option<String>,
+            request_headers: Option<Headers>,
+            request_headers_text: Option<String>,
+        }
+        impl WebSocketResponseBuilder {
+            pub fn status(mut self, status: impl Into<i64>) -> Self {
+                self.status = Some(status.into());
+                self
+            }
+            pub fn status_text(mut self, status_text: impl Into<String>) -> Self {
+                self.status_text = Some(status_text.into());
+                self
+            }
+            pub fn headers(mut self, headers: impl Into<Headers>) -> Self {
+                self.headers = Some(headers.into());
+                self
+            }
+            pub fn headers_text(mut self, headers_text: impl Into<String>) -> Self {
+                self.headers_text = Some(headers_text.into());
+                self
+            }
+            pub fn request_headers(mut self, request_headers: impl Into<Headers>) -> Self {
+                self.request_headers = Some(request_headers.into());
+                self
+            }
+            pub fn request_headers_text(mut self, request_headers_text: impl Into<String>) -> Self {
+                self.request_headers_text = Some(request_headers_text.into());
+                self
+            }
+            pub fn build(self) -> Result<WebSocketResponse, String> {
+                Ok(WebSocketResponse {
+                    status: self.status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status))
+                    })?,
+                    status_text: self.status_text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status_text))
+                    })?,
+                    headers: self.headers.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(headers))
+                    })?,
+                    headers_text: self.headers_text,
+                    request_headers: self.request_headers,
+                    request_headers_text: self.request_headers_text,
+                })
+            }
+        }
+        impl WebSocketResponse {
+            pub const IDENTIFIER: &'static str = "Network.WebSocketResponse";
+        }
+        #[doc = "WebSocket message data. This represents an entire WebSocket message, not just a fragmented frame as the name suggests.\n[WebSocketFrame](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-WebSocketFrame)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct WebSocketFrame {
+            #[doc = "WebSocket message opcode."]
+            #[serde(rename = "opcode")]
+            pub opcode: f64,
+            #[doc = "WebSocket message mask."]
+            #[serde(rename = "mask")]
+            pub mask: bool,
+            #[doc = "WebSocket message payload data.\nIf the opcode is 1, this is a text message and payloadData is a UTF-8 string.\nIf the opcode isn't 1, then payloadData is a base64 encoded string representing binary data."]
+            #[serde(rename = "payloadData")]
+            pub payload_data: String,
+        }
+        impl WebSocketFrame {
+            pub fn new(
+                opcode: impl Into<f64>,
+                mask: impl Into<bool>,
+                payload_data: impl Into<String>,
+            ) -> Self {
+                Self {
+                    opcode: opcode.into(),
+                    mask: mask.into(),
+                    payload_data: payload_data.into(),
+                }
+            }
+        }
+        impl WebSocketFrame {
+            pub fn builder() -> WebSocketFrameBuilder {
+                WebSocketFrameBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct WebSocketFrameBuilder {
+            opcode: Option<f64>,
+            mask: Option<bool>,
+            payload_data: Option<String>,
+        }
+        impl WebSocketFrameBuilder {
+            pub fn opcode(mut self, opcode: impl Into<f64>) -> Self {
+                self.opcode = Some(opcode.into());
+                self
+            }
+            pub fn mask(mut self, mask: impl Into<bool>) -> Self {
+                self.mask = Some(mask.into());
+                self
+            }
+            pub fn payload_data(mut self, payload_data: impl Into<String>) -> Self {
+                self.payload_data = Some(payload_data.into());
+                self
+            }
+            pub fn build(self) -> Result<WebSocketFrame, String> {
+                Ok(WebSocketFrame {
+                    opcode: self.opcode.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(opcode))
+                    })?,
+                    mask: self.mask.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mask))
+                    })?,
+                    payload_data: self.payload_data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(payload_data))
+                    })?,
+                })
+            }
+        }
+        impl WebSocketFrame {
+            pub const IDENTIFIER: &'static str = "Network.WebSocketFrame";
+        }
+        #[doc = "Information about the cached resource.\n[CachedResource](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-CachedResource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CachedResource {
+            #[doc = "Resource URL. This is the url of the original network request."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Type of this resource."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: ResourceType,
+            #[doc = "Cached response data."]
+            #[serde(rename = "response")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub response: Option<Response>,
+            #[doc = "Cached response body size."]
+            #[serde(rename = "bodySize")]
+            pub body_size: f64,
+        }
+        impl CachedResource {
+            pub fn new(
+                url: impl Into<String>,
+                r#type: impl Into<ResourceType>,
+                body_size: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    url: url.into(),
+                    r#type: r#type.into(),
+                    body_size: body_size.into(),
+                    response: None,
+                }
+            }
+        }
+        impl CachedResource {
+            pub fn builder() -> CachedResourceBuilder {
+                CachedResourceBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CachedResourceBuilder {
+            url: Option<String>,
+            r#type: Option<ResourceType>,
+            response: Option<Response>,
+            body_size: Option<f64>,
+        }
+        impl CachedResourceBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<ResourceType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn response(mut self, response: impl Into<Response>) -> Self {
+                self.response = Some(response.into());
+                self
+            }
+            pub fn body_size(mut self, body_size: impl Into<f64>) -> Self {
+                self.body_size = Some(body_size.into());
+                self
+            }
+            pub fn build(self) -> Result<CachedResource, String> {
+                Ok(CachedResource {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    response: self.response,
+                    body_size: self.body_size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(body_size))
+                    })?,
+                })
+            }
+        }
+        impl CachedResource {
+            pub const IDENTIFIER: &'static str = "Network.CachedResource";
+        }
+        #[doc = "Information about the request initiator.\n[Initiator](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-Initiator)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Initiator {
+            #[doc = "Type of this initiator."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: InitiatorType,
+            #[doc = "Initiator JavaScript stack trace, set for Script only.\nRequires the Debugger domain to be enabled."]
+            #[serde(rename = "stack")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stack: Option<super::super::js_protocol::runtime::StackTrace>,
+            #[doc = "Initiator URL, set for Parser type or for Script type (when script is importing module) or for SignedExchange type."]
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[doc = "Initiator line number, set for Parser type or for Script type (when script is importing\nmodule) (0-based)."]
+            #[serde(rename = "lineNumber")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub line_number: Option<f64>,
+            #[doc = "Initiator column number, set for Parser type or for Script type (when script is importing\nmodule) (0-based)."]
+            #[serde(rename = "columnNumber")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub column_number: Option<f64>,
+            #[doc = "Set if another request triggered this request (e.g. preflight)."]
+            #[serde(rename = "requestId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request_id: Option<RequestId>,
+        }
+        #[doc = "Type of this initiator."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum InitiatorType {
+            #[serde(rename = "parser")]
+            Parser,
+            #[serde(rename = "script")]
+            Script,
+            #[serde(rename = "preload")]
+            Preload,
+            #[serde(rename = "SignedExchange")]
+            SignedExchange,
+            #[serde(rename = "preflight")]
+            Preflight,
+            #[serde(rename = "FedCM")]
+            FedCm,
+            #[serde(rename = "other")]
+            Other,
+        }
+        impl AsRef<str> for InitiatorType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    InitiatorType::Parser => "parser",
+                    InitiatorType::Script => "script",
+                    InitiatorType::Preload => "preload",
+                    InitiatorType::SignedExchange => "SignedExchange",
+                    InitiatorType::Preflight => "preflight",
+                    InitiatorType::FedCm => "FedCM",
+                    InitiatorType::Other => "other",
+                }
+            }
+        }
+        impl ::std::str::FromStr for InitiatorType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "parser" | "Parser" => Ok(InitiatorType::Parser),
+                    "script" | "Script" => Ok(InitiatorType::Script),
+                    "preload" | "Preload" => Ok(InitiatorType::Preload),
+                    "SignedExchange" | "signedexchange" => Ok(InitiatorType::SignedExchange),
+                    "preflight" | "Preflight" => Ok(InitiatorType::Preflight),
+                    "FedCM" | "FedCm" | "fedcm" => Ok(InitiatorType::FedCm),
+                    "other" | "Other" => Ok(InitiatorType::Other),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl Initiator {
+            pub fn new(r#type: impl Into<InitiatorType>) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    stack: None,
+                    url: None,
+                    line_number: None,
+                    column_number: None,
+                    request_id: None,
+                }
+            }
+        }
+        impl Initiator {
+            pub fn builder() -> InitiatorBuilder {
+                InitiatorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InitiatorBuilder {
+            r#type: Option<InitiatorType>,
+            stack: Option<super::super::js_protocol::runtime::StackTrace>,
+            url: Option<String>,
+            line_number: Option<f64>,
+            column_number: Option<f64>,
+            request_id: Option<RequestId>,
+        }
+        impl InitiatorBuilder {
+            pub fn r#type(mut self, r#type: impl Into<InitiatorType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn stack(
+                mut self,
+                stack: impl Into<super::super::js_protocol::runtime::StackTrace>,
+            ) -> Self {
+                self.stack = Some(stack.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn line_number(mut self, line_number: impl Into<f64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<f64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn build(self) -> Result<Initiator, String> {
+                Ok(Initiator {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    stack: self.stack,
+                    url: self.url,
+                    line_number: self.line_number,
+                    column_number: self.column_number,
+                    request_id: self.request_id,
+                })
+            }
+        }
+        impl Initiator {
+            pub const IDENTIFIER: &'static str = "Network.Initiator";
+        }
+        #[doc = "cookiePartitionKey object\nThe representation of the components of the key that are created by the cookiePartitionKey class contained in net/cookies/cookie_partition_key.h.\n[CookiePartitionKey](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-CookiePartitionKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CookiePartitionKey {
+            #[doc = "The site of the top-level URL the browser was visiting at the start\nof the request to the endpoint that set the cookie."]
+            #[serde(rename = "topLevelSite")]
+            pub top_level_site: String,
+            #[doc = "Indicates if the cookie has any ancestors that are cross-site to the topLevelSite."]
+            #[serde(rename = "hasCrossSiteAncestor")]
+            pub has_cross_site_ancestor: bool,
+        }
+        impl CookiePartitionKey {
+            pub fn new(
+                top_level_site: impl Into<String>,
+                has_cross_site_ancestor: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    top_level_site: top_level_site.into(),
+                    has_cross_site_ancestor: has_cross_site_ancestor.into(),
+                }
+            }
+        }
+        impl CookiePartitionKey {
+            pub fn builder() -> CookiePartitionKeyBuilder {
+                CookiePartitionKeyBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CookiePartitionKeyBuilder {
+            top_level_site: Option<String>,
+            has_cross_site_ancestor: Option<bool>,
+        }
+        impl CookiePartitionKeyBuilder {
+            pub fn top_level_site(mut self, top_level_site: impl Into<String>) -> Self {
+                self.top_level_site = Some(top_level_site.into());
+                self
+            }
+            pub fn has_cross_site_ancestor(
+                mut self,
+                has_cross_site_ancestor: impl Into<bool>,
+            ) -> Self {
+                self.has_cross_site_ancestor = Some(has_cross_site_ancestor.into());
+                self
+            }
+            pub fn build(self) -> Result<CookiePartitionKey, String> {
+                Ok(CookiePartitionKey {
+                    top_level_site: self.top_level_site.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(top_level_site))
+                    })?,
+                    has_cross_site_ancestor: self.has_cross_site_ancestor.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(has_cross_site_ancestor)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl CookiePartitionKey {
+            pub const IDENTIFIER: &'static str = "Network.CookiePartitionKey";
+        }
+        #[doc = "Cookie object\n[Cookie](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-Cookie)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Cookie {
+            #[doc = "Cookie name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Cookie value."]
+            #[serde(rename = "value")]
+            pub value: String,
+            #[doc = "Cookie domain."]
+            #[serde(rename = "domain")]
+            pub domain: String,
+            #[doc = "Cookie path."]
+            #[serde(rename = "path")]
+            pub path: String,
+            #[doc = "Cookie expiration date as the number of seconds since the UNIX epoch.\nThe value is set to -1 if the expiry date is not set.\nThe value can be null for values that cannot be represented in\nJSON (±Inf)."]
+            #[serde(rename = "expires")]
+            pub expires: f64,
+            #[doc = "Cookie size."]
+            #[serde(rename = "size")]
+            pub size: i64,
+            #[doc = "True if cookie is http-only."]
+            #[serde(rename = "httpOnly")]
+            pub http_only: bool,
+            #[doc = "True if cookie is secure."]
+            #[serde(rename = "secure")]
+            pub secure: bool,
+            #[doc = "True in case of session cookie."]
+            #[serde(rename = "session")]
+            pub session: bool,
+            #[doc = "Cookie SameSite type."]
+            #[serde(rename = "sameSite")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub same_site: Option<CookieSameSite>,
+            #[doc = "Cookie Priority"]
+            #[serde(rename = "priority")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub priority: CookiePriority,
+            #[doc = "Cookie source scheme type."]
+            #[serde(rename = "sourceScheme")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub source_scheme: CookieSourceScheme,
+            #[doc = "Cookie source port. Valid values are {-1, [1, 65535]}, -1 indicates an unspecified port.\nAn unspecified port value allows protocol clients to emulate legacy cookie scope for the port.\nThis is a temporary ability and it will be removed in the future."]
+            #[serde(rename = "sourcePort")]
+            pub source_port: i64,
+            #[doc = "Cookie partition key."]
+            #[serde(rename = "partitionKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub partition_key: Option<CookiePartitionKey>,
+            #[doc = "True if cookie partition key is opaque."]
+            #[serde(rename = "partitionKeyOpaque")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub partition_key_opaque: Option<bool>,
+        }
+        impl Cookie {
+            pub fn builder() -> CookieBuilder {
+                CookieBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CookieBuilder {
+            name: Option<String>,
+            value: Option<String>,
+            domain: Option<String>,
+            path: Option<String>,
+            expires: Option<f64>,
+            size: Option<i64>,
+            http_only: Option<bool>,
+            secure: Option<bool>,
+            session: Option<bool>,
+            same_site: Option<CookieSameSite>,
+            priority: Option<CookiePriority>,
+            source_scheme: Option<CookieSourceScheme>,
+            source_port: Option<i64>,
+            partition_key: Option<CookiePartitionKey>,
+            partition_key_opaque: Option<bool>,
+        }
+        impl CookieBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn domain(mut self, domain: impl Into<String>) -> Self {
+                self.domain = Some(domain.into());
+                self
+            }
+            pub fn path(mut self, path: impl Into<String>) -> Self {
+                self.path = Some(path.into());
+                self
+            }
+            pub fn expires(mut self, expires: impl Into<f64>) -> Self {
+                self.expires = Some(expires.into());
+                self
+            }
+            pub fn size(mut self, size: impl Into<i64>) -> Self {
+                self.size = Some(size.into());
+                self
+            }
+            pub fn http_only(mut self, http_only: impl Into<bool>) -> Self {
+                self.http_only = Some(http_only.into());
+                self
+            }
+            pub fn secure(mut self, secure: impl Into<bool>) -> Self {
+                self.secure = Some(secure.into());
+                self
+            }
+            pub fn session(mut self, session: impl Into<bool>) -> Self {
+                self.session = Some(session.into());
+                self
+            }
+            pub fn same_site(mut self, same_site: impl Into<CookieSameSite>) -> Self {
+                self.same_site = Some(same_site.into());
+                self
+            }
+            pub fn priority(mut self, priority: impl Into<CookiePriority>) -> Self {
+                self.priority = Some(priority.into());
+                self
+            }
+            pub fn source_scheme(mut self, source_scheme: impl Into<CookieSourceScheme>) -> Self {
+                self.source_scheme = Some(source_scheme.into());
+                self
+            }
+            pub fn source_port(mut self, source_port: impl Into<i64>) -> Self {
+                self.source_port = Some(source_port.into());
+                self
+            }
+            pub fn partition_key(mut self, partition_key: impl Into<CookiePartitionKey>) -> Self {
+                self.partition_key = Some(partition_key.into());
+                self
+            }
+            pub fn partition_key_opaque(mut self, partition_key_opaque: impl Into<bool>) -> Self {
+                self.partition_key_opaque = Some(partition_key_opaque.into());
+                self
+            }
+            pub fn build(self) -> Result<Cookie, String> {
+                Ok(Cookie {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    domain: self.domain.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(domain))
+                    })?,
+                    path: self.path.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(path))
+                    })?,
+                    expires: self.expires.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expires))
+                    })?,
+                    size: self.size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(size))
+                    })?,
+                    http_only: self.http_only.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(http_only))
+                    })?,
+                    secure: self.secure.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(secure))
+                    })?,
+                    session: self.session.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(session))
+                    })?,
+                    same_site: self.same_site,
+                    priority: self.priority.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(priority))
+                    })?,
+                    source_scheme: self.source_scheme.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source_scheme))
+                    })?,
+                    source_port: self.source_port.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source_port))
+                    })?,
+                    partition_key: self.partition_key,
+                    partition_key_opaque: self.partition_key_opaque,
+                })
+            }
+        }
+        impl Cookie {
+            pub const IDENTIFIER: &'static str = "Network.Cookie";
+        }
+        #[doc = "Types of reasons why a cookie may not be stored from a response."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SetCookieBlockedReason {
+            #[doc = "The cookie had the \"Secure\" attribute but was not received over a secure connection."]
+            #[serde(rename = "SecureOnly")]
+            SecureOnly,
+            #[doc = "The cookie had the \"SameSite=Strict\" attribute but came from a cross-origin response.\nThis includes navigation requests initiated by other origins."]
+            #[serde(rename = "SameSiteStrict")]
+            SameSiteStrict,
+            #[doc = "The cookie had the \"SameSite=Lax\" attribute but came from a cross-origin response."]
+            #[serde(rename = "SameSiteLax")]
+            SameSiteLax,
+            #[doc = "The cookie didn't specify a \"SameSite\" attribute and was defaulted to \"SameSite=Lax\" and\nbroke the same rules specified in the SameSiteLax value."]
+            #[serde(rename = "SameSiteUnspecifiedTreatedAsLax")]
+            SameSiteUnspecifiedTreatedAsLax,
+            #[doc = "The cookie had the \"SameSite=None\" attribute but did not specify the \"Secure\" attribute,\nwhich is required in order to use \"SameSite=None\"."]
+            #[serde(rename = "SameSiteNoneInsecure")]
+            SameSiteNoneInsecure,
+            #[doc = "The cookie was not stored due to user preferences."]
+            #[serde(rename = "UserPreferences")]
+            UserPreferences,
+            #[doc = "The cookie was blocked due to third-party cookie phaseout."]
+            #[serde(rename = "ThirdPartyPhaseout")]
+            ThirdPartyPhaseout,
+            #[doc = "The cookie was blocked by third-party cookie blocking between sites in\nthe same First-Party Set."]
+            #[serde(rename = "ThirdPartyBlockedInFirstPartySet")]
+            ThirdPartyBlockedInFirstPartySet,
+            #[doc = "The syntax of the Set-Cookie header of the response was invalid."]
+            #[serde(rename = "SyntaxError")]
+            SyntaxError,
+            #[doc = "The scheme of the connection is not allowed to store cookies."]
+            #[serde(rename = "SchemeNotSupported")]
+            SchemeNotSupported,
+            #[doc = "The cookie was not sent over a secure connection and would have overwritten a cookie with\nthe Secure attribute."]
+            #[serde(rename = "OverwriteSecure")]
+            OverwriteSecure,
+            #[doc = "The cookie's domain attribute was invalid with regards to the current host url."]
+            #[serde(rename = "InvalidDomain")]
+            InvalidDomain,
+            #[doc = "The cookie used the \"__Secure-\" or \"__Host-\" prefix in its name and broke the additional\nrules applied to cookies with these prefixes as defined in\nhttps://tools.ietf.org/html/draft-west-cookie-prefixes-05"]
+            #[serde(rename = "InvalidPrefix")]
+            InvalidPrefix,
+            #[doc = "An unknown error was encountered when trying to store this cookie."]
+            #[serde(rename = "UnknownError")]
+            UnknownError,
+            #[doc = "The cookie had the \"SameSite=Strict\" attribute but came from a response\nwith the same registrable domain but a different scheme.\nThis includes navigation requests initiated by other origins.\nThis is the \"Schemeful Same-Site\" version of the blocked reason."]
+            #[serde(rename = "SchemefulSameSiteStrict")]
+            SchemefulSameSiteStrict,
+            #[doc = "The cookie had the \"SameSite=Lax\" attribute but came from a response\nwith the same registrable domain but a different scheme.\nThis is the \"Schemeful Same-Site\" version of the blocked reason."]
+            #[serde(rename = "SchemefulSameSiteLax")]
+            SchemefulSameSiteLax,
+            #[doc = "The cookie didn't specify a \"SameSite\" attribute and was defaulted to\n\"SameSite=Lax\" and broke the same rules specified in the SchemefulSameSiteLax\nvalue.\nThis is the \"Schemeful Same-Site\" version of the blocked reason."]
+            #[serde(rename = "SchemefulSameSiteUnspecifiedTreatedAsLax")]
+            SchemefulSameSiteUnspecifiedTreatedAsLax,
+            #[doc = "The cookie had the \"SameParty\" attribute but came from a cross-party response."]
+            #[serde(rename = "SamePartyFromCrossPartyContext")]
+            SamePartyFromCrossPartyContext,
+            #[doc = "The cookie had the \"SameParty\" attribute but did not specify the \"Secure\" attribute\n(which is required in order to use \"SameParty\"); or specified the \"SameSite=Strict\"\nattribute (which is forbidden when using \"SameParty\")."]
+            #[serde(rename = "SamePartyConflictsWithOtherAttributes")]
+            SamePartyConflictsWithOtherAttributes,
+            #[doc = "The cookie's name/value pair size exceeded the size limit defined in\nRFC6265bis."]
+            #[serde(rename = "NameValuePairExceedsMaxSize")]
+            NameValuePairExceedsMaxSize,
+            #[doc = "The cookie contained a forbidden ASCII control character, or the tab\ncharacter if it appears in the middle of the cookie name, value, an\nattribute name, or an attribute value."]
+            #[serde(rename = "DisallowedCharacter")]
+            DisallowedCharacter,
+            #[doc = "Cookie contains no content or only whitespace."]
+            #[serde(rename = "NoCookieContent")]
+            NoCookieContent,
+        }
+        impl AsRef<str> for SetCookieBlockedReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SetCookieBlockedReason::SecureOnly => "SecureOnly",
+                    SetCookieBlockedReason::SameSiteStrict => "SameSiteStrict",
+                    SetCookieBlockedReason::SameSiteLax => "SameSiteLax",
+                    SetCookieBlockedReason::SameSiteUnspecifiedTreatedAsLax => {
+                        "SameSiteUnspecifiedTreatedAsLax"
+                    }
+                    SetCookieBlockedReason::SameSiteNoneInsecure => "SameSiteNoneInsecure",
+                    SetCookieBlockedReason::UserPreferences => "UserPreferences",
+                    SetCookieBlockedReason::ThirdPartyPhaseout => "ThirdPartyPhaseout",
+                    SetCookieBlockedReason::ThirdPartyBlockedInFirstPartySet => {
+                        "ThirdPartyBlockedInFirstPartySet"
+                    }
+                    SetCookieBlockedReason::SyntaxError => "SyntaxError",
+                    SetCookieBlockedReason::SchemeNotSupported => "SchemeNotSupported",
+                    SetCookieBlockedReason::OverwriteSecure => "OverwriteSecure",
+                    SetCookieBlockedReason::InvalidDomain => "InvalidDomain",
+                    SetCookieBlockedReason::InvalidPrefix => "InvalidPrefix",
+                    SetCookieBlockedReason::UnknownError => "UnknownError",
+                    SetCookieBlockedReason::SchemefulSameSiteStrict => "SchemefulSameSiteStrict",
+                    SetCookieBlockedReason::SchemefulSameSiteLax => "SchemefulSameSiteLax",
+                    SetCookieBlockedReason::SchemefulSameSiteUnspecifiedTreatedAsLax => {
+                        "SchemefulSameSiteUnspecifiedTreatedAsLax"
+                    }
+                    SetCookieBlockedReason::SamePartyFromCrossPartyContext => {
+                        "SamePartyFromCrossPartyContext"
+                    }
+                    SetCookieBlockedReason::SamePartyConflictsWithOtherAttributes => {
+                        "SamePartyConflictsWithOtherAttributes"
+                    }
+                    SetCookieBlockedReason::NameValuePairExceedsMaxSize => {
+                        "NameValuePairExceedsMaxSize"
+                    }
+                    SetCookieBlockedReason::DisallowedCharacter => "DisallowedCharacter",
+                    SetCookieBlockedReason::NoCookieContent => "NoCookieContent",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SetCookieBlockedReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "SecureOnly" | "secureonly" => Ok(SetCookieBlockedReason::SecureOnly),
+                    "SameSiteStrict" | "samesitestrict" => {
+                        Ok(SetCookieBlockedReason::SameSiteStrict)
+                    }
+                    "SameSiteLax" | "samesitelax" => Ok(SetCookieBlockedReason::SameSiteLax),
+                    "SameSiteUnspecifiedTreatedAsLax" | "samesiteunspecifiedtreatedaslax" => {
+                        Ok(SetCookieBlockedReason::SameSiteUnspecifiedTreatedAsLax)
+                    }
+                    "SameSiteNoneInsecure" | "samesitenoneinsecure" => {
+                        Ok(SetCookieBlockedReason::SameSiteNoneInsecure)
+                    }
+                    "UserPreferences" | "userpreferences" => {
+                        Ok(SetCookieBlockedReason::UserPreferences)
+                    }
+                    "ThirdPartyPhaseout" | "thirdpartyphaseout" => {
+                        Ok(SetCookieBlockedReason::ThirdPartyPhaseout)
+                    }
+                    "ThirdPartyBlockedInFirstPartySet" | "thirdpartyblockedinfirstpartyset" => {
+                        Ok(SetCookieBlockedReason::ThirdPartyBlockedInFirstPartySet)
+                    }
+                    "SyntaxError" | "syntaxerror" => Ok(SetCookieBlockedReason::SyntaxError),
+                    "SchemeNotSupported" | "schemenotsupported" => {
+                        Ok(SetCookieBlockedReason::SchemeNotSupported)
+                    }
+                    "OverwriteSecure" | "overwritesecure" => {
+                        Ok(SetCookieBlockedReason::OverwriteSecure)
+                    }
+                    "InvalidDomain" | "invaliddomain" => Ok(SetCookieBlockedReason::InvalidDomain),
+                    "InvalidPrefix" | "invalidprefix" => Ok(SetCookieBlockedReason::InvalidPrefix),
+                    "UnknownError" | "unknownerror" => Ok(SetCookieBlockedReason::UnknownError),
+                    "SchemefulSameSiteStrict" | "schemefulsamesitestrict" => {
+                        Ok(SetCookieBlockedReason::SchemefulSameSiteStrict)
+                    }
+                    "SchemefulSameSiteLax" | "schemefulsamesitelax" => {
+                        Ok(SetCookieBlockedReason::SchemefulSameSiteLax)
+                    }
+                    "SchemefulSameSiteUnspecifiedTreatedAsLax"
+                    | "schemefulsamesiteunspecifiedtreatedaslax" => {
+                        Ok(SetCookieBlockedReason::SchemefulSameSiteUnspecifiedTreatedAsLax)
+                    }
+                    "SamePartyFromCrossPartyContext" | "samepartyfromcrosspartycontext" => {
+                        Ok(SetCookieBlockedReason::SamePartyFromCrossPartyContext)
+                    }
+                    "SamePartyConflictsWithOtherAttributes"
+                    | "samepartyconflictswithotherattributes" => {
+                        Ok(SetCookieBlockedReason::SamePartyConflictsWithOtherAttributes)
+                    }
+                    "NameValuePairExceedsMaxSize" | "namevaluepairexceedsmaxsize" => {
+                        Ok(SetCookieBlockedReason::NameValuePairExceedsMaxSize)
+                    }
+                    "DisallowedCharacter" | "disallowedcharacter" => {
+                        Ok(SetCookieBlockedReason::DisallowedCharacter)
+                    }
+                    "NoCookieContent" | "nocookiecontent" => {
+                        Ok(SetCookieBlockedReason::NoCookieContent)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Types of reasons why a cookie may not be sent with a request."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CookieBlockedReason {
+            #[doc = "The cookie had the \"Secure\" attribute and the connection was not secure."]
+            #[serde(rename = "SecureOnly")]
+            SecureOnly,
+            #[doc = "The cookie's path was not within the request url's path."]
+            #[serde(rename = "NotOnPath")]
+            NotOnPath,
+            #[doc = "The cookie's domain is not configured to match the request url's domain, even though they\nshare a common TLD+1 (TLD+1 of foo.bar.example.com is example.com)."]
+            #[serde(rename = "DomainMismatch")]
+            DomainMismatch,
+            #[doc = "The cookie had the \"SameSite=Strict\" attribute and the request was made on on a different\nsite. This includes navigation requests initiated by other sites."]
+            #[serde(rename = "SameSiteStrict")]
+            SameSiteStrict,
+            #[doc = "The cookie had the \"SameSite=Lax\" attribute and the request was made on a different site.\nThis does not include navigation requests initiated by other sites."]
+            #[serde(rename = "SameSiteLax")]
+            SameSiteLax,
+            #[doc = "The cookie didn't specify a SameSite attribute when it was stored and was defaulted to\n\"SameSite=Lax\" and broke the same rules specified in the SameSiteLax value. The cookie had\nto have been set with \"SameSite=None\" to enable third-party usage."]
+            #[serde(rename = "SameSiteUnspecifiedTreatedAsLax")]
+            SameSiteUnspecifiedTreatedAsLax,
+            #[doc = "The cookie had the \"SameSite=None\" attribute and the connection was not secure. Cookies\nwithout SameSite restrictions must be sent over a secure connection."]
+            #[serde(rename = "SameSiteNoneInsecure")]
+            SameSiteNoneInsecure,
+            #[doc = "The cookie was not sent due to user preferences."]
+            #[serde(rename = "UserPreferences")]
+            UserPreferences,
+            #[doc = "The cookie was blocked due to third-party cookie phaseout."]
+            #[serde(rename = "ThirdPartyPhaseout")]
+            ThirdPartyPhaseout,
+            #[doc = "The cookie was blocked by third-party cookie blocking between sites in\nthe same First-Party Set."]
+            #[serde(rename = "ThirdPartyBlockedInFirstPartySet")]
+            ThirdPartyBlockedInFirstPartySet,
+            #[doc = "An unknown error was encountered when trying to send this cookie."]
+            #[serde(rename = "UnknownError")]
+            UnknownError,
+            #[doc = "The cookie had the \"SameSite=Strict\" attribute but came from a response\nwith the same registrable domain but a different scheme.\nThis includes navigation requests initiated by other origins.\nThis is the \"Schemeful Same-Site\" version of the blocked reason."]
+            #[serde(rename = "SchemefulSameSiteStrict")]
+            SchemefulSameSiteStrict,
+            #[doc = "The cookie had the \"SameSite=Lax\" attribute but came from a response\nwith the same registrable domain but a different scheme.\nThis is the \"Schemeful Same-Site\" version of the blocked reason."]
+            #[serde(rename = "SchemefulSameSiteLax")]
+            SchemefulSameSiteLax,
+            #[doc = "The cookie didn't specify a \"SameSite\" attribute and was defaulted to\n\"SameSite=Lax\" and broke the same rules specified in the SchemefulSameSiteLax\nvalue.\nThis is the \"Schemeful Same-Site\" version of the blocked reason."]
+            #[serde(rename = "SchemefulSameSiteUnspecifiedTreatedAsLax")]
+            SchemefulSameSiteUnspecifiedTreatedAsLax,
+            #[doc = "The cookie had the \"SameParty\" attribute and the request was made from a cross-party context."]
+            #[serde(rename = "SamePartyFromCrossPartyContext")]
+            SamePartyFromCrossPartyContext,
+            #[doc = "The cookie's name/value pair size exceeded the size limit defined in\nRFC6265bis."]
+            #[serde(rename = "NameValuePairExceedsMaxSize")]
+            NameValuePairExceedsMaxSize,
+            #[doc = "The cookie's source port value does not match the request origin's port."]
+            #[serde(rename = "PortMismatch")]
+            PortMismatch,
+            #[doc = "The cookie's source scheme value does not match the request origin's scheme."]
+            #[serde(rename = "SchemeMismatch")]
+            SchemeMismatch,
+            #[doc = "Unpartitioned cookie access from an anonymous context was blocked."]
+            #[serde(rename = "AnonymousContext")]
+            AnonymousContext,
+        }
+        impl AsRef<str> for CookieBlockedReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CookieBlockedReason::SecureOnly => "SecureOnly",
+                    CookieBlockedReason::NotOnPath => "NotOnPath",
+                    CookieBlockedReason::DomainMismatch => "DomainMismatch",
+                    CookieBlockedReason::SameSiteStrict => "SameSiteStrict",
+                    CookieBlockedReason::SameSiteLax => "SameSiteLax",
+                    CookieBlockedReason::SameSiteUnspecifiedTreatedAsLax => {
+                        "SameSiteUnspecifiedTreatedAsLax"
+                    }
+                    CookieBlockedReason::SameSiteNoneInsecure => "SameSiteNoneInsecure",
+                    CookieBlockedReason::UserPreferences => "UserPreferences",
+                    CookieBlockedReason::ThirdPartyPhaseout => "ThirdPartyPhaseout",
+                    CookieBlockedReason::ThirdPartyBlockedInFirstPartySet => {
+                        "ThirdPartyBlockedInFirstPartySet"
+                    }
+                    CookieBlockedReason::UnknownError => "UnknownError",
+                    CookieBlockedReason::SchemefulSameSiteStrict => "SchemefulSameSiteStrict",
+                    CookieBlockedReason::SchemefulSameSiteLax => "SchemefulSameSiteLax",
+                    CookieBlockedReason::SchemefulSameSiteUnspecifiedTreatedAsLax => {
+                        "SchemefulSameSiteUnspecifiedTreatedAsLax"
+                    }
+                    CookieBlockedReason::SamePartyFromCrossPartyContext => {
+                        "SamePartyFromCrossPartyContext"
+                    }
+                    CookieBlockedReason::NameValuePairExceedsMaxSize => {
+                        "NameValuePairExceedsMaxSize"
+                    }
+                    CookieBlockedReason::PortMismatch => "PortMismatch",
+                    CookieBlockedReason::SchemeMismatch => "SchemeMismatch",
+                    CookieBlockedReason::AnonymousContext => "AnonymousContext",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CookieBlockedReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "SecureOnly" | "secureonly" => Ok(CookieBlockedReason::SecureOnly),
+                    "NotOnPath" | "notonpath" => Ok(CookieBlockedReason::NotOnPath),
+                    "DomainMismatch" | "domainmismatch" => Ok(CookieBlockedReason::DomainMismatch),
+                    "SameSiteStrict" | "samesitestrict" => Ok(CookieBlockedReason::SameSiteStrict),
+                    "SameSiteLax" | "samesitelax" => Ok(CookieBlockedReason::SameSiteLax),
+                    "SameSiteUnspecifiedTreatedAsLax" | "samesiteunspecifiedtreatedaslax" => {
+                        Ok(CookieBlockedReason::SameSiteUnspecifiedTreatedAsLax)
+                    }
+                    "SameSiteNoneInsecure" | "samesitenoneinsecure" => {
+                        Ok(CookieBlockedReason::SameSiteNoneInsecure)
+                    }
+                    "UserPreferences" | "userpreferences" => {
+                        Ok(CookieBlockedReason::UserPreferences)
+                    }
+                    "ThirdPartyPhaseout" | "thirdpartyphaseout" => {
+                        Ok(CookieBlockedReason::ThirdPartyPhaseout)
+                    }
+                    "ThirdPartyBlockedInFirstPartySet" | "thirdpartyblockedinfirstpartyset" => {
+                        Ok(CookieBlockedReason::ThirdPartyBlockedInFirstPartySet)
+                    }
+                    "UnknownError" | "unknownerror" => Ok(CookieBlockedReason::UnknownError),
+                    "SchemefulSameSiteStrict" | "schemefulsamesitestrict" => {
+                        Ok(CookieBlockedReason::SchemefulSameSiteStrict)
+                    }
+                    "SchemefulSameSiteLax" | "schemefulsamesitelax" => {
+                        Ok(CookieBlockedReason::SchemefulSameSiteLax)
+                    }
+                    "SchemefulSameSiteUnspecifiedTreatedAsLax"
+                    | "schemefulsamesiteunspecifiedtreatedaslax" => {
+                        Ok(CookieBlockedReason::SchemefulSameSiteUnspecifiedTreatedAsLax)
+                    }
+                    "SamePartyFromCrossPartyContext" | "samepartyfromcrosspartycontext" => {
+                        Ok(CookieBlockedReason::SamePartyFromCrossPartyContext)
+                    }
+                    "NameValuePairExceedsMaxSize" | "namevaluepairexceedsmaxsize" => {
+                        Ok(CookieBlockedReason::NameValuePairExceedsMaxSize)
+                    }
+                    "PortMismatch" | "portmismatch" => Ok(CookieBlockedReason::PortMismatch),
+                    "SchemeMismatch" | "schememismatch" => Ok(CookieBlockedReason::SchemeMismatch),
+                    "AnonymousContext" | "anonymouscontext" => {
+                        Ok(CookieBlockedReason::AnonymousContext)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Types of reasons why a cookie should have been blocked by 3PCD but is exempted for the request."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CookieExemptionReason {
+            #[doc = "The default value. Cookie with this reason could either be blocked or included."]
+            #[serde(rename = "None")]
+            None,
+            #[doc = "The cookie should have been blocked by 3PCD but is exempted by explicit user setting."]
+            #[serde(rename = "UserSetting")]
+            UserSetting,
+            #[doc = "The cookie should have been blocked by 3PCD but is exempted by metadata mitigation."]
+            #[serde(rename = "TPCDMetadata")]
+            TpcdMetadata,
+            #[doc = "The cookie should have been blocked by 3PCD but is exempted by Deprecation Trial mitigation."]
+            #[serde(rename = "TPCDDeprecationTrial")]
+            TpcdDeprecationTrial,
+            #[doc = "The cookie should have been blocked by 3PCD but is exempted by Top-level Deprecation Trial mitigation."]
+            #[serde(rename = "TopLevelTPCDDeprecationTrial")]
+            TopLevelTpcdDeprecationTrial,
+            #[doc = "The cookie should have been blocked by 3PCD but is exempted by heuristics mitigation."]
+            #[serde(rename = "TPCDHeuristics")]
+            TpcdHeuristics,
+            #[doc = "The cookie should have been blocked by 3PCD but is exempted by Enterprise Policy."]
+            #[serde(rename = "EnterprisePolicy")]
+            EnterprisePolicy,
+            #[doc = "The cookie should have been blocked by 3PCD but is exempted by Storage Access API."]
+            #[serde(rename = "StorageAccess")]
+            StorageAccess,
+            #[doc = "The cookie should have been blocked by 3PCD but is exempted by Top-level Storage Access API."]
+            #[serde(rename = "TopLevelStorageAccess")]
+            TopLevelStorageAccess,
+            #[doc = "The cookie should have been blocked by 3PCD but is exempted by the first-party URL scheme."]
+            #[serde(rename = "Scheme")]
+            Scheme,
+            #[doc = "The cookie was included due to the 'allow-same-site-none-cookies' value being set in the sandboxing policy."]
+            #[serde(rename = "SameSiteNoneCookiesInSandbox")]
+            SameSiteNoneCookiesInSandbox,
+        }
+        impl AsRef<str> for CookieExemptionReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CookieExemptionReason::None => "None",
+                    CookieExemptionReason::UserSetting => "UserSetting",
+                    CookieExemptionReason::TpcdMetadata => "TPCDMetadata",
+                    CookieExemptionReason::TpcdDeprecationTrial => "TPCDDeprecationTrial",
+                    CookieExemptionReason::TopLevelTpcdDeprecationTrial => {
+                        "TopLevelTPCDDeprecationTrial"
+                    }
+                    CookieExemptionReason::TpcdHeuristics => "TPCDHeuristics",
+                    CookieExemptionReason::EnterprisePolicy => "EnterprisePolicy",
+                    CookieExemptionReason::StorageAccess => "StorageAccess",
+                    CookieExemptionReason::TopLevelStorageAccess => "TopLevelStorageAccess",
+                    CookieExemptionReason::Scheme => "Scheme",
+                    CookieExemptionReason::SameSiteNoneCookiesInSandbox => {
+                        "SameSiteNoneCookiesInSandbox"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for CookieExemptionReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "None" | "none" => Ok(CookieExemptionReason::None),
+                    "UserSetting" | "usersetting" => Ok(CookieExemptionReason::UserSetting),
+                    "TPCDMetadata" | "TpcdMetadata" | "tpcdmetadata" => {
+                        Ok(CookieExemptionReason::TpcdMetadata)
+                    }
+                    "TPCDDeprecationTrial" | "TpcdDeprecationTrial" | "tpcddeprecationtrial" => {
+                        Ok(CookieExemptionReason::TpcdDeprecationTrial)
+                    }
+                    "TopLevelTPCDDeprecationTrial"
+                    | "TopLevelTpcdDeprecationTrial"
+                    | "topleveltpcddeprecationtrial" => {
+                        Ok(CookieExemptionReason::TopLevelTpcdDeprecationTrial)
+                    }
+                    "TPCDHeuristics" | "TpcdHeuristics" | "tpcdheuristics" => {
+                        Ok(CookieExemptionReason::TpcdHeuristics)
+                    }
+                    "EnterprisePolicy" | "enterprisepolicy" => {
+                        Ok(CookieExemptionReason::EnterprisePolicy)
+                    }
+                    "StorageAccess" | "storageaccess" => Ok(CookieExemptionReason::StorageAccess),
+                    "TopLevelStorageAccess" | "toplevelstorageaccess" => {
+                        Ok(CookieExemptionReason::TopLevelStorageAccess)
+                    }
+                    "Scheme" | "scheme" => Ok(CookieExemptionReason::Scheme),
+                    "SameSiteNoneCookiesInSandbox" | "samesitenonecookiesinsandbox" => {
+                        Ok(CookieExemptionReason::SameSiteNoneCookiesInSandbox)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "A cookie which was not stored from a response with the corresponding reason.\n[BlockedSetCookieWithReason](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-BlockedSetCookieWithReason)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BlockedSetCookieWithReason {
+            #[doc = "The reason(s) this cookie was blocked."]
+            #[serde(rename = "blockedReasons")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub blocked_reasons: Vec<SetCookieBlockedReason>,
+            #[doc = "The string representing this individual cookie as it would appear in the header.\nThis is not the entire \"cookie\" or \"set-cookie\" header which could have multiple cookies."]
+            #[serde(rename = "cookieLine")]
+            pub cookie_line: String,
+            #[doc = "The cookie object which represents the cookie which was not stored. It is optional because\nsometimes complete cookie information is not available, such as in the case of parsing\nerrors."]
+            #[serde(rename = "cookie")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cookie: Option<Cookie>,
+        }
+        impl BlockedSetCookieWithReason {
+            pub fn new(
+                blocked_reasons: Vec<SetCookieBlockedReason>,
+                cookie_line: impl Into<String>,
+            ) -> Self {
+                Self {
+                    blocked_reasons,
+                    cookie_line: cookie_line.into(),
+                    cookie: None,
+                }
+            }
+        }
+        impl BlockedSetCookieWithReason {
+            pub fn builder() -> BlockedSetCookieWithReasonBuilder {
+                BlockedSetCookieWithReasonBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BlockedSetCookieWithReasonBuilder {
+            blocked_reasons: Option<Vec<SetCookieBlockedReason>>,
+            cookie_line: Option<String>,
+            cookie: Option<Cookie>,
+        }
+        impl BlockedSetCookieWithReasonBuilder {
+            pub fn blocked_reason(
+                mut self,
+                blocked_reason: impl Into<SetCookieBlockedReason>,
+            ) -> Self {
+                let v = self.blocked_reasons.get_or_insert(Vec::new());
+                v.push(blocked_reason.into());
+                self
+            }
+            pub fn blocked_reasons<I, S>(mut self, blocked_reasons: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SetCookieBlockedReason>,
+            {
+                let v = self.blocked_reasons.get_or_insert(Vec::new());
+                for val in blocked_reasons {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn cookie_line(mut self, cookie_line: impl Into<String>) -> Self {
+                self.cookie_line = Some(cookie_line.into());
+                self
+            }
+            pub fn cookie(mut self, cookie: impl Into<Cookie>) -> Self {
+                self.cookie = Some(cookie.into());
+                self
+            }
+            pub fn build(self) -> Result<BlockedSetCookieWithReason, String> {
+                Ok(BlockedSetCookieWithReason {
+                    blocked_reasons: self.blocked_reasons.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(blocked_reasons))
+                    })?,
+                    cookie_line: self.cookie_line.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cookie_line))
+                    })?,
+                    cookie: self.cookie,
+                })
+            }
+        }
+        impl BlockedSetCookieWithReason {
+            pub const IDENTIFIER: &'static str = "Network.BlockedSetCookieWithReason";
+        }
+        #[doc = "A cookie should have been blocked by 3PCD but is exempted and stored from a response with the\ncorresponding reason. A cookie could only have at most one exemption reason.\n[ExemptedSetCookieWithReason](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-ExemptedSetCookieWithReason)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ExemptedSetCookieWithReason {
+            #[doc = "The reason the cookie was exempted."]
+            #[serde(rename = "exemptionReason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub exemption_reason: CookieExemptionReason,
+            #[doc = "The string representing this individual cookie as it would appear in the header."]
+            #[serde(rename = "cookieLine")]
+            pub cookie_line: String,
+            #[doc = "The cookie object representing the cookie."]
+            #[serde(rename = "cookie")]
+            pub cookie: Cookie,
+        }
+        impl ExemptedSetCookieWithReason {
+            pub fn new(
+                exemption_reason: impl Into<CookieExemptionReason>,
+                cookie_line: impl Into<String>,
+                cookie: impl Into<Cookie>,
+            ) -> Self {
+                Self {
+                    exemption_reason: exemption_reason.into(),
+                    cookie_line: cookie_line.into(),
+                    cookie: cookie.into(),
+                }
+            }
+        }
+        impl ExemptedSetCookieWithReason {
+            pub fn builder() -> ExemptedSetCookieWithReasonBuilder {
+                ExemptedSetCookieWithReasonBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ExemptedSetCookieWithReasonBuilder {
+            exemption_reason: Option<CookieExemptionReason>,
+            cookie_line: Option<String>,
+            cookie: Option<Cookie>,
+        }
+        impl ExemptedSetCookieWithReasonBuilder {
+            pub fn exemption_reason(
+                mut self,
+                exemption_reason: impl Into<CookieExemptionReason>,
+            ) -> Self {
+                self.exemption_reason = Some(exemption_reason.into());
+                self
+            }
+            pub fn cookie_line(mut self, cookie_line: impl Into<String>) -> Self {
+                self.cookie_line = Some(cookie_line.into());
+                self
+            }
+            pub fn cookie(mut self, cookie: impl Into<Cookie>) -> Self {
+                self.cookie = Some(cookie.into());
+                self
+            }
+            pub fn build(self) -> Result<ExemptedSetCookieWithReason, String> {
+                Ok(ExemptedSetCookieWithReason {
+                    exemption_reason: self.exemption_reason.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(exemption_reason)
+                        )
+                    })?,
+                    cookie_line: self.cookie_line.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cookie_line))
+                    })?,
+                    cookie: self.cookie.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cookie))
+                    })?,
+                })
+            }
+        }
+        impl ExemptedSetCookieWithReason {
+            pub const IDENTIFIER: &'static str = "Network.ExemptedSetCookieWithReason";
+        }
+        #[doc = "A cookie associated with the request which may or may not be sent with it.\nIncludes the cookies itself and reasons for blocking or exemption.\n[AssociatedCookie](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-AssociatedCookie)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AssociatedCookie {
+            #[doc = "The cookie object representing the cookie which was not sent."]
+            #[serde(rename = "cookie")]
+            pub cookie: Cookie,
+            #[doc = "The reason(s) the cookie was blocked. If empty means the cookie is included."]
+            #[serde(rename = "blockedReasons")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub blocked_reasons: Vec<CookieBlockedReason>,
+            #[doc = "The reason the cookie should have been blocked by 3PCD but is exempted. A cookie could\nonly have at most one exemption reason."]
+            #[serde(rename = "exemptionReason")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub exemption_reason: Option<CookieExemptionReason>,
+        }
+        impl AssociatedCookie {
+            pub fn new(
+                cookie: impl Into<Cookie>,
+                blocked_reasons: Vec<CookieBlockedReason>,
+            ) -> Self {
+                Self {
+                    cookie: cookie.into(),
+                    blocked_reasons,
+                    exemption_reason: None,
+                }
+            }
+        }
+        impl AssociatedCookie {
+            pub fn builder() -> AssociatedCookieBuilder {
+                AssociatedCookieBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AssociatedCookieBuilder {
+            cookie: Option<Cookie>,
+            blocked_reasons: Option<Vec<CookieBlockedReason>>,
+            exemption_reason: Option<CookieExemptionReason>,
+        }
+        impl AssociatedCookieBuilder {
+            pub fn cookie(mut self, cookie: impl Into<Cookie>) -> Self {
+                self.cookie = Some(cookie.into());
+                self
+            }
+            pub fn blocked_reason(
+                mut self,
+                blocked_reason: impl Into<CookieBlockedReason>,
+            ) -> Self {
+                let v = self.blocked_reasons.get_or_insert(Vec::new());
+                v.push(blocked_reason.into());
+                self
+            }
+            pub fn blocked_reasons<I, S>(mut self, blocked_reasons: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CookieBlockedReason>,
+            {
+                let v = self.blocked_reasons.get_or_insert(Vec::new());
+                for val in blocked_reasons {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn exemption_reason(
+                mut self,
+                exemption_reason: impl Into<CookieExemptionReason>,
+            ) -> Self {
+                self.exemption_reason = Some(exemption_reason.into());
+                self
+            }
+            pub fn build(self) -> Result<AssociatedCookie, String> {
+                Ok(AssociatedCookie {
+                    cookie: self.cookie.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cookie))
+                    })?,
+                    blocked_reasons: self.blocked_reasons.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(blocked_reasons))
+                    })?,
+                    exemption_reason: self.exemption_reason,
+                })
+            }
+        }
+        impl AssociatedCookie {
+            pub const IDENTIFIER: &'static str = "Network.AssociatedCookie";
+        }
+        #[doc = "Cookie parameter object\n[CookieParam](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-CookieParam)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CookieParam {
+            #[doc = "Cookie name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Cookie value."]
+            #[serde(rename = "value")]
+            pub value: String,
+            #[doc = "The request-URI to associate with the setting of the cookie. This value can affect the\ndefault domain, path, source port, and source scheme values of the created cookie."]
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[doc = "Cookie domain."]
+            #[serde(rename = "domain")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub domain: Option<String>,
+            #[doc = "Cookie path."]
+            #[serde(rename = "path")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub path: Option<String>,
+            #[doc = "True if cookie is secure."]
+            #[serde(rename = "secure")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub secure: Option<bool>,
+            #[doc = "True if cookie is http-only."]
+            #[serde(rename = "httpOnly")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub http_only: Option<bool>,
+            #[doc = "Cookie SameSite type."]
+            #[serde(rename = "sameSite")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub same_site: Option<CookieSameSite>,
+            #[doc = "Cookie expiration date, session cookie if not set"]
+            #[serde(rename = "expires")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub expires: Option<TimeSinceEpoch>,
+            #[doc = "Cookie Priority."]
+            #[serde(rename = "priority")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub priority: Option<CookiePriority>,
+            #[doc = "True if cookie is SameParty."]
+            #[serde(rename = "sameParty")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub same_party: Option<bool>,
+            #[doc = "Cookie source scheme type."]
+            #[serde(rename = "sourceScheme")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub source_scheme: Option<CookieSourceScheme>,
+            #[doc = "Cookie source port. Valid values are {-1, [1, 65535]}, -1 indicates an unspecified port.\nAn unspecified port value allows protocol clients to emulate legacy cookie scope for the port.\nThis is a temporary ability and it will be removed in the future."]
+            #[serde(rename = "sourcePort")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_port: Option<i64>,
+            #[doc = "Cookie partition key. If not set, the cookie will be set as not partitioned."]
+            #[serde(rename = "partitionKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub partition_key: Option<CookiePartitionKey>,
+        }
+        impl CookieParam {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                    url: None,
+                    domain: None,
+                    path: None,
+                    secure: None,
+                    http_only: None,
+                    same_site: None,
+                    expires: None,
+                    priority: None,
+                    same_party: None,
+                    source_scheme: None,
+                    source_port: None,
+                    partition_key: None,
+                }
+            }
+        }
+        impl CookieParam {
+            pub fn builder() -> CookieParamBuilder {
+                CookieParamBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CookieParamBuilder {
+            name: Option<String>,
+            value: Option<String>,
+            url: Option<String>,
+            domain: Option<String>,
+            path: Option<String>,
+            secure: Option<bool>,
+            http_only: Option<bool>,
+            same_site: Option<CookieSameSite>,
+            expires: Option<TimeSinceEpoch>,
+            priority: Option<CookiePriority>,
+            same_party: Option<bool>,
+            source_scheme: Option<CookieSourceScheme>,
+            source_port: Option<i64>,
+            partition_key: Option<CookiePartitionKey>,
+        }
+        impl CookieParamBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn domain(mut self, domain: impl Into<String>) -> Self {
+                self.domain = Some(domain.into());
+                self
+            }
+            pub fn path(mut self, path: impl Into<String>) -> Self {
+                self.path = Some(path.into());
+                self
+            }
+            pub fn secure(mut self, secure: impl Into<bool>) -> Self {
+                self.secure = Some(secure.into());
+                self
+            }
+            pub fn http_only(mut self, http_only: impl Into<bool>) -> Self {
+                self.http_only = Some(http_only.into());
+                self
+            }
+            pub fn same_site(mut self, same_site: impl Into<CookieSameSite>) -> Self {
+                self.same_site = Some(same_site.into());
+                self
+            }
+            pub fn expires(mut self, expires: impl Into<TimeSinceEpoch>) -> Self {
+                self.expires = Some(expires.into());
+                self
+            }
+            pub fn priority(mut self, priority: impl Into<CookiePriority>) -> Self {
+                self.priority = Some(priority.into());
+                self
+            }
+            pub fn same_party(mut self, same_party: impl Into<bool>) -> Self {
+                self.same_party = Some(same_party.into());
+                self
+            }
+            pub fn source_scheme(mut self, source_scheme: impl Into<CookieSourceScheme>) -> Self {
+                self.source_scheme = Some(source_scheme.into());
+                self
+            }
+            pub fn source_port(mut self, source_port: impl Into<i64>) -> Self {
+                self.source_port = Some(source_port.into());
+                self
+            }
+            pub fn partition_key(mut self, partition_key: impl Into<CookiePartitionKey>) -> Self {
+                self.partition_key = Some(partition_key.into());
+                self
+            }
+            pub fn build(self) -> Result<CookieParam, String> {
+                Ok(CookieParam {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    url: self.url,
+                    domain: self.domain,
+                    path: self.path,
+                    secure: self.secure,
+                    http_only: self.http_only,
+                    same_site: self.same_site,
+                    expires: self.expires,
+                    priority: self.priority,
+                    same_party: self.same_party,
+                    source_scheme: self.source_scheme,
+                    source_port: self.source_port,
+                    partition_key: self.partition_key,
+                })
+            }
+        }
+        impl CookieParam {
+            pub const IDENTIFIER: &'static str = "Network.CookieParam";
+        }
+        #[doc = "Authorization challenge for HTTP status code 401 or 407.\n[AuthChallenge](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-AuthChallenge)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AuthChallenge {
+            #[doc = "Source of the authentication challenge."]
+            #[serde(rename = "source")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub source: Option<AuthChallengeSource>,
+            #[doc = "Origin of the challenger."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "The authentication scheme used, such as basic or digest"]
+            #[serde(rename = "scheme")]
+            pub scheme: String,
+            #[doc = "The realm of the challenge. May be empty."]
+            #[serde(rename = "realm")]
+            pub realm: String,
+        }
+        #[doc = "Source of the authentication challenge."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AuthChallengeSource {
+            #[serde(rename = "Server")]
+            Server,
+            #[serde(rename = "Proxy")]
+            Proxy,
+        }
+        impl AsRef<str> for AuthChallengeSource {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AuthChallengeSource::Server => "Server",
+                    AuthChallengeSource::Proxy => "Proxy",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AuthChallengeSource {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Server" | "server" => Ok(AuthChallengeSource::Server),
+                    "Proxy" | "proxy" => Ok(AuthChallengeSource::Proxy),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl AuthChallenge {
+            pub fn new(
+                origin: impl Into<String>,
+                scheme: impl Into<String>,
+                realm: impl Into<String>,
+            ) -> Self {
+                Self {
+                    origin: origin.into(),
+                    scheme: scheme.into(),
+                    realm: realm.into(),
+                    source: None,
+                }
+            }
+        }
+        impl AuthChallenge {
+            pub fn builder() -> AuthChallengeBuilder {
+                AuthChallengeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AuthChallengeBuilder {
+            source: Option<AuthChallengeSource>,
+            origin: Option<String>,
+            scheme: Option<String>,
+            realm: Option<String>,
+        }
+        impl AuthChallengeBuilder {
+            pub fn source(mut self, source: impl Into<AuthChallengeSource>) -> Self {
+                self.source = Some(source.into());
+                self
+            }
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn scheme(mut self, scheme: impl Into<String>) -> Self {
+                self.scheme = Some(scheme.into());
+                self
+            }
+            pub fn realm(mut self, realm: impl Into<String>) -> Self {
+                self.realm = Some(realm.into());
+                self
+            }
+            pub fn build(self) -> Result<AuthChallenge, String> {
+                Ok(AuthChallenge {
+                    source: self.source,
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    scheme: self.scheme.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scheme))
+                    })?,
+                    realm: self.realm.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(realm))
+                    })?,
+                })
+            }
+        }
+        impl AuthChallenge {
+            pub const IDENTIFIER: &'static str = "Network.AuthChallenge";
+        }
+        #[doc = "Response to an AuthChallenge.\n[AuthChallengeResponse](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-AuthChallengeResponse)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AuthChallengeResponse {
+            #[doc = "The decision on what to do in response to the authorization challenge.  Default means\ndeferring to the default behavior of the net stack, which will likely either the Cancel\nauthentication or display a popup dialog box."]
+            #[serde(rename = "response")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub response: AuthChallengeResponseResponse,
+            #[doc = "The username to provide, possibly empty. Should only be set if response is\nProvideCredentials."]
+            #[serde(rename = "username")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub username: Option<String>,
+            #[doc = "The password to provide, possibly empty. Should only be set if response is\nProvideCredentials."]
+            #[serde(rename = "password")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub password: Option<String>,
+        }
+        #[doc = "The decision on what to do in response to the authorization challenge.  Default means\ndeferring to the default behavior of the net stack, which will likely either the Cancel\nauthentication or display a popup dialog box."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AuthChallengeResponseResponse {
+            #[serde(rename = "Default")]
+            Default,
+            #[serde(rename = "CancelAuth")]
+            CancelAuth,
+            #[serde(rename = "ProvideCredentials")]
+            ProvideCredentials,
+        }
+        impl AsRef<str> for AuthChallengeResponseResponse {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AuthChallengeResponseResponse::Default => "Default",
+                    AuthChallengeResponseResponse::CancelAuth => "CancelAuth",
+                    AuthChallengeResponseResponse::ProvideCredentials => "ProvideCredentials",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AuthChallengeResponseResponse {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Default" | "default" => Ok(AuthChallengeResponseResponse::Default),
+                    "CancelAuth" | "cancelauth" => Ok(AuthChallengeResponseResponse::CancelAuth),
+                    "ProvideCredentials" | "providecredentials" => {
+                        Ok(AuthChallengeResponseResponse::ProvideCredentials)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl AuthChallengeResponse {
+            pub fn new(response: impl Into<AuthChallengeResponseResponse>) -> Self {
+                Self {
+                    response: response.into(),
+                    username: None,
+                    password: None,
+                }
+            }
+        }
+        impl AuthChallengeResponse {
+            pub fn builder() -> AuthChallengeResponseBuilder {
+                AuthChallengeResponseBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AuthChallengeResponseBuilder {
+            response: Option<AuthChallengeResponseResponse>,
+            username: Option<String>,
+            password: Option<String>,
+        }
+        impl AuthChallengeResponseBuilder {
+            pub fn response(mut self, response: impl Into<AuthChallengeResponseResponse>) -> Self {
+                self.response = Some(response.into());
+                self
+            }
+            pub fn username(mut self, username: impl Into<String>) -> Self {
+                self.username = Some(username.into());
+                self
+            }
+            pub fn password(mut self, password: impl Into<String>) -> Self {
+                self.password = Some(password.into());
+                self
+            }
+            pub fn build(self) -> Result<AuthChallengeResponse, String> {
+                Ok(AuthChallengeResponse {
+                    response: self.response.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(response))
+                    })?,
+                    username: self.username,
+                    password: self.password,
+                })
+            }
+        }
+        impl AuthChallengeResponse {
+            pub const IDENTIFIER: &'static str = "Network.AuthChallengeResponse";
+        }
+        #[doc = "Stages of the interception to begin intercepting. Request will intercept before the request is\nsent. Response will intercept after the response is received."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum InterceptionStage {
+            #[serde(rename = "Request")]
+            Request,
+            #[serde(rename = "HeadersReceived")]
+            HeadersReceived,
+        }
+        impl AsRef<str> for InterceptionStage {
+            fn as_ref(&self) -> &str {
+                match self {
+                    InterceptionStage::Request => "Request",
+                    InterceptionStage::HeadersReceived => "HeadersReceived",
+                }
+            }
+        }
+        impl ::std::str::FromStr for InterceptionStage {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Request" | "request" => Ok(InterceptionStage::Request),
+                    "HeadersReceived" | "headersreceived" => Ok(InterceptionStage::HeadersReceived),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Request pattern for interception.\n[RequestPattern](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-RequestPattern)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RequestPattern {
+            #[doc = "Wildcards (`'*'` -> zero or more, `'?'` -> exactly one) are allowed. Escape character is\nbackslash. Omitting is equivalent to `\"*\"`."]
+            #[serde(rename = "urlPattern")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url_pattern: Option<String>,
+            #[doc = "If set, only requests for matching resource types will be intercepted."]
+            #[serde(rename = "resourceType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub resource_type: Option<ResourceType>,
+            #[doc = "Stage at which to begin intercepting requests. Default is Request."]
+            #[serde(rename = "interceptionStage")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub interception_stage: Option<InterceptionStage>,
+        }
+        impl RequestPattern {
+            pub fn builder() -> RequestPatternBuilder {
+                RequestPatternBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestPatternBuilder {
+            url_pattern: Option<String>,
+            resource_type: Option<ResourceType>,
+            interception_stage: Option<InterceptionStage>,
+        }
+        impl RequestPatternBuilder {
+            pub fn url_pattern(mut self, url_pattern: impl Into<String>) -> Self {
+                self.url_pattern = Some(url_pattern.into());
+                self
+            }
+            pub fn resource_type(mut self, resource_type: impl Into<ResourceType>) -> Self {
+                self.resource_type = Some(resource_type.into());
+                self
+            }
+            pub fn interception_stage(
+                mut self,
+                interception_stage: impl Into<InterceptionStage>,
+            ) -> Self {
+                self.interception_stage = Some(interception_stage.into());
+                self
+            }
+            pub fn build(self) -> RequestPattern {
+                RequestPattern {
+                    url_pattern: self.url_pattern,
+                    resource_type: self.resource_type,
+                    interception_stage: self.interception_stage,
+                }
+            }
+        }
+        impl RequestPattern {
+            pub const IDENTIFIER: &'static str = "Network.RequestPattern";
+        }
+        #[doc = "Information about a signed exchange signature.\nhttps://wicg.github.io/webpackage/draft-yasskin-httpbis-origin-signed-exchanges-impl.html#rfc.section.3.1\n[SignedExchangeSignature](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-SignedExchangeSignature)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SignedExchangeSignature {
+            #[doc = "Signed exchange signature label."]
+            #[serde(rename = "label")]
+            pub label: String,
+            #[doc = "The hex string of signed exchange signature."]
+            #[serde(rename = "signature")]
+            pub signature: String,
+            #[doc = "Signed exchange signature integrity."]
+            #[serde(rename = "integrity")]
+            pub integrity: String,
+            #[doc = "Signed exchange signature cert Url."]
+            #[serde(rename = "certUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cert_url: Option<String>,
+            #[doc = "The hex string of signed exchange signature cert sha256."]
+            #[serde(rename = "certSha256")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cert_sha256: Option<String>,
+            #[doc = "Signed exchange signature validity Url."]
+            #[serde(rename = "validityUrl")]
+            pub validity_url: String,
+            #[doc = "Signed exchange signature date."]
+            #[serde(rename = "date")]
+            pub date: i64,
+            #[doc = "Signed exchange signature expires."]
+            #[serde(rename = "expires")]
+            pub expires: i64,
+            #[doc = "The encoded certificates."]
+            #[serde(rename = "certificates")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub certificates: Option<Vec<String>>,
+        }
+        impl SignedExchangeSignature {
+            pub fn builder() -> SignedExchangeSignatureBuilder {
+                SignedExchangeSignatureBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SignedExchangeSignatureBuilder {
+            label: Option<String>,
+            signature: Option<String>,
+            integrity: Option<String>,
+            cert_url: Option<String>,
+            cert_sha256: Option<String>,
+            validity_url: Option<String>,
+            date: Option<i64>,
+            expires: Option<i64>,
+            certificates: Option<Vec<String>>,
+        }
+        impl SignedExchangeSignatureBuilder {
+            pub fn label(mut self, label: impl Into<String>) -> Self {
+                self.label = Some(label.into());
+                self
+            }
+            pub fn signature(mut self, signature: impl Into<String>) -> Self {
+                self.signature = Some(signature.into());
+                self
+            }
+            pub fn integrity(mut self, integrity: impl Into<String>) -> Self {
+                self.integrity = Some(integrity.into());
+                self
+            }
+            pub fn cert_url(mut self, cert_url: impl Into<String>) -> Self {
+                self.cert_url = Some(cert_url.into());
+                self
+            }
+            pub fn cert_sha256(mut self, cert_sha256: impl Into<String>) -> Self {
+                self.cert_sha256 = Some(cert_sha256.into());
+                self
+            }
+            pub fn validity_url(mut self, validity_url: impl Into<String>) -> Self {
+                self.validity_url = Some(validity_url.into());
+                self
+            }
+            pub fn date(mut self, date: impl Into<i64>) -> Self {
+                self.date = Some(date.into());
+                self
+            }
+            pub fn expires(mut self, expires: impl Into<i64>) -> Self {
+                self.expires = Some(expires.into());
+                self
+            }
+            pub fn certificate(mut self, certificate: impl Into<String>) -> Self {
+                let v = self.certificates.get_or_insert(Vec::new());
+                v.push(certificate.into());
+                self
+            }
+            pub fn certificates<I, S>(mut self, certificates: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.certificates.get_or_insert(Vec::new());
+                for val in certificates {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SignedExchangeSignature, String> {
+                Ok(SignedExchangeSignature {
+                    label: self.label.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(label))
+                    })?,
+                    signature: self.signature.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(signature))
+                    })?,
+                    integrity: self.integrity.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(integrity))
+                    })?,
+                    cert_url: self.cert_url,
+                    cert_sha256: self.cert_sha256,
+                    validity_url: self.validity_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(validity_url))
+                    })?,
+                    date: self.date.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(date))
+                    })?,
+                    expires: self.expires.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expires))
+                    })?,
+                    certificates: self.certificates,
+                })
+            }
+        }
+        impl SignedExchangeSignature {
+            pub const IDENTIFIER: &'static str = "Network.SignedExchangeSignature";
+        }
+        #[doc = "Information about a signed exchange header.\nhttps://wicg.github.io/webpackage/draft-yasskin-httpbis-origin-signed-exchanges-impl.html#cbor-representation\n[SignedExchangeHeader](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-SignedExchangeHeader)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SignedExchangeHeader {
+            #[doc = "Signed exchange request URL."]
+            #[serde(rename = "requestUrl")]
+            pub request_url: String,
+            #[doc = "Signed exchange response code."]
+            #[serde(rename = "responseCode")]
+            pub response_code: i64,
+            #[doc = "Signed exchange response headers."]
+            #[serde(rename = "responseHeaders")]
+            pub response_headers: Headers,
+            #[doc = "Signed exchange response signature."]
+            #[serde(rename = "signatures")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub signatures: Vec<SignedExchangeSignature>,
+            #[doc = "Signed exchange header integrity hash in the form of `sha256-<base64-hash-value>`."]
+            #[serde(rename = "headerIntegrity")]
+            pub header_integrity: String,
+        }
+        impl SignedExchangeHeader {
+            pub fn builder() -> SignedExchangeHeaderBuilder {
+                SignedExchangeHeaderBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SignedExchangeHeaderBuilder {
+            request_url: Option<String>,
+            response_code: Option<i64>,
+            response_headers: Option<Headers>,
+            signatures: Option<Vec<SignedExchangeSignature>>,
+            header_integrity: Option<String>,
+        }
+        impl SignedExchangeHeaderBuilder {
+            pub fn request_url(mut self, request_url: impl Into<String>) -> Self {
+                self.request_url = Some(request_url.into());
+                self
+            }
+            pub fn response_code(mut self, response_code: impl Into<i64>) -> Self {
+                self.response_code = Some(response_code.into());
+                self
+            }
+            pub fn response_headers(mut self, response_headers: impl Into<Headers>) -> Self {
+                self.response_headers = Some(response_headers.into());
+                self
+            }
+            pub fn signature(mut self, signature: impl Into<SignedExchangeSignature>) -> Self {
+                let v = self.signatures.get_or_insert(Vec::new());
+                v.push(signature.into());
+                self
+            }
+            pub fn signatures<I, S>(mut self, signatures: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SignedExchangeSignature>,
+            {
+                let v = self.signatures.get_or_insert(Vec::new());
+                for val in signatures {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn header_integrity(mut self, header_integrity: impl Into<String>) -> Self {
+                self.header_integrity = Some(header_integrity.into());
+                self
+            }
+            pub fn build(self) -> Result<SignedExchangeHeader, String> {
+                Ok(SignedExchangeHeader {
+                    request_url: self.request_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_url))
+                    })?,
+                    response_code: self.response_code.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(response_code))
+                    })?,
+                    response_headers: self.response_headers.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(response_headers)
+                        )
+                    })?,
+                    signatures: self.signatures.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(signatures))
+                    })?,
+                    header_integrity: self.header_integrity.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(header_integrity)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl SignedExchangeHeader {
+            pub const IDENTIFIER: &'static str = "Network.SignedExchangeHeader";
+        }
+        #[doc = "Field type for a signed exchange related error."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SignedExchangeErrorField {
+            #[serde(rename = "signatureSig")]
+            SignatureSig,
+            #[serde(rename = "signatureIntegrity")]
+            SignatureIntegrity,
+            #[serde(rename = "signatureCertUrl")]
+            SignatureCertUrl,
+            #[serde(rename = "signatureCertSha256")]
+            SignatureCertSha256,
+            #[serde(rename = "signatureValidityUrl")]
+            SignatureValidityUrl,
+            #[serde(rename = "signatureTimestamps")]
+            SignatureTimestamps,
+        }
+        impl AsRef<str> for SignedExchangeErrorField {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SignedExchangeErrorField::SignatureSig => "signatureSig",
+                    SignedExchangeErrorField::SignatureIntegrity => "signatureIntegrity",
+                    SignedExchangeErrorField::SignatureCertUrl => "signatureCertUrl",
+                    SignedExchangeErrorField::SignatureCertSha256 => "signatureCertSha256",
+                    SignedExchangeErrorField::SignatureValidityUrl => "signatureValidityUrl",
+                    SignedExchangeErrorField::SignatureTimestamps => "signatureTimestamps",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SignedExchangeErrorField {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "signatureSig" | "SignatureSig" | "signaturesig" => {
+                        Ok(SignedExchangeErrorField::SignatureSig)
+                    }
+                    "signatureIntegrity" | "SignatureIntegrity" | "signatureintegrity" => {
+                        Ok(SignedExchangeErrorField::SignatureIntegrity)
+                    }
+                    "signatureCertUrl" | "SignatureCertUrl" | "signaturecerturl" => {
+                        Ok(SignedExchangeErrorField::SignatureCertUrl)
+                    }
+                    "signatureCertSha256" | "SignatureCertSha256" | "signaturecertsha256" => {
+                        Ok(SignedExchangeErrorField::SignatureCertSha256)
+                    }
+                    "signatureValidityUrl" | "SignatureValidityUrl" | "signaturevalidityurl" => {
+                        Ok(SignedExchangeErrorField::SignatureValidityUrl)
+                    }
+                    "signatureTimestamps" | "SignatureTimestamps" | "signaturetimestamps" => {
+                        Ok(SignedExchangeErrorField::SignatureTimestamps)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Information about a signed exchange response.\n[SignedExchangeError](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-SignedExchangeError)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SignedExchangeError {
+            #[doc = "Error message."]
+            #[serde(rename = "message")]
+            pub message: String,
+            #[doc = "The index of the signature which caused the error."]
+            #[serde(rename = "signatureIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub signature_index: Option<i64>,
+            #[doc = "The field which caused the error."]
+            #[serde(rename = "errorField")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub error_field: Option<SignedExchangeErrorField>,
+        }
+        impl SignedExchangeError {
+            pub fn new(message: impl Into<String>) -> Self {
+                Self {
+                    message: message.into(),
+                    signature_index: None,
+                    error_field: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for SignedExchangeError {
+            fn from(url: T) -> Self {
+                SignedExchangeError::new(url)
+            }
+        }
+        impl SignedExchangeError {
+            pub fn builder() -> SignedExchangeErrorBuilder {
+                SignedExchangeErrorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SignedExchangeErrorBuilder {
+            message: Option<String>,
+            signature_index: Option<i64>,
+            error_field: Option<SignedExchangeErrorField>,
+        }
+        impl SignedExchangeErrorBuilder {
+            pub fn message(mut self, message: impl Into<String>) -> Self {
+                self.message = Some(message.into());
+                self
+            }
+            pub fn signature_index(mut self, signature_index: impl Into<i64>) -> Self {
+                self.signature_index = Some(signature_index.into());
+                self
+            }
+            pub fn error_field(mut self, error_field: impl Into<SignedExchangeErrorField>) -> Self {
+                self.error_field = Some(error_field.into());
+                self
+            }
+            pub fn build(self) -> Result<SignedExchangeError, String> {
+                Ok(SignedExchangeError {
+                    message: self.message.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(message))
+                    })?,
+                    signature_index: self.signature_index,
+                    error_field: self.error_field,
+                })
+            }
+        }
+        impl SignedExchangeError {
+            pub const IDENTIFIER: &'static str = "Network.SignedExchangeError";
+        }
+        #[doc = "Information about a signed exchange response.\n[SignedExchangeInfo](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-SignedExchangeInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SignedExchangeInfo {
+            #[doc = "The outer response of signed HTTP exchange which was received from network."]
+            #[serde(rename = "outerResponse")]
+            pub outer_response: Response,
+            #[doc = "Whether network response for the signed exchange was accompanied by\nextra headers."]
+            #[serde(rename = "hasExtraInfo")]
+            pub has_extra_info: bool,
+            #[doc = "Information about the signed exchange header."]
+            #[serde(rename = "header")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub header: Option<SignedExchangeHeader>,
+            #[doc = "Security details for the signed exchange header."]
+            #[serde(rename = "securityDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_details: Option<SecurityDetails>,
+            #[doc = "Errors occurred while handling the signed exchange."]
+            #[serde(rename = "errors")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub errors: Option<Vec<SignedExchangeError>>,
+        }
+        impl SignedExchangeInfo {
+            pub fn new(
+                outer_response: impl Into<Response>,
+                has_extra_info: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    outer_response: outer_response.into(),
+                    has_extra_info: has_extra_info.into(),
+                    header: None,
+                    security_details: None,
+                    errors: None,
+                }
+            }
+        }
+        impl SignedExchangeInfo {
+            pub fn builder() -> SignedExchangeInfoBuilder {
+                SignedExchangeInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SignedExchangeInfoBuilder {
+            outer_response: Option<Response>,
+            has_extra_info: Option<bool>,
+            header: Option<SignedExchangeHeader>,
+            security_details: Option<SecurityDetails>,
+            errors: Option<Vec<SignedExchangeError>>,
+        }
+        impl SignedExchangeInfoBuilder {
+            pub fn outer_response(mut self, outer_response: impl Into<Response>) -> Self {
+                self.outer_response = Some(outer_response.into());
+                self
+            }
+            pub fn has_extra_info(mut self, has_extra_info: impl Into<bool>) -> Self {
+                self.has_extra_info = Some(has_extra_info.into());
+                self
+            }
+            pub fn header(mut self, header: impl Into<SignedExchangeHeader>) -> Self {
+                self.header = Some(header.into());
+                self
+            }
+            pub fn security_details(
+                mut self,
+                security_details: impl Into<SecurityDetails>,
+            ) -> Self {
+                self.security_details = Some(security_details.into());
+                self
+            }
+            pub fn error(mut self, error: impl Into<SignedExchangeError>) -> Self {
+                let v = self.errors.get_or_insert(Vec::new());
+                v.push(error.into());
+                self
+            }
+            pub fn errors<I, S>(mut self, errors: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SignedExchangeError>,
+            {
+                let v = self.errors.get_or_insert(Vec::new());
+                for val in errors {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SignedExchangeInfo, String> {
+                Ok(SignedExchangeInfo {
+                    outer_response: self.outer_response.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(outer_response))
+                    })?,
+                    has_extra_info: self.has_extra_info.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(has_extra_info))
+                    })?,
+                    header: self.header,
+                    security_details: self.security_details,
+                    errors: self.errors,
+                })
+            }
+        }
+        impl SignedExchangeInfo {
+            pub const IDENTIFIER: &'static str = "Network.SignedExchangeInfo";
+        }
+        #[doc = "List of content encodings supported by the backend."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ContentEncoding {
+            #[serde(rename = "deflate")]
+            Deflate,
+            #[serde(rename = "gzip")]
+            Gzip,
+            #[serde(rename = "br")]
+            Br,
+            #[serde(rename = "zstd")]
+            Zstd,
+        }
+        impl AsRef<str> for ContentEncoding {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ContentEncoding::Deflate => "deflate",
+                    ContentEncoding::Gzip => "gzip",
+                    ContentEncoding::Br => "br",
+                    ContentEncoding::Zstd => "zstd",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ContentEncoding {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "deflate" | "Deflate" => Ok(ContentEncoding::Deflate),
+                    "gzip" | "Gzip" => Ok(ContentEncoding::Gzip),
+                    "br" | "Br" => Ok(ContentEncoding::Br),
+                    "zstd" | "Zstd" => Ok(ContentEncoding::Zstd),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct NetworkConditions {
+            #[doc = "Only matching requests will be affected by these conditions. Patterns use the URLPattern constructor string\nsyntax (https://urlpattern.spec.whatwg.org/) and must be absolute. If the pattern is empty, all requests are\nmatched (including p2p connections)."]
+            #[serde(rename = "urlPattern")]
+            pub url_pattern: String,
+            #[doc = "Minimum latency from request sent to response headers received (ms)."]
+            #[serde(rename = "latency")]
+            pub latency: f64,
+            #[doc = "Maximal aggregated download throughput (bytes/sec). -1 disables download throttling."]
+            #[serde(rename = "downloadThroughput")]
+            pub download_throughput: f64,
+            #[doc = "Maximal aggregated upload throughput (bytes/sec).  -1 disables upload throttling."]
+            #[serde(rename = "uploadThroughput")]
+            pub upload_throughput: f64,
+            #[doc = "Connection type if known."]
+            #[serde(rename = "connectionType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub connection_type: Option<ConnectionType>,
+            #[doc = "WebRTC packet loss (percent, 0-100). 0 disables packet loss emulation, 100 drops all the packets."]
+            #[serde(rename = "packetLoss")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub packet_loss: Option<f64>,
+            #[doc = "WebRTC packet queue length (packet). 0 removes any queue length limitations."]
+            #[serde(rename = "packetQueueLength")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub packet_queue_length: Option<i64>,
+            #[doc = "WebRTC packetReordering feature."]
+            #[serde(rename = "packetReordering")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub packet_reordering: Option<bool>,
+        }
+        impl NetworkConditions {
+            pub fn new(
+                url_pattern: impl Into<String>,
+                latency: impl Into<f64>,
+                download_throughput: impl Into<f64>,
+                upload_throughput: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    url_pattern: url_pattern.into(),
+                    latency: latency.into(),
+                    download_throughput: download_throughput.into(),
+                    upload_throughput: upload_throughput.into(),
+                    connection_type: None,
+                    packet_loss: None,
+                    packet_queue_length: None,
+                    packet_reordering: None,
+                }
+            }
+        }
+        impl NetworkConditions {
+            pub fn builder() -> NetworkConditionsBuilder {
+                NetworkConditionsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct NetworkConditionsBuilder {
+            url_pattern: Option<String>,
+            latency: Option<f64>,
+            download_throughput: Option<f64>,
+            upload_throughput: Option<f64>,
+            connection_type: Option<ConnectionType>,
+            packet_loss: Option<f64>,
+            packet_queue_length: Option<i64>,
+            packet_reordering: Option<bool>,
+        }
+        impl NetworkConditionsBuilder {
+            pub fn url_pattern(mut self, url_pattern: impl Into<String>) -> Self {
+                self.url_pattern = Some(url_pattern.into());
+                self
+            }
+            pub fn latency(mut self, latency: impl Into<f64>) -> Self {
+                self.latency = Some(latency.into());
+                self
+            }
+            pub fn download_throughput(mut self, download_throughput: impl Into<f64>) -> Self {
+                self.download_throughput = Some(download_throughput.into());
+                self
+            }
+            pub fn upload_throughput(mut self, upload_throughput: impl Into<f64>) -> Self {
+                self.upload_throughput = Some(upload_throughput.into());
+                self
+            }
+            pub fn connection_type(mut self, connection_type: impl Into<ConnectionType>) -> Self {
+                self.connection_type = Some(connection_type.into());
+                self
+            }
+            pub fn packet_loss(mut self, packet_loss: impl Into<f64>) -> Self {
+                self.packet_loss = Some(packet_loss.into());
+                self
+            }
+            pub fn packet_queue_length(mut self, packet_queue_length: impl Into<i64>) -> Self {
+                self.packet_queue_length = Some(packet_queue_length.into());
+                self
+            }
+            pub fn packet_reordering(mut self, packet_reordering: impl Into<bool>) -> Self {
+                self.packet_reordering = Some(packet_reordering.into());
+                self
+            }
+            pub fn build(self) -> Result<NetworkConditions, String> {
+                Ok(NetworkConditions {
+                    url_pattern: self.url_pattern.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(url_pattern))
+                    })?,
+                    latency: self.latency.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(latency))
+                    })?,
+                    download_throughput: self.download_throughput.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(download_throughput)
+                        )
+                    })?,
+                    upload_throughput: self.upload_throughput.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(upload_throughput)
+                        )
+                    })?,
+                    connection_type: self.connection_type,
+                    packet_loss: self.packet_loss,
+                    packet_queue_length: self.packet_queue_length,
+                    packet_reordering: self.packet_reordering,
+                })
+            }
+        }
+        impl NetworkConditions {
+            pub const IDENTIFIER: &'static str = "Network.NetworkConditions";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BlockPattern {
+            #[doc = "URL pattern to match. Patterns use the URLPattern constructor string syntax\n(https://urlpattern.spec.whatwg.org/) and must be absolute. Example: `*://*:*/*.css`."]
+            #[serde(rename = "urlPattern")]
+            pub url_pattern: String,
+            #[doc = "Whether or not to block the pattern. If false, a matching request will not be blocked even if it matches a later\n`BlockPattern`."]
+            #[serde(rename = "block")]
+            pub block: bool,
+        }
+        impl BlockPattern {
+            pub fn new(url_pattern: impl Into<String>, block: impl Into<bool>) -> Self {
+                Self {
+                    url_pattern: url_pattern.into(),
+                    block: block.into(),
+                }
+            }
+        }
+        impl BlockPattern {
+            pub fn builder() -> BlockPatternBuilder {
+                BlockPatternBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BlockPatternBuilder {
+            url_pattern: Option<String>,
+            block: Option<bool>,
+        }
+        impl BlockPatternBuilder {
+            pub fn url_pattern(mut self, url_pattern: impl Into<String>) -> Self {
+                self.url_pattern = Some(url_pattern.into());
+                self
+            }
+            pub fn block(mut self, block: impl Into<bool>) -> Self {
+                self.block = Some(block.into());
+                self
+            }
+            pub fn build(self) -> Result<BlockPattern, String> {
+                Ok(BlockPattern {
+                    url_pattern: self.url_pattern.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(url_pattern))
+                    })?,
+                    block: self.block.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(block))
+                    })?,
+                })
+            }
+        }
+        impl BlockPattern {
+            pub const IDENTIFIER: &'static str = "Network.BlockPattern";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DirectSocketDnsQueryType {
+            #[serde(rename = "ipv4")]
+            Ipv4,
+            #[serde(rename = "ipv6")]
+            Ipv6,
+        }
+        impl AsRef<str> for DirectSocketDnsQueryType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DirectSocketDnsQueryType::Ipv4 => "ipv4",
+                    DirectSocketDnsQueryType::Ipv6 => "ipv6",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DirectSocketDnsQueryType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "ipv4" | "Ipv4" => Ok(DirectSocketDnsQueryType::Ipv4),
+                    "ipv6" | "Ipv6" => Ok(DirectSocketDnsQueryType::Ipv6),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DirectTcpSocketOptions {
+            #[doc = "TCP_NODELAY option"]
+            #[serde(rename = "noDelay")]
+            pub no_delay: bool,
+            #[doc = "Expected to be unsigned integer."]
+            #[serde(rename = "keepAliveDelay")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub keep_alive_delay: Option<f64>,
+            #[doc = "Expected to be unsigned integer."]
+            #[serde(rename = "sendBufferSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub send_buffer_size: Option<f64>,
+            #[doc = "Expected to be unsigned integer."]
+            #[serde(rename = "receiveBufferSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub receive_buffer_size: Option<f64>,
+            #[serde(rename = "dnsQueryType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub dns_query_type: Option<DirectSocketDnsQueryType>,
+        }
+        impl DirectTcpSocketOptions {
+            pub fn new(no_delay: impl Into<bool>) -> Self {
+                Self {
+                    no_delay: no_delay.into(),
+                    keep_alive_delay: None,
+                    send_buffer_size: None,
+                    receive_buffer_size: None,
+                    dns_query_type: None,
+                }
+            }
+        }
+        impl DirectTcpSocketOptions {
+            pub fn builder() -> DirectTcpSocketOptionsBuilder {
+                DirectTcpSocketOptionsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DirectTcpSocketOptionsBuilder {
+            no_delay: Option<bool>,
+            keep_alive_delay: Option<f64>,
+            send_buffer_size: Option<f64>,
+            receive_buffer_size: Option<f64>,
+            dns_query_type: Option<DirectSocketDnsQueryType>,
+        }
+        impl DirectTcpSocketOptionsBuilder {
+            pub fn no_delay(mut self, no_delay: impl Into<bool>) -> Self {
+                self.no_delay = Some(no_delay.into());
+                self
+            }
+            pub fn keep_alive_delay(mut self, keep_alive_delay: impl Into<f64>) -> Self {
+                self.keep_alive_delay = Some(keep_alive_delay.into());
+                self
+            }
+            pub fn send_buffer_size(mut self, send_buffer_size: impl Into<f64>) -> Self {
+                self.send_buffer_size = Some(send_buffer_size.into());
+                self
+            }
+            pub fn receive_buffer_size(mut self, receive_buffer_size: impl Into<f64>) -> Self {
+                self.receive_buffer_size = Some(receive_buffer_size.into());
+                self
+            }
+            pub fn dns_query_type(
+                mut self,
+                dns_query_type: impl Into<DirectSocketDnsQueryType>,
+            ) -> Self {
+                self.dns_query_type = Some(dns_query_type.into());
+                self
+            }
+            pub fn build(self) -> Result<DirectTcpSocketOptions, String> {
+                Ok(DirectTcpSocketOptions {
+                    no_delay: self.no_delay.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(no_delay))
+                    })?,
+                    keep_alive_delay: self.keep_alive_delay,
+                    send_buffer_size: self.send_buffer_size,
+                    receive_buffer_size: self.receive_buffer_size,
+                    dns_query_type: self.dns_query_type,
+                })
+            }
+        }
+        impl DirectTcpSocketOptions {
+            pub const IDENTIFIER: &'static str = "Network.DirectTCPSocketOptions";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DirectUdpSocketOptions {
+            #[serde(rename = "remoteAddr")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub remote_addr: Option<String>,
+            #[doc = "Unsigned int 16."]
+            #[serde(rename = "remotePort")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub remote_port: Option<i64>,
+            #[serde(rename = "localAddr")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub local_addr: Option<String>,
+            #[doc = "Unsigned int 16."]
+            #[serde(rename = "localPort")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub local_port: Option<i64>,
+            #[serde(rename = "dnsQueryType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub dns_query_type: Option<DirectSocketDnsQueryType>,
+            #[doc = "Expected to be unsigned integer."]
+            #[serde(rename = "sendBufferSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub send_buffer_size: Option<f64>,
+            #[doc = "Expected to be unsigned integer."]
+            #[serde(rename = "receiveBufferSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub receive_buffer_size: Option<f64>,
+            #[serde(rename = "multicastLoopback")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub multicast_loopback: Option<bool>,
+            #[doc = "Unsigned int 8."]
+            #[serde(rename = "multicastTimeToLive")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub multicast_time_to_live: Option<i64>,
+            #[serde(rename = "multicastAllowAddressSharing")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub multicast_allow_address_sharing: Option<bool>,
+        }
+        impl DirectUdpSocketOptions {
+            pub fn builder() -> DirectUdpSocketOptionsBuilder {
+                DirectUdpSocketOptionsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DirectUdpSocketOptionsBuilder {
+            remote_addr: Option<String>,
+            remote_port: Option<i64>,
+            local_addr: Option<String>,
+            local_port: Option<i64>,
+            dns_query_type: Option<DirectSocketDnsQueryType>,
+            send_buffer_size: Option<f64>,
+            receive_buffer_size: Option<f64>,
+            multicast_loopback: Option<bool>,
+            multicast_time_to_live: Option<i64>,
+            multicast_allow_address_sharing: Option<bool>,
+        }
+        impl DirectUdpSocketOptionsBuilder {
+            pub fn remote_addr(mut self, remote_addr: impl Into<String>) -> Self {
+                self.remote_addr = Some(remote_addr.into());
+                self
+            }
+            pub fn remote_port(mut self, remote_port: impl Into<i64>) -> Self {
+                self.remote_port = Some(remote_port.into());
+                self
+            }
+            pub fn local_addr(mut self, local_addr: impl Into<String>) -> Self {
+                self.local_addr = Some(local_addr.into());
+                self
+            }
+            pub fn local_port(mut self, local_port: impl Into<i64>) -> Self {
+                self.local_port = Some(local_port.into());
+                self
+            }
+            pub fn dns_query_type(
+                mut self,
+                dns_query_type: impl Into<DirectSocketDnsQueryType>,
+            ) -> Self {
+                self.dns_query_type = Some(dns_query_type.into());
+                self
+            }
+            pub fn send_buffer_size(mut self, send_buffer_size: impl Into<f64>) -> Self {
+                self.send_buffer_size = Some(send_buffer_size.into());
+                self
+            }
+            pub fn receive_buffer_size(mut self, receive_buffer_size: impl Into<f64>) -> Self {
+                self.receive_buffer_size = Some(receive_buffer_size.into());
+                self
+            }
+            pub fn multicast_loopback(mut self, multicast_loopback: impl Into<bool>) -> Self {
+                self.multicast_loopback = Some(multicast_loopback.into());
+                self
+            }
+            pub fn multicast_time_to_live(
+                mut self,
+                multicast_time_to_live: impl Into<i64>,
+            ) -> Self {
+                self.multicast_time_to_live = Some(multicast_time_to_live.into());
+                self
+            }
+            pub fn multicast_allow_address_sharing(
+                mut self,
+                multicast_allow_address_sharing: impl Into<bool>,
+            ) -> Self {
+                self.multicast_allow_address_sharing = Some(multicast_allow_address_sharing.into());
+                self
+            }
+            pub fn build(self) -> DirectUdpSocketOptions {
+                DirectUdpSocketOptions {
+                    remote_addr: self.remote_addr,
+                    remote_port: self.remote_port,
+                    local_addr: self.local_addr,
+                    local_port: self.local_port,
+                    dns_query_type: self.dns_query_type,
+                    send_buffer_size: self.send_buffer_size,
+                    receive_buffer_size: self.receive_buffer_size,
+                    multicast_loopback: self.multicast_loopback,
+                    multicast_time_to_live: self.multicast_time_to_live,
+                    multicast_allow_address_sharing: self.multicast_allow_address_sharing,
+                }
+            }
+        }
+        impl DirectUdpSocketOptions {
+            pub const IDENTIFIER: &'static str = "Network.DirectUDPSocketOptions";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DirectUdpMessage {
+            #[serde(rename = "data")]
+            pub data: chromiumoxide_types::Binary,
+            #[doc = "Null for connected mode."]
+            #[serde(rename = "remoteAddr")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub remote_addr: Option<String>,
+            #[doc = "Null for connected mode.\nExpected to be unsigned integer."]
+            #[serde(rename = "remotePort")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub remote_port: Option<i64>,
+        }
+        impl DirectUdpMessage {
+            pub fn new(data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                Self {
+                    data: data.into(),
+                    remote_addr: None,
+                    remote_port: None,
+                }
+            }
+        }
+        impl DirectUdpMessage {
+            pub fn builder() -> DirectUdpMessageBuilder {
+                DirectUdpMessageBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DirectUdpMessageBuilder {
+            data: Option<chromiumoxide_types::Binary>,
+            remote_addr: Option<String>,
+            remote_port: Option<i64>,
+        }
+        impl DirectUdpMessageBuilder {
+            pub fn data(mut self, data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn remote_addr(mut self, remote_addr: impl Into<String>) -> Self {
+                self.remote_addr = Some(remote_addr.into());
+                self
+            }
+            pub fn remote_port(mut self, remote_port: impl Into<i64>) -> Self {
+                self.remote_port = Some(remote_port.into());
+                self
+            }
+            pub fn build(self) -> Result<DirectUdpMessage, String> {
+                Ok(DirectUdpMessage {
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                    remote_addr: self.remote_addr,
+                    remote_port: self.remote_port,
+                })
+            }
+        }
+        impl DirectUdpMessage {
+            pub const IDENTIFIER: &'static str = "Network.DirectUDPMessage";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PrivateNetworkRequestPolicy {
+            #[serde(rename = "Allow")]
+            Allow,
+            #[serde(rename = "BlockFromInsecureToMorePrivate")]
+            BlockFromInsecureToMorePrivate,
+            #[serde(rename = "WarnFromInsecureToMorePrivate")]
+            WarnFromInsecureToMorePrivate,
+            #[serde(rename = "PermissionBlock")]
+            PermissionBlock,
+            #[serde(rename = "PermissionWarn")]
+            PermissionWarn,
+        }
+        impl AsRef<str> for PrivateNetworkRequestPolicy {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PrivateNetworkRequestPolicy::Allow => "Allow",
+                    PrivateNetworkRequestPolicy::BlockFromInsecureToMorePrivate => {
+                        "BlockFromInsecureToMorePrivate"
+                    }
+                    PrivateNetworkRequestPolicy::WarnFromInsecureToMorePrivate => {
+                        "WarnFromInsecureToMorePrivate"
+                    }
+                    PrivateNetworkRequestPolicy::PermissionBlock => "PermissionBlock",
+                    PrivateNetworkRequestPolicy::PermissionWarn => "PermissionWarn",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PrivateNetworkRequestPolicy {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Allow" | "allow" => Ok(PrivateNetworkRequestPolicy::Allow),
+                    "BlockFromInsecureToMorePrivate" | "blockfrominsecuretomoreprivate" => {
+                        Ok(PrivateNetworkRequestPolicy::BlockFromInsecureToMorePrivate)
+                    }
+                    "WarnFromInsecureToMorePrivate" | "warnfrominsecuretomoreprivate" => {
+                        Ok(PrivateNetworkRequestPolicy::WarnFromInsecureToMorePrivate)
+                    }
+                    "PermissionBlock" | "permissionblock" => {
+                        Ok(PrivateNetworkRequestPolicy::PermissionBlock)
+                    }
+                    "PermissionWarn" | "permissionwarn" => {
+                        Ok(PrivateNetworkRequestPolicy::PermissionWarn)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum IpAddressSpace {
+            #[serde(rename = "Loopback")]
+            Loopback,
+            #[serde(rename = "Local")]
+            Local,
+            #[serde(rename = "Public")]
+            Public,
+            #[serde(rename = "Unknown")]
+            Unknown,
+        }
+        impl AsRef<str> for IpAddressSpace {
+            fn as_ref(&self) -> &str {
+                match self {
+                    IpAddressSpace::Loopback => "Loopback",
+                    IpAddressSpace::Local => "Local",
+                    IpAddressSpace::Public => "Public",
+                    IpAddressSpace::Unknown => "Unknown",
+                }
+            }
+        }
+        impl ::std::str::FromStr for IpAddressSpace {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Loopback" | "loopback" => Ok(IpAddressSpace::Loopback),
+                    "Local" | "local" => Ok(IpAddressSpace::Local),
+                    "Public" | "public" => Ok(IpAddressSpace::Public),
+                    "Unknown" | "unknown" => Ok(IpAddressSpace::Unknown),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ConnectTiming {
+            #[doc = "Timing's requestTime is a baseline in seconds, while the other numbers are ticks in\nmilliseconds relatively to this requestTime. Matches ResourceTiming's requestTime for\nthe same request (but not for redirected requests)."]
+            #[serde(rename = "requestTime")]
+            pub request_time: f64,
+        }
+        impl ConnectTiming {
+            pub fn new(request_time: impl Into<f64>) -> Self {
+                Self {
+                    request_time: request_time.into(),
+                }
+            }
+        }
+        impl ConnectTiming {
+            pub fn builder() -> ConnectTimingBuilder {
+                ConnectTimingBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ConnectTimingBuilder {
+            request_time: Option<f64>,
+        }
+        impl ConnectTimingBuilder {
+            pub fn request_time(mut self, request_time: impl Into<f64>) -> Self {
+                self.request_time = Some(request_time.into());
+                self
+            }
+            pub fn build(self) -> Result<ConnectTiming, String> {
+                Ok(ConnectTiming {
+                    request_time: self.request_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_time))
+                    })?,
+                })
+            }
+        }
+        impl ConnectTiming {
+            pub const IDENTIFIER: &'static str = "Network.ConnectTiming";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClientSecurityState {
+            #[serde(rename = "initiatorIsSecureContext")]
+            pub initiator_is_secure_context: bool,
+            #[serde(rename = "initiatorIPAddressSpace")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub initiator_ip_address_space: IpAddressSpace,
+            #[serde(rename = "privateNetworkRequestPolicy")]
+            #[serde(alias = "localNetworkAccessRequestPolicy")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub private_network_request_policy: PrivateNetworkRequestPolicy,
+        }
+        impl ClientSecurityState {
+            pub fn new(
+                initiator_is_secure_context: impl Into<bool>,
+                initiator_ip_address_space: impl Into<IpAddressSpace>,
+                private_network_request_policy: impl Into<PrivateNetworkRequestPolicy>,
+            ) -> Self {
+                Self {
+                    initiator_is_secure_context: initiator_is_secure_context.into(),
+                    initiator_ip_address_space: initiator_ip_address_space.into(),
+                    private_network_request_policy: private_network_request_policy.into(),
+                }
+            }
+        }
+        impl ClientSecurityState {
+            pub fn builder() -> ClientSecurityStateBuilder {
+                ClientSecurityStateBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClientSecurityStateBuilder {
+            initiator_is_secure_context: Option<bool>,
+            initiator_ip_address_space: Option<IpAddressSpace>,
+            private_network_request_policy: Option<PrivateNetworkRequestPolicy>,
+        }
+        impl ClientSecurityStateBuilder {
+            pub fn initiator_is_secure_context(
+                mut self,
+                initiator_is_secure_context: impl Into<bool>,
+            ) -> Self {
+                self.initiator_is_secure_context = Some(initiator_is_secure_context.into());
+                self
+            }
+            pub fn initiator_ip_address_space(
+                mut self,
+                initiator_ip_address_space: impl Into<IpAddressSpace>,
+            ) -> Self {
+                self.initiator_ip_address_space = Some(initiator_ip_address_space.into());
+                self
+            }
+            pub fn private_network_request_policy(
+                mut self,
+                private_network_request_policy: impl Into<PrivateNetworkRequestPolicy>,
+            ) -> Self {
+                self.private_network_request_policy = Some(private_network_request_policy.into());
+                self
+            }
+            pub fn build(self) -> Result<ClientSecurityState, String> {
+                Ok(ClientSecurityState {
+                    initiator_is_secure_context: self.initiator_is_secure_context.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(initiator_is_secure_context)
+                            )
+                        },
+                    )?,
+                    initiator_ip_address_space: self.initiator_ip_address_space.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(initiator_ip_address_space)
+                            )
+                        },
+                    )?,
+                    private_network_request_policy: self
+                        .private_network_request_policy
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(private_network_request_policy)
+                            )
+                        })?,
+                })
+            }
+        }
+        impl ClientSecurityState {
+            pub const IDENTIFIER: &'static str = "Network.ClientSecurityState";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CrossOriginOpenerPolicyValue {
+            #[serde(rename = "SameOrigin")]
+            SameOrigin,
+            #[serde(rename = "SameOriginAllowPopups")]
+            SameOriginAllowPopups,
+            #[serde(rename = "RestrictProperties")]
+            RestrictProperties,
+            #[serde(rename = "UnsafeNone")]
+            UnsafeNone,
+            #[serde(rename = "SameOriginPlusCoep")]
+            SameOriginPlusCoep,
+            #[serde(rename = "RestrictPropertiesPlusCoep")]
+            RestrictPropertiesPlusCoep,
+            #[serde(rename = "NoopenerAllowPopups")]
+            NoopenerAllowPopups,
+        }
+        impl AsRef<str> for CrossOriginOpenerPolicyValue {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CrossOriginOpenerPolicyValue::SameOrigin => "SameOrigin",
+                    CrossOriginOpenerPolicyValue::SameOriginAllowPopups => "SameOriginAllowPopups",
+                    CrossOriginOpenerPolicyValue::RestrictProperties => "RestrictProperties",
+                    CrossOriginOpenerPolicyValue::UnsafeNone => "UnsafeNone",
+                    CrossOriginOpenerPolicyValue::SameOriginPlusCoep => "SameOriginPlusCoep",
+                    CrossOriginOpenerPolicyValue::RestrictPropertiesPlusCoep => {
+                        "RestrictPropertiesPlusCoep"
+                    }
+                    CrossOriginOpenerPolicyValue::NoopenerAllowPopups => "NoopenerAllowPopups",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CrossOriginOpenerPolicyValue {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "SameOrigin" | "sameorigin" => Ok(CrossOriginOpenerPolicyValue::SameOrigin),
+                    "SameOriginAllowPopups" | "sameoriginallowpopups" => {
+                        Ok(CrossOriginOpenerPolicyValue::SameOriginAllowPopups)
+                    }
+                    "RestrictProperties" | "restrictproperties" => {
+                        Ok(CrossOriginOpenerPolicyValue::RestrictProperties)
+                    }
+                    "UnsafeNone" | "unsafenone" => Ok(CrossOriginOpenerPolicyValue::UnsafeNone),
+                    "SameOriginPlusCoep" | "sameoriginpluscoep" => {
+                        Ok(CrossOriginOpenerPolicyValue::SameOriginPlusCoep)
+                    }
+                    "RestrictPropertiesPlusCoep" | "restrictpropertiespluscoep" => {
+                        Ok(CrossOriginOpenerPolicyValue::RestrictPropertiesPlusCoep)
+                    }
+                    "NoopenerAllowPopups" | "noopenerallowpopups" => {
+                        Ok(CrossOriginOpenerPolicyValue::NoopenerAllowPopups)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CrossOriginOpenerPolicyStatus {
+            #[serde(rename = "value")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub value: CrossOriginOpenerPolicyValue,
+            #[serde(rename = "reportOnlyValue")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub report_only_value: CrossOriginOpenerPolicyValue,
+            #[serde(rename = "reportingEndpoint")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub reporting_endpoint: Option<String>,
+            #[serde(rename = "reportOnlyReportingEndpoint")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub report_only_reporting_endpoint: Option<String>,
+        }
+        impl CrossOriginOpenerPolicyStatus {
+            pub fn new(
+                value: impl Into<CrossOriginOpenerPolicyValue>,
+                report_only_value: impl Into<CrossOriginOpenerPolicyValue>,
+            ) -> Self {
+                Self {
+                    value: value.into(),
+                    report_only_value: report_only_value.into(),
+                    reporting_endpoint: None,
+                    report_only_reporting_endpoint: None,
+                }
+            }
+        }
+        impl CrossOriginOpenerPolicyStatus {
+            pub fn builder() -> CrossOriginOpenerPolicyStatusBuilder {
+                CrossOriginOpenerPolicyStatusBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CrossOriginOpenerPolicyStatusBuilder {
+            value: Option<CrossOriginOpenerPolicyValue>,
+            report_only_value: Option<CrossOriginOpenerPolicyValue>,
+            reporting_endpoint: Option<String>,
+            report_only_reporting_endpoint: Option<String>,
+        }
+        impl CrossOriginOpenerPolicyStatusBuilder {
+            pub fn value(mut self, value: impl Into<CrossOriginOpenerPolicyValue>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn report_only_value(
+                mut self,
+                report_only_value: impl Into<CrossOriginOpenerPolicyValue>,
+            ) -> Self {
+                self.report_only_value = Some(report_only_value.into());
+                self
+            }
+            pub fn reporting_endpoint(mut self, reporting_endpoint: impl Into<String>) -> Self {
+                self.reporting_endpoint = Some(reporting_endpoint.into());
+                self
+            }
+            pub fn report_only_reporting_endpoint(
+                mut self,
+                report_only_reporting_endpoint: impl Into<String>,
+            ) -> Self {
+                self.report_only_reporting_endpoint = Some(report_only_reporting_endpoint.into());
+                self
+            }
+            pub fn build(self) -> Result<CrossOriginOpenerPolicyStatus, String> {
+                Ok(CrossOriginOpenerPolicyStatus {
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    report_only_value: self.report_only_value.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(report_only_value)
+                        )
+                    })?,
+                    reporting_endpoint: self.reporting_endpoint,
+                    report_only_reporting_endpoint: self.report_only_reporting_endpoint,
+                })
+            }
+        }
+        impl CrossOriginOpenerPolicyStatus {
+            pub const IDENTIFIER: &'static str = "Network.CrossOriginOpenerPolicyStatus";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CrossOriginEmbedderPolicyValue {
+            #[serde(rename = "None")]
+            None,
+            #[serde(rename = "Credentialless")]
+            Credentialless,
+            #[serde(rename = "RequireCorp")]
+            RequireCorp,
+        }
+        impl AsRef<str> for CrossOriginEmbedderPolicyValue {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CrossOriginEmbedderPolicyValue::None => "None",
+                    CrossOriginEmbedderPolicyValue::Credentialless => "Credentialless",
+                    CrossOriginEmbedderPolicyValue::RequireCorp => "RequireCorp",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CrossOriginEmbedderPolicyValue {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "None" | "none" => Ok(CrossOriginEmbedderPolicyValue::None),
+                    "Credentialless" | "credentialless" => {
+                        Ok(CrossOriginEmbedderPolicyValue::Credentialless)
+                    }
+                    "RequireCorp" | "requirecorp" => {
+                        Ok(CrossOriginEmbedderPolicyValue::RequireCorp)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CrossOriginEmbedderPolicyStatus {
+            #[serde(rename = "value")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub value: CrossOriginEmbedderPolicyValue,
+            #[serde(rename = "reportOnlyValue")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub report_only_value: CrossOriginEmbedderPolicyValue,
+            #[serde(rename = "reportingEndpoint")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub reporting_endpoint: Option<String>,
+            #[serde(rename = "reportOnlyReportingEndpoint")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub report_only_reporting_endpoint: Option<String>,
+        }
+        impl CrossOriginEmbedderPolicyStatus {
+            pub fn new(
+                value: impl Into<CrossOriginEmbedderPolicyValue>,
+                report_only_value: impl Into<CrossOriginEmbedderPolicyValue>,
+            ) -> Self {
+                Self {
+                    value: value.into(),
+                    report_only_value: report_only_value.into(),
+                    reporting_endpoint: None,
+                    report_only_reporting_endpoint: None,
+                }
+            }
+        }
+        impl CrossOriginEmbedderPolicyStatus {
+            pub fn builder() -> CrossOriginEmbedderPolicyStatusBuilder {
+                CrossOriginEmbedderPolicyStatusBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CrossOriginEmbedderPolicyStatusBuilder {
+            value: Option<CrossOriginEmbedderPolicyValue>,
+            report_only_value: Option<CrossOriginEmbedderPolicyValue>,
+            reporting_endpoint: Option<String>,
+            report_only_reporting_endpoint: Option<String>,
+        }
+        impl CrossOriginEmbedderPolicyStatusBuilder {
+            pub fn value(mut self, value: impl Into<CrossOriginEmbedderPolicyValue>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn report_only_value(
+                mut self,
+                report_only_value: impl Into<CrossOriginEmbedderPolicyValue>,
+            ) -> Self {
+                self.report_only_value = Some(report_only_value.into());
+                self
+            }
+            pub fn reporting_endpoint(mut self, reporting_endpoint: impl Into<String>) -> Self {
+                self.reporting_endpoint = Some(reporting_endpoint.into());
+                self
+            }
+            pub fn report_only_reporting_endpoint(
+                mut self,
+                report_only_reporting_endpoint: impl Into<String>,
+            ) -> Self {
+                self.report_only_reporting_endpoint = Some(report_only_reporting_endpoint.into());
+                self
+            }
+            pub fn build(self) -> Result<CrossOriginEmbedderPolicyStatus, String> {
+                Ok(CrossOriginEmbedderPolicyStatus {
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    report_only_value: self.report_only_value.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(report_only_value)
+                        )
+                    })?,
+                    reporting_endpoint: self.reporting_endpoint,
+                    report_only_reporting_endpoint: self.report_only_reporting_endpoint,
+                })
+            }
+        }
+        impl CrossOriginEmbedderPolicyStatus {
+            pub const IDENTIFIER: &'static str = "Network.CrossOriginEmbedderPolicyStatus";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ContentSecurityPolicySource {
+            #[serde(rename = "HTTP")]
+            Http,
+            #[serde(rename = "Meta")]
+            Meta,
+        }
+        impl AsRef<str> for ContentSecurityPolicySource {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ContentSecurityPolicySource::Http => "HTTP",
+                    ContentSecurityPolicySource::Meta => "Meta",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ContentSecurityPolicySource {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "HTTP" | "Http" | "http" => Ok(ContentSecurityPolicySource::Http),
+                    "Meta" | "meta" => Ok(ContentSecurityPolicySource::Meta),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ContentSecurityPolicyStatus {
+            #[serde(rename = "effectiveDirectives")]
+            pub effective_directives: String,
+            #[serde(rename = "isEnforced")]
+            pub is_enforced: bool,
+            #[serde(rename = "source")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub source: ContentSecurityPolicySource,
+        }
+        impl ContentSecurityPolicyStatus {
+            pub fn new(
+                effective_directives: impl Into<String>,
+                is_enforced: impl Into<bool>,
+                source: impl Into<ContentSecurityPolicySource>,
+            ) -> Self {
+                Self {
+                    effective_directives: effective_directives.into(),
+                    is_enforced: is_enforced.into(),
+                    source: source.into(),
+                }
+            }
+        }
+        impl ContentSecurityPolicyStatus {
+            pub fn builder() -> ContentSecurityPolicyStatusBuilder {
+                ContentSecurityPolicyStatusBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ContentSecurityPolicyStatusBuilder {
+            effective_directives: Option<String>,
+            is_enforced: Option<bool>,
+            source: Option<ContentSecurityPolicySource>,
+        }
+        impl ContentSecurityPolicyStatusBuilder {
+            pub fn effective_directives(mut self, effective_directives: impl Into<String>) -> Self {
+                self.effective_directives = Some(effective_directives.into());
+                self
+            }
+            pub fn is_enforced(mut self, is_enforced: impl Into<bool>) -> Self {
+                self.is_enforced = Some(is_enforced.into());
+                self
+            }
+            pub fn source(mut self, source: impl Into<ContentSecurityPolicySource>) -> Self {
+                self.source = Some(source.into());
+                self
+            }
+            pub fn build(self) -> Result<ContentSecurityPolicyStatus, String> {
+                Ok(ContentSecurityPolicyStatus {
+                    effective_directives: self.effective_directives.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(effective_directives)
+                        )
+                    })?,
+                    is_enforced: self.is_enforced.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_enforced))
+                    })?,
+                    source: self.source.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source))
+                    })?,
+                })
+            }
+        }
+        impl ContentSecurityPolicyStatus {
+            pub const IDENTIFIER: &'static str = "Network.ContentSecurityPolicyStatus";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SecurityIsolationStatus {
+            #[serde(rename = "coop")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub coop: Option<CrossOriginOpenerPolicyStatus>,
+            #[serde(rename = "coep")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub coep: Option<CrossOriginEmbedderPolicyStatus>,
+            #[serde(rename = "csp")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub csp: Option<Vec<ContentSecurityPolicyStatus>>,
+        }
+        impl SecurityIsolationStatus {
+            pub fn builder() -> SecurityIsolationStatusBuilder {
+                SecurityIsolationStatusBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SecurityIsolationStatusBuilder {
+            coop: Option<CrossOriginOpenerPolicyStatus>,
+            coep: Option<CrossOriginEmbedderPolicyStatus>,
+            csp: Option<Vec<ContentSecurityPolicyStatus>>,
+        }
+        impl SecurityIsolationStatusBuilder {
+            pub fn coop(mut self, coop: impl Into<CrossOriginOpenerPolicyStatus>) -> Self {
+                self.coop = Some(coop.into());
+                self
+            }
+            pub fn coep(mut self, coep: impl Into<CrossOriginEmbedderPolicyStatus>) -> Self {
+                self.coep = Some(coep.into());
+                self
+            }
+            pub fn csp(mut self, csp: impl Into<ContentSecurityPolicyStatus>) -> Self {
+                let v = self.csp.get_or_insert(Vec::new());
+                v.push(csp.into());
+                self
+            }
+            pub fn csps<I, S>(mut self, csps: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ContentSecurityPolicyStatus>,
+            {
+                let v = self.csp.get_or_insert(Vec::new());
+                for val in csps {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> SecurityIsolationStatus {
+                SecurityIsolationStatus {
+                    coop: self.coop,
+                    coep: self.coep,
+                    csp: self.csp,
+                }
+            }
+        }
+        impl SecurityIsolationStatus {
+            pub const IDENTIFIER: &'static str = "Network.SecurityIsolationStatus";
+        }
+        #[doc = "The status of a Reporting API report."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ReportStatus {
+            #[doc = "Report has been queued and no attempt has been made to deliver it yet,\nor attempted previous upload failed (impermanently)."]
+            #[serde(rename = "Queued")]
+            Queued,
+            #[doc = "There is an ongoing attempt to upload this report."]
+            #[serde(rename = "Pending")]
+            Pending,
+            #[doc = "Deletion of this report was requested while it was pending, so it will\nbe removed after possibly outstanding upload attempts complete (successful\nor not)."]
+            #[serde(rename = "MarkedForRemoval")]
+            MarkedForRemoval,
+            #[doc = "Successfully uploaded and MarkedForRemoval."]
+            #[serde(rename = "Success")]
+            Success,
+        }
+        impl AsRef<str> for ReportStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ReportStatus::Queued => "Queued",
+                    ReportStatus::Pending => "Pending",
+                    ReportStatus::MarkedForRemoval => "MarkedForRemoval",
+                    ReportStatus::Success => "Success",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ReportStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Queued" | "queued" => Ok(ReportStatus::Queued),
+                    "Pending" | "pending" => Ok(ReportStatus::Pending),
+                    "MarkedForRemoval" | "markedforremoval" => Ok(ReportStatus::MarkedForRemoval),
+                    "Success" | "success" => Ok(ReportStatus::Success),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct ReportId(String);
+        impl ReportId {
+            pub fn new(val: impl Into<String>) -> Self {
+                ReportId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for ReportId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<ReportId> for String {
+            fn from(el: ReportId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for ReportId {
+            fn from(expr: String) -> Self {
+                ReportId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for ReportId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl ReportId {
+            pub const IDENTIFIER: &'static str = "Network.ReportId";
+        }
+        #[doc = "An object representing a report generated by the Reporting API.\n[ReportingApiReport](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-ReportingApiReport)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReportingApiReport {
+            #[serde(rename = "id")]
+            pub id: ReportId,
+            #[doc = "The URL of the document that triggered the report."]
+            #[serde(rename = "initiatorUrl")]
+            pub initiator_url: String,
+            #[doc = "The name of the endpoint group that should be used to deliver the report."]
+            #[serde(rename = "destination")]
+            pub destination: String,
+            #[doc = "The type of the report (specifies the set of data that is contained in the report body)."]
+            #[serde(rename = "type")]
+            pub r#type: String,
+            #[doc = "When the report was generated."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: super::network::TimeSinceEpoch,
+            #[doc = "How many uploads deep the related request was."]
+            #[serde(rename = "depth")]
+            pub depth: i64,
+            #[doc = "The number of delivery attempts made so far, not including an active attempt."]
+            #[serde(rename = "completedAttempts")]
+            pub completed_attempts: i64,
+            #[serde(rename = "body")]
+            pub body: serde_json::Value,
+            #[serde(rename = "status")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub status: ReportStatus,
+        }
+        impl ReportingApiReport {
+            pub fn builder() -> ReportingApiReportBuilder {
+                ReportingApiReportBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReportingApiReportBuilder {
+            id: Option<ReportId>,
+            initiator_url: Option<String>,
+            destination: Option<String>,
+            r#type: Option<String>,
+            timestamp: Option<super::network::TimeSinceEpoch>,
+            depth: Option<i64>,
+            completed_attempts: Option<i64>,
+            body: Option<serde_json::Value>,
+            status: Option<ReportStatus>,
+        }
+        impl ReportingApiReportBuilder {
+            pub fn id(mut self, id: impl Into<ReportId>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn initiator_url(mut self, initiator_url: impl Into<String>) -> Self {
+                self.initiator_url = Some(initiator_url.into());
+                self
+            }
+            pub fn destination(mut self, destination: impl Into<String>) -> Self {
+                self.destination = Some(destination.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn timestamp(
+                mut self,
+                timestamp: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn depth(mut self, depth: impl Into<i64>) -> Self {
+                self.depth = Some(depth.into());
+                self
+            }
+            pub fn completed_attempts(mut self, completed_attempts: impl Into<i64>) -> Self {
+                self.completed_attempts = Some(completed_attempts.into());
+                self
+            }
+            pub fn body(mut self, body: impl Into<serde_json::Value>) -> Self {
+                self.body = Some(body.into());
+                self
+            }
+            pub fn status(mut self, status: impl Into<ReportStatus>) -> Self {
+                self.status = Some(status.into());
+                self
+            }
+            pub fn build(self) -> Result<ReportingApiReport, String> {
+                Ok(ReportingApiReport {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    initiator_url: self.initiator_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(initiator_url))
+                    })?,
+                    destination: self.destination.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(destination))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    timestamp: self.timestamp.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(timestamp))
+                    })?,
+                    depth: self.depth.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(depth))
+                    })?,
+                    completed_attempts: self.completed_attempts.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(completed_attempts)
+                        )
+                    })?,
+                    body: self.body.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(body))
+                    })?,
+                    status: self.status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status))
+                    })?,
+                })
+            }
+        }
+        impl ReportingApiReport {
+            pub const IDENTIFIER: &'static str = "Network.ReportingApiReport";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReportingApiEndpoint {
+            #[doc = "The URL of the endpoint to which reports may be delivered."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Name of the endpoint group."]
+            #[serde(rename = "groupName")]
+            pub group_name: String,
+        }
+        impl ReportingApiEndpoint {
+            pub fn new(url: impl Into<String>, group_name: impl Into<String>) -> Self {
+                Self {
+                    url: url.into(),
+                    group_name: group_name.into(),
+                }
+            }
+        }
+        impl ReportingApiEndpoint {
+            pub fn builder() -> ReportingApiEndpointBuilder {
+                ReportingApiEndpointBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReportingApiEndpointBuilder {
+            url: Option<String>,
+            group_name: Option<String>,
+        }
+        impl ReportingApiEndpointBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn group_name(mut self, group_name: impl Into<String>) -> Self {
+                self.group_name = Some(group_name.into());
+                self
+            }
+            pub fn build(self) -> Result<ReportingApiEndpoint, String> {
+                Ok(ReportingApiEndpoint {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    group_name: self.group_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(group_name))
+                    })?,
+                })
+            }
+        }
+        impl ReportingApiEndpoint {
+            pub const IDENTIFIER: &'static str = "Network.ReportingApiEndpoint";
+        }
+        #[doc = "Unique identifier for a device bound session.\n[DeviceBoundSessionKey](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-DeviceBoundSessionKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeviceBoundSessionKey {
+            #[doc = "The site the session is set up for."]
+            #[serde(rename = "site")]
+            pub site: String,
+            #[doc = "The id of the session."]
+            #[serde(rename = "id")]
+            pub id: String,
+        }
+        impl DeviceBoundSessionKey {
+            pub fn new(site: impl Into<String>, id: impl Into<String>) -> Self {
+                Self {
+                    site: site.into(),
+                    id: id.into(),
+                }
+            }
+        }
+        impl DeviceBoundSessionKey {
+            pub fn builder() -> DeviceBoundSessionKeyBuilder {
+                DeviceBoundSessionKeyBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeviceBoundSessionKeyBuilder {
+            site: Option<String>,
+            id: Option<String>,
+        }
+        impl DeviceBoundSessionKeyBuilder {
+            pub fn site(mut self, site: impl Into<String>) -> Self {
+                self.site = Some(site.into());
+                self
+            }
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn build(self) -> Result<DeviceBoundSessionKey, String> {
+                Ok(DeviceBoundSessionKey {
+                    site: self.site.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(site))
+                    })?,
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                })
+            }
+        }
+        impl DeviceBoundSessionKey {
+            pub const IDENTIFIER: &'static str = "Network.DeviceBoundSessionKey";
+        }
+        #[doc = "A device bound session's cookie craving.\n[DeviceBoundSessionCookieCraving](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-DeviceBoundSessionCookieCraving)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeviceBoundSessionCookieCraving {
+            #[doc = "The name of the craving."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "The domain of the craving."]
+            #[serde(rename = "domain")]
+            pub domain: String,
+            #[doc = "The path of the craving."]
+            #[serde(rename = "path")]
+            pub path: String,
+            #[doc = "The `Secure` attribute of the craving attributes."]
+            #[serde(rename = "secure")]
+            pub secure: bool,
+            #[doc = "The `HttpOnly` attribute of the craving attributes."]
+            #[serde(rename = "httpOnly")]
+            pub http_only: bool,
+            #[doc = "The `SameSite` attribute of the craving attributes."]
+            #[serde(rename = "sameSite")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub same_site: Option<CookieSameSite>,
+        }
+        impl DeviceBoundSessionCookieCraving {
+            pub fn builder() -> DeviceBoundSessionCookieCravingBuilder {
+                DeviceBoundSessionCookieCravingBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeviceBoundSessionCookieCravingBuilder {
+            name: Option<String>,
+            domain: Option<String>,
+            path: Option<String>,
+            secure: Option<bool>,
+            http_only: Option<bool>,
+            same_site: Option<CookieSameSite>,
+        }
+        impl DeviceBoundSessionCookieCravingBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn domain(mut self, domain: impl Into<String>) -> Self {
+                self.domain = Some(domain.into());
+                self
+            }
+            pub fn path(mut self, path: impl Into<String>) -> Self {
+                self.path = Some(path.into());
+                self
+            }
+            pub fn secure(mut self, secure: impl Into<bool>) -> Self {
+                self.secure = Some(secure.into());
+                self
+            }
+            pub fn http_only(mut self, http_only: impl Into<bool>) -> Self {
+                self.http_only = Some(http_only.into());
+                self
+            }
+            pub fn same_site(mut self, same_site: impl Into<CookieSameSite>) -> Self {
+                self.same_site = Some(same_site.into());
+                self
+            }
+            pub fn build(self) -> Result<DeviceBoundSessionCookieCraving, String> {
+                Ok(DeviceBoundSessionCookieCraving {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    domain: self.domain.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(domain))
+                    })?,
+                    path: self.path.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(path))
+                    })?,
+                    secure: self.secure.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(secure))
+                    })?,
+                    http_only: self.http_only.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(http_only))
+                    })?,
+                    same_site: self.same_site,
+                })
+            }
+        }
+        impl DeviceBoundSessionCookieCraving {
+            pub const IDENTIFIER: &'static str = "Network.DeviceBoundSessionCookieCraving";
+        }
+        #[doc = "A device bound session's inclusion URL rule.\n[DeviceBoundSessionUrlRule](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-DeviceBoundSessionUrlRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeviceBoundSessionUrlRule {
+            #[doc = "See comments on `net::device_bound_sessions::SessionInclusionRules::UrlRule::rule_type`."]
+            #[serde(rename = "ruleType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub rule_type: DeviceBoundSessionUrlRuleRuleType,
+            #[doc = "See comments on `net::device_bound_sessions::SessionInclusionRules::UrlRule::host_pattern`."]
+            #[serde(rename = "hostPattern")]
+            pub host_pattern: String,
+            #[doc = "See comments on `net::device_bound_sessions::SessionInclusionRules::UrlRule::path_prefix`."]
+            #[serde(rename = "pathPrefix")]
+            pub path_prefix: String,
+        }
+        #[doc = "See comments on `net::device_bound_sessions::SessionInclusionRules::UrlRule::rule_type`."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DeviceBoundSessionUrlRuleRuleType {
+            #[serde(rename = "Exclude")]
+            Exclude,
+            #[serde(rename = "Include")]
+            Include,
+        }
+        impl AsRef<str> for DeviceBoundSessionUrlRuleRuleType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DeviceBoundSessionUrlRuleRuleType::Exclude => "Exclude",
+                    DeviceBoundSessionUrlRuleRuleType::Include => "Include",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DeviceBoundSessionUrlRuleRuleType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Exclude" | "exclude" => Ok(DeviceBoundSessionUrlRuleRuleType::Exclude),
+                    "Include" | "include" => Ok(DeviceBoundSessionUrlRuleRuleType::Include),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl DeviceBoundSessionUrlRule {
+            pub fn new(
+                rule_type: impl Into<DeviceBoundSessionUrlRuleRuleType>,
+                host_pattern: impl Into<String>,
+                path_prefix: impl Into<String>,
+            ) -> Self {
+                Self {
+                    rule_type: rule_type.into(),
+                    host_pattern: host_pattern.into(),
+                    path_prefix: path_prefix.into(),
+                }
+            }
+        }
+        impl DeviceBoundSessionUrlRule {
+            pub fn builder() -> DeviceBoundSessionUrlRuleBuilder {
+                DeviceBoundSessionUrlRuleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeviceBoundSessionUrlRuleBuilder {
+            rule_type: Option<DeviceBoundSessionUrlRuleRuleType>,
+            host_pattern: Option<String>,
+            path_prefix: Option<String>,
+        }
+        impl DeviceBoundSessionUrlRuleBuilder {
+            pub fn rule_type(
+                mut self,
+                rule_type: impl Into<DeviceBoundSessionUrlRuleRuleType>,
+            ) -> Self {
+                self.rule_type = Some(rule_type.into());
+                self
+            }
+            pub fn host_pattern(mut self, host_pattern: impl Into<String>) -> Self {
+                self.host_pattern = Some(host_pattern.into());
+                self
+            }
+            pub fn path_prefix(mut self, path_prefix: impl Into<String>) -> Self {
+                self.path_prefix = Some(path_prefix.into());
+                self
+            }
+            pub fn build(self) -> Result<DeviceBoundSessionUrlRule, String> {
+                Ok(DeviceBoundSessionUrlRule {
+                    rule_type: self.rule_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rule_type))
+                    })?,
+                    host_pattern: self.host_pattern.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(host_pattern))
+                    })?,
+                    path_prefix: self.path_prefix.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(path_prefix))
+                    })?,
+                })
+            }
+        }
+        impl DeviceBoundSessionUrlRule {
+            pub const IDENTIFIER: &'static str = "Network.DeviceBoundSessionUrlRule";
+        }
+        #[doc = "A device bound session's inclusion rules.\n[DeviceBoundSessionInclusionRules](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-DeviceBoundSessionInclusionRules)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeviceBoundSessionInclusionRules {
+            #[doc = "See comments on `net::device_bound_sessions::SessionInclusionRules::origin_`."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "Whether the whole site is included. See comments on\n`net::device_bound_sessions::SessionInclusionRules::include_site_` for more\ndetails; this boolean is true if that value is populated."]
+            #[serde(rename = "includeSite")]
+            pub include_site: bool,
+            #[doc = "See comments on `net::device_bound_sessions::SessionInclusionRules::url_rules_`."]
+            #[serde(rename = "urlRules")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub url_rules: Vec<DeviceBoundSessionUrlRule>,
+        }
+        impl DeviceBoundSessionInclusionRules {
+            pub fn new(
+                origin: impl Into<String>,
+                include_site: impl Into<bool>,
+                url_rules: Vec<DeviceBoundSessionUrlRule>,
+            ) -> Self {
+                Self {
+                    origin: origin.into(),
+                    include_site: include_site.into(),
+                    url_rules,
+                }
+            }
+        }
+        impl DeviceBoundSessionInclusionRules {
+            pub fn builder() -> DeviceBoundSessionInclusionRulesBuilder {
+                DeviceBoundSessionInclusionRulesBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeviceBoundSessionInclusionRulesBuilder {
+            origin: Option<String>,
+            include_site: Option<bool>,
+            url_rules: Option<Vec<DeviceBoundSessionUrlRule>>,
+        }
+        impl DeviceBoundSessionInclusionRulesBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn include_site(mut self, include_site: impl Into<bool>) -> Self {
+                self.include_site = Some(include_site.into());
+                self
+            }
+            pub fn url_rule(mut self, url_rule: impl Into<DeviceBoundSessionUrlRule>) -> Self {
+                let v = self.url_rules.get_or_insert(Vec::new());
+                v.push(url_rule.into());
+                self
+            }
+            pub fn url_rules<I, S>(mut self, url_rules: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<DeviceBoundSessionUrlRule>,
+            {
+                let v = self.url_rules.get_or_insert(Vec::new());
+                for val in url_rules {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<DeviceBoundSessionInclusionRules, String> {
+                Ok(DeviceBoundSessionInclusionRules {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    include_site: self.include_site.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(include_site))
+                    })?,
+                    url_rules: self.url_rules.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(url_rules))
+                    })?,
+                })
+            }
+        }
+        impl DeviceBoundSessionInclusionRules {
+            pub const IDENTIFIER: &'static str = "Network.DeviceBoundSessionInclusionRules";
+        }
+        #[doc = "A device bound session.\n[DeviceBoundSession](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-DeviceBoundSession)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeviceBoundSession {
+            #[doc = "The site and session ID of the session."]
+            #[serde(rename = "key")]
+            pub key: DeviceBoundSessionKey,
+            #[doc = "See comments on `net::device_bound_sessions::Session::refresh_url_`."]
+            #[serde(rename = "refreshUrl")]
+            pub refresh_url: String,
+            #[doc = "See comments on `net::device_bound_sessions::Session::inclusion_rules_`."]
+            #[serde(rename = "inclusionRules")]
+            pub inclusion_rules: DeviceBoundSessionInclusionRules,
+            #[doc = "See comments on `net::device_bound_sessions::Session::cookie_cravings_`."]
+            #[serde(rename = "cookieCravings")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub cookie_cravings: Vec<DeviceBoundSessionCookieCraving>,
+            #[doc = "See comments on `net::device_bound_sessions::Session::expiry_date_`."]
+            #[serde(rename = "expiryDate")]
+            pub expiry_date: super::network::TimeSinceEpoch,
+            #[doc = "See comments on `net::device_bound_sessions::Session::cached_challenge__`."]
+            #[serde(rename = "cachedChallenge")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cached_challenge: Option<String>,
+            #[doc = "See comments on `net::device_bound_sessions::Session::allowed_refresh_initiators_`."]
+            #[serde(rename = "allowedRefreshInitiators")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub allowed_refresh_initiators: Vec<String>,
+        }
+        impl DeviceBoundSession {
+            pub fn builder() -> DeviceBoundSessionBuilder {
+                DeviceBoundSessionBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeviceBoundSessionBuilder {
+            key: Option<DeviceBoundSessionKey>,
+            refresh_url: Option<String>,
+            inclusion_rules: Option<DeviceBoundSessionInclusionRules>,
+            cookie_cravings: Option<Vec<DeviceBoundSessionCookieCraving>>,
+            expiry_date: Option<super::network::TimeSinceEpoch>,
+            cached_challenge: Option<String>,
+            allowed_refresh_initiators: Option<Vec<String>>,
+        }
+        impl DeviceBoundSessionBuilder {
+            pub fn key(mut self, key: impl Into<DeviceBoundSessionKey>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn refresh_url(mut self, refresh_url: impl Into<String>) -> Self {
+                self.refresh_url = Some(refresh_url.into());
+                self
+            }
+            pub fn inclusion_rules(
+                mut self,
+                inclusion_rules: impl Into<DeviceBoundSessionInclusionRules>,
+            ) -> Self {
+                self.inclusion_rules = Some(inclusion_rules.into());
+                self
+            }
+            pub fn cookie_craving(
+                mut self,
+                cookie_craving: impl Into<DeviceBoundSessionCookieCraving>,
+            ) -> Self {
+                let v = self.cookie_cravings.get_or_insert(Vec::new());
+                v.push(cookie_craving.into());
+                self
+            }
+            pub fn cookie_cravings<I, S>(mut self, cookie_cravings: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<DeviceBoundSessionCookieCraving>,
+            {
+                let v = self.cookie_cravings.get_or_insert(Vec::new());
+                for val in cookie_cravings {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn expiry_date(
+                mut self,
+                expiry_date: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.expiry_date = Some(expiry_date.into());
+                self
+            }
+            pub fn cached_challenge(mut self, cached_challenge: impl Into<String>) -> Self {
+                self.cached_challenge = Some(cached_challenge.into());
+                self
+            }
+            pub fn allowed_refresh_initiator(
+                mut self,
+                allowed_refresh_initiator: impl Into<String>,
+            ) -> Self {
+                let v = self.allowed_refresh_initiators.get_or_insert(Vec::new());
+                v.push(allowed_refresh_initiator.into());
+                self
+            }
+            pub fn allowed_refresh_initiators<I, S>(mut self, allowed_refresh_initiators: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.allowed_refresh_initiators.get_or_insert(Vec::new());
+                for val in allowed_refresh_initiators {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<DeviceBoundSession, String> {
+                Ok(DeviceBoundSession {
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    refresh_url: self.refresh_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(refresh_url))
+                    })?,
+                    inclusion_rules: self.inclusion_rules.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(inclusion_rules))
+                    })?,
+                    cookie_cravings: self.cookie_cravings.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cookie_cravings))
+                    })?,
+                    expiry_date: self.expiry_date.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expiry_date))
+                    })?,
+                    cached_challenge: self.cached_challenge,
+                    allowed_refresh_initiators: self.allowed_refresh_initiators.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(allowed_refresh_initiators)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl DeviceBoundSession {
+            pub const IDENTIFIER: &'static str = "Network.DeviceBoundSession";
+        }
+        #[doc = "A unique identifier for a device bound session event.\n[DeviceBoundSessionEventId](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-DeviceBoundSessionEventId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct DeviceBoundSessionEventId(String);
+        impl DeviceBoundSessionEventId {
+            pub fn new(val: impl Into<String>) -> Self {
+                DeviceBoundSessionEventId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for DeviceBoundSessionEventId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<DeviceBoundSessionEventId> for String {
+            fn from(el: DeviceBoundSessionEventId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for DeviceBoundSessionEventId {
+            fn from(expr: String) -> Self {
+                DeviceBoundSessionEventId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for DeviceBoundSessionEventId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl DeviceBoundSessionEventId {
+            pub const IDENTIFIER: &'static str = "Network.DeviceBoundSessionEventId";
+        }
+        #[doc = "A fetch result for a device bound session creation or refresh."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DeviceBoundSessionFetchResult {
+            #[serde(rename = "Success")]
+            Success,
+            #[serde(rename = "KeyError")]
+            KeyError,
+            #[serde(rename = "SigningError")]
+            SigningError,
+            #[serde(rename = "ServerRequestedTermination")]
+            ServerRequestedTermination,
+            #[serde(rename = "InvalidSessionId")]
+            InvalidSessionId,
+            #[serde(rename = "InvalidChallenge")]
+            InvalidChallenge,
+            #[serde(rename = "TooManyChallenges")]
+            TooManyChallenges,
+            #[serde(rename = "InvalidFetcherUrl")]
+            InvalidFetcherUrl,
+            #[serde(rename = "InvalidRefreshUrl")]
+            InvalidRefreshUrl,
+            #[serde(rename = "TransientHttpError")]
+            TransientHttpError,
+            #[serde(rename = "ScopeOriginSameSiteMismatch")]
+            ScopeOriginSameSiteMismatch,
+            #[serde(rename = "RefreshUrlSameSiteMismatch")]
+            RefreshUrlSameSiteMismatch,
+            #[serde(rename = "MismatchedSessionId")]
+            MismatchedSessionId,
+            #[serde(rename = "MissingScope")]
+            MissingScope,
+            #[serde(rename = "NoCredentials")]
+            NoCredentials,
+            #[serde(rename = "SubdomainRegistrationWellKnownUnavailable")]
+            SubdomainRegistrationWellKnownUnavailable,
+            #[serde(rename = "SubdomainRegistrationUnauthorized")]
+            SubdomainRegistrationUnauthorized,
+            #[serde(rename = "SubdomainRegistrationWellKnownMalformed")]
+            SubdomainRegistrationWellKnownMalformed,
+            #[serde(rename = "SessionProviderWellKnownUnavailable")]
+            SessionProviderWellKnownUnavailable,
+            #[serde(rename = "RelyingPartyWellKnownUnavailable")]
+            RelyingPartyWellKnownUnavailable,
+            #[serde(rename = "FederatedKeyThumbprintMismatch")]
+            FederatedKeyThumbprintMismatch,
+            #[serde(rename = "InvalidFederatedSessionUrl")]
+            InvalidFederatedSessionUrl,
+            #[serde(rename = "InvalidFederatedKey")]
+            InvalidFederatedKey,
+            #[serde(rename = "TooManyRelyingOriginLabels")]
+            TooManyRelyingOriginLabels,
+            #[serde(rename = "BoundCookieSetForbidden")]
+            BoundCookieSetForbidden,
+            #[serde(rename = "NetError")]
+            NetError,
+            #[serde(rename = "ProxyError")]
+            ProxyError,
+            #[serde(rename = "EmptySessionConfig")]
+            EmptySessionConfig,
+            #[serde(rename = "InvalidCredentialsConfig")]
+            InvalidCredentialsConfig,
+            #[serde(rename = "InvalidCredentialsType")]
+            InvalidCredentialsType,
+            #[serde(rename = "InvalidCredentialsEmptyName")]
+            InvalidCredentialsEmptyName,
+            #[serde(rename = "InvalidCredentialsCookie")]
+            InvalidCredentialsCookie,
+            #[serde(rename = "PersistentHttpError")]
+            PersistentHttpError,
+            #[serde(rename = "RegistrationAttemptedChallenge")]
+            RegistrationAttemptedChallenge,
+            #[serde(rename = "InvalidScopeOrigin")]
+            InvalidScopeOrigin,
+            #[serde(rename = "ScopeOriginContainsPath")]
+            ScopeOriginContainsPath,
+            #[serde(rename = "RefreshInitiatorNotString")]
+            RefreshInitiatorNotString,
+            #[serde(rename = "RefreshInitiatorInvalidHostPattern")]
+            RefreshInitiatorInvalidHostPattern,
+            #[serde(rename = "InvalidScopeSpecification")]
+            InvalidScopeSpecification,
+            #[serde(rename = "MissingScopeSpecificationType")]
+            MissingScopeSpecificationType,
+            #[serde(rename = "EmptyScopeSpecificationDomain")]
+            EmptyScopeSpecificationDomain,
+            #[serde(rename = "EmptyScopeSpecificationPath")]
+            EmptyScopeSpecificationPath,
+            #[serde(rename = "InvalidScopeSpecificationType")]
+            InvalidScopeSpecificationType,
+            #[serde(rename = "InvalidScopeIncludeSite")]
+            InvalidScopeIncludeSite,
+            #[serde(rename = "MissingScopeIncludeSite")]
+            MissingScopeIncludeSite,
+            #[serde(rename = "FederatedNotAuthorizedByProvider")]
+            FederatedNotAuthorizedByProvider,
+            #[serde(rename = "FederatedNotAuthorizedByRelyingParty")]
+            FederatedNotAuthorizedByRelyingParty,
+            #[serde(rename = "SessionProviderWellKnownMalformed")]
+            SessionProviderWellKnownMalformed,
+            #[serde(rename = "SessionProviderWellKnownHasProviderOrigin")]
+            SessionProviderWellKnownHasProviderOrigin,
+            #[serde(rename = "RelyingPartyWellKnownMalformed")]
+            RelyingPartyWellKnownMalformed,
+            #[serde(rename = "RelyingPartyWellKnownHasRelyingOrigins")]
+            RelyingPartyWellKnownHasRelyingOrigins,
+            #[serde(rename = "InvalidFederatedSessionProviderSessionMissing")]
+            InvalidFederatedSessionProviderSessionMissing,
+            #[serde(rename = "InvalidFederatedSessionWrongProviderOrigin")]
+            InvalidFederatedSessionWrongProviderOrigin,
+            #[serde(rename = "InvalidCredentialsCookieCreationTime")]
+            InvalidCredentialsCookieCreationTime,
+            #[serde(rename = "InvalidCredentialsCookieName")]
+            InvalidCredentialsCookieName,
+            #[serde(rename = "InvalidCredentialsCookieParsing")]
+            InvalidCredentialsCookieParsing,
+            #[serde(rename = "InvalidCredentialsCookieUnpermittedAttribute")]
+            InvalidCredentialsCookieUnpermittedAttribute,
+            #[serde(rename = "InvalidCredentialsCookieInvalidDomain")]
+            InvalidCredentialsCookieInvalidDomain,
+            #[serde(rename = "InvalidCredentialsCookiePrefix")]
+            InvalidCredentialsCookiePrefix,
+            #[serde(rename = "InvalidScopeRulePath")]
+            InvalidScopeRulePath,
+            #[serde(rename = "InvalidScopeRuleHostPattern")]
+            InvalidScopeRuleHostPattern,
+            #[serde(rename = "ScopeRuleOriginScopedHostPatternMismatch")]
+            ScopeRuleOriginScopedHostPatternMismatch,
+            #[serde(rename = "ScopeRuleSiteScopedHostPatternMismatch")]
+            ScopeRuleSiteScopedHostPatternMismatch,
+            #[serde(rename = "SigningQuotaExceeded")]
+            SigningQuotaExceeded,
+            #[serde(rename = "InvalidConfigJson")]
+            InvalidConfigJson,
+            #[serde(rename = "InvalidFederatedSessionProviderFailedToRestoreKey")]
+            InvalidFederatedSessionProviderFailedToRestoreKey,
+            #[serde(rename = "FailedToUnwrapKey")]
+            FailedToUnwrapKey,
+            #[serde(rename = "SessionDeletedDuringRefresh")]
+            SessionDeletedDuringRefresh,
+        }
+        impl AsRef<str> for DeviceBoundSessionFetchResult {
+            fn as_ref(&self) -> &str {
+                match self { DeviceBoundSessionFetchResult :: Success => "Success" , DeviceBoundSessionFetchResult :: KeyError => "KeyError" , DeviceBoundSessionFetchResult :: SigningError => "SigningError" , DeviceBoundSessionFetchResult :: ServerRequestedTermination => "ServerRequestedTermination" , DeviceBoundSessionFetchResult :: InvalidSessionId => "InvalidSessionId" , DeviceBoundSessionFetchResult :: InvalidChallenge => "InvalidChallenge" , DeviceBoundSessionFetchResult :: TooManyChallenges => "TooManyChallenges" , DeviceBoundSessionFetchResult :: InvalidFetcherUrl => "InvalidFetcherUrl" , DeviceBoundSessionFetchResult :: InvalidRefreshUrl => "InvalidRefreshUrl" , DeviceBoundSessionFetchResult :: TransientHttpError => "TransientHttpError" , DeviceBoundSessionFetchResult :: ScopeOriginSameSiteMismatch => "ScopeOriginSameSiteMismatch" , DeviceBoundSessionFetchResult :: RefreshUrlSameSiteMismatch => "RefreshUrlSameSiteMismatch" , DeviceBoundSessionFetchResult :: MismatchedSessionId => "MismatchedSessionId" , DeviceBoundSessionFetchResult :: MissingScope => "MissingScope" , DeviceBoundSessionFetchResult :: NoCredentials => "NoCredentials" , DeviceBoundSessionFetchResult :: SubdomainRegistrationWellKnownUnavailable => "SubdomainRegistrationWellKnownUnavailable" , DeviceBoundSessionFetchResult :: SubdomainRegistrationUnauthorized => "SubdomainRegistrationUnauthorized" , DeviceBoundSessionFetchResult :: SubdomainRegistrationWellKnownMalformed => "SubdomainRegistrationWellKnownMalformed" , DeviceBoundSessionFetchResult :: SessionProviderWellKnownUnavailable => "SessionProviderWellKnownUnavailable" , DeviceBoundSessionFetchResult :: RelyingPartyWellKnownUnavailable => "RelyingPartyWellKnownUnavailable" , DeviceBoundSessionFetchResult :: FederatedKeyThumbprintMismatch => "FederatedKeyThumbprintMismatch" , DeviceBoundSessionFetchResult :: InvalidFederatedSessionUrl => "InvalidFederatedSessionUrl" , DeviceBoundSessionFetchResult :: InvalidFederatedKey => "InvalidFederatedKey" , DeviceBoundSessionFetchResult :: TooManyRelyingOriginLabels => "TooManyRelyingOriginLabels" , DeviceBoundSessionFetchResult :: BoundCookieSetForbidden => "BoundCookieSetForbidden" , DeviceBoundSessionFetchResult :: NetError => "NetError" , DeviceBoundSessionFetchResult :: ProxyError => "ProxyError" , DeviceBoundSessionFetchResult :: EmptySessionConfig => "EmptySessionConfig" , DeviceBoundSessionFetchResult :: InvalidCredentialsConfig => "InvalidCredentialsConfig" , DeviceBoundSessionFetchResult :: InvalidCredentialsType => "InvalidCredentialsType" , DeviceBoundSessionFetchResult :: InvalidCredentialsEmptyName => "InvalidCredentialsEmptyName" , DeviceBoundSessionFetchResult :: InvalidCredentialsCookie => "InvalidCredentialsCookie" , DeviceBoundSessionFetchResult :: PersistentHttpError => "PersistentHttpError" , DeviceBoundSessionFetchResult :: RegistrationAttemptedChallenge => "RegistrationAttemptedChallenge" , DeviceBoundSessionFetchResult :: InvalidScopeOrigin => "InvalidScopeOrigin" , DeviceBoundSessionFetchResult :: ScopeOriginContainsPath => "ScopeOriginContainsPath" , DeviceBoundSessionFetchResult :: RefreshInitiatorNotString => "RefreshInitiatorNotString" , DeviceBoundSessionFetchResult :: RefreshInitiatorInvalidHostPattern => "RefreshInitiatorInvalidHostPattern" , DeviceBoundSessionFetchResult :: InvalidScopeSpecification => "InvalidScopeSpecification" , DeviceBoundSessionFetchResult :: MissingScopeSpecificationType => "MissingScopeSpecificationType" , DeviceBoundSessionFetchResult :: EmptyScopeSpecificationDomain => "EmptyScopeSpecificationDomain" , DeviceBoundSessionFetchResult :: EmptyScopeSpecificationPath => "EmptyScopeSpecificationPath" , DeviceBoundSessionFetchResult :: InvalidScopeSpecificationType => "InvalidScopeSpecificationType" , DeviceBoundSessionFetchResult :: InvalidScopeIncludeSite => "InvalidScopeIncludeSite" , DeviceBoundSessionFetchResult :: MissingScopeIncludeSite => "MissingScopeIncludeSite" , DeviceBoundSessionFetchResult :: FederatedNotAuthorizedByProvider => "FederatedNotAuthorizedByProvider" , DeviceBoundSessionFetchResult :: FederatedNotAuthorizedByRelyingParty => "FederatedNotAuthorizedByRelyingParty" , DeviceBoundSessionFetchResult :: SessionProviderWellKnownMalformed => "SessionProviderWellKnownMalformed" , DeviceBoundSessionFetchResult :: SessionProviderWellKnownHasProviderOrigin => "SessionProviderWellKnownHasProviderOrigin" , DeviceBoundSessionFetchResult :: RelyingPartyWellKnownMalformed => "RelyingPartyWellKnownMalformed" , DeviceBoundSessionFetchResult :: RelyingPartyWellKnownHasRelyingOrigins => "RelyingPartyWellKnownHasRelyingOrigins" , DeviceBoundSessionFetchResult :: InvalidFederatedSessionProviderSessionMissing => "InvalidFederatedSessionProviderSessionMissing" , DeviceBoundSessionFetchResult :: InvalidFederatedSessionWrongProviderOrigin => "InvalidFederatedSessionWrongProviderOrigin" , DeviceBoundSessionFetchResult :: InvalidCredentialsCookieCreationTime => "InvalidCredentialsCookieCreationTime" , DeviceBoundSessionFetchResult :: InvalidCredentialsCookieName => "InvalidCredentialsCookieName" , DeviceBoundSessionFetchResult :: InvalidCredentialsCookieParsing => "InvalidCredentialsCookieParsing" , DeviceBoundSessionFetchResult :: InvalidCredentialsCookieUnpermittedAttribute => "InvalidCredentialsCookieUnpermittedAttribute" , DeviceBoundSessionFetchResult :: InvalidCredentialsCookieInvalidDomain => "InvalidCredentialsCookieInvalidDomain" , DeviceBoundSessionFetchResult :: InvalidCredentialsCookiePrefix => "InvalidCredentialsCookiePrefix" , DeviceBoundSessionFetchResult :: InvalidScopeRulePath => "InvalidScopeRulePath" , DeviceBoundSessionFetchResult :: InvalidScopeRuleHostPattern => "InvalidScopeRuleHostPattern" , DeviceBoundSessionFetchResult :: ScopeRuleOriginScopedHostPatternMismatch => "ScopeRuleOriginScopedHostPatternMismatch" , DeviceBoundSessionFetchResult :: ScopeRuleSiteScopedHostPatternMismatch => "ScopeRuleSiteScopedHostPatternMismatch" , DeviceBoundSessionFetchResult :: SigningQuotaExceeded => "SigningQuotaExceeded" , DeviceBoundSessionFetchResult :: InvalidConfigJson => "InvalidConfigJson" , DeviceBoundSessionFetchResult :: InvalidFederatedSessionProviderFailedToRestoreKey => "InvalidFederatedSessionProviderFailedToRestoreKey" , DeviceBoundSessionFetchResult :: FailedToUnwrapKey => "FailedToUnwrapKey" , DeviceBoundSessionFetchResult :: SessionDeletedDuringRefresh => "SessionDeletedDuringRefresh" }
+            }
+        }
+        impl ::std::str::FromStr for DeviceBoundSessionFetchResult {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s { "Success" | "success" => Ok (DeviceBoundSessionFetchResult :: Success) , "KeyError" | "keyerror" => Ok (DeviceBoundSessionFetchResult :: KeyError) , "SigningError" | "signingerror" => Ok (DeviceBoundSessionFetchResult :: SigningError) , "ServerRequestedTermination" | "serverrequestedtermination" => Ok (DeviceBoundSessionFetchResult :: ServerRequestedTermination) , "InvalidSessionId" | "invalidsessionid" => Ok (DeviceBoundSessionFetchResult :: InvalidSessionId) , "InvalidChallenge" | "invalidchallenge" => Ok (DeviceBoundSessionFetchResult :: InvalidChallenge) , "TooManyChallenges" | "toomanychallenges" => Ok (DeviceBoundSessionFetchResult :: TooManyChallenges) , "InvalidFetcherUrl" | "invalidfetcherurl" => Ok (DeviceBoundSessionFetchResult :: InvalidFetcherUrl) , "InvalidRefreshUrl" | "invalidrefreshurl" => Ok (DeviceBoundSessionFetchResult :: InvalidRefreshUrl) , "TransientHttpError" | "transienthttperror" => Ok (DeviceBoundSessionFetchResult :: TransientHttpError) , "ScopeOriginSameSiteMismatch" | "scopeoriginsamesitemismatch" => Ok (DeviceBoundSessionFetchResult :: ScopeOriginSameSiteMismatch) , "RefreshUrlSameSiteMismatch" | "refreshurlsamesitemismatch" => Ok (DeviceBoundSessionFetchResult :: RefreshUrlSameSiteMismatch) , "MismatchedSessionId" | "mismatchedsessionid" => Ok (DeviceBoundSessionFetchResult :: MismatchedSessionId) , "MissingScope" | "missingscope" => Ok (DeviceBoundSessionFetchResult :: MissingScope) , "NoCredentials" | "nocredentials" => Ok (DeviceBoundSessionFetchResult :: NoCredentials) , "SubdomainRegistrationWellKnownUnavailable" | "subdomainregistrationwellknownunavailable" => Ok (DeviceBoundSessionFetchResult :: SubdomainRegistrationWellKnownUnavailable) , "SubdomainRegistrationUnauthorized" | "subdomainregistrationunauthorized" => Ok (DeviceBoundSessionFetchResult :: SubdomainRegistrationUnauthorized) , "SubdomainRegistrationWellKnownMalformed" | "subdomainregistrationwellknownmalformed" => Ok (DeviceBoundSessionFetchResult :: SubdomainRegistrationWellKnownMalformed) , "SessionProviderWellKnownUnavailable" | "sessionproviderwellknownunavailable" => Ok (DeviceBoundSessionFetchResult :: SessionProviderWellKnownUnavailable) , "RelyingPartyWellKnownUnavailable" | "relyingpartywellknownunavailable" => Ok (DeviceBoundSessionFetchResult :: RelyingPartyWellKnownUnavailable) , "FederatedKeyThumbprintMismatch" | "federatedkeythumbprintmismatch" => Ok (DeviceBoundSessionFetchResult :: FederatedKeyThumbprintMismatch) , "InvalidFederatedSessionUrl" | "invalidfederatedsessionurl" => Ok (DeviceBoundSessionFetchResult :: InvalidFederatedSessionUrl) , "InvalidFederatedKey" | "invalidfederatedkey" => Ok (DeviceBoundSessionFetchResult :: InvalidFederatedKey) , "TooManyRelyingOriginLabels" | "toomanyrelyingoriginlabels" => Ok (DeviceBoundSessionFetchResult :: TooManyRelyingOriginLabels) , "BoundCookieSetForbidden" | "boundcookiesetforbidden" => Ok (DeviceBoundSessionFetchResult :: BoundCookieSetForbidden) , "NetError" | "neterror" => Ok (DeviceBoundSessionFetchResult :: NetError) , "ProxyError" | "proxyerror" => Ok (DeviceBoundSessionFetchResult :: ProxyError) , "EmptySessionConfig" | "emptysessionconfig" => Ok (DeviceBoundSessionFetchResult :: EmptySessionConfig) , "InvalidCredentialsConfig" | "invalidcredentialsconfig" => Ok (DeviceBoundSessionFetchResult :: InvalidCredentialsConfig) , "InvalidCredentialsType" | "invalidcredentialstype" => Ok (DeviceBoundSessionFetchResult :: InvalidCredentialsType) , "InvalidCredentialsEmptyName" | "invalidcredentialsemptyname" => Ok (DeviceBoundSessionFetchResult :: InvalidCredentialsEmptyName) , "InvalidCredentialsCookie" | "invalidcredentialscookie" => Ok (DeviceBoundSessionFetchResult :: InvalidCredentialsCookie) , "PersistentHttpError" | "persistenthttperror" => Ok (DeviceBoundSessionFetchResult :: PersistentHttpError) , "RegistrationAttemptedChallenge" | "registrationattemptedchallenge" => Ok (DeviceBoundSessionFetchResult :: RegistrationAttemptedChallenge) , "InvalidScopeOrigin" | "invalidscopeorigin" => Ok (DeviceBoundSessionFetchResult :: InvalidScopeOrigin) , "ScopeOriginContainsPath" | "scopeorigincontainspath" => Ok (DeviceBoundSessionFetchResult :: ScopeOriginContainsPath) , "RefreshInitiatorNotString" | "refreshinitiatornotstring" => Ok (DeviceBoundSessionFetchResult :: RefreshInitiatorNotString) , "RefreshInitiatorInvalidHostPattern" | "refreshinitiatorinvalidhostpattern" => Ok (DeviceBoundSessionFetchResult :: RefreshInitiatorInvalidHostPattern) , "InvalidScopeSpecification" | "invalidscopespecification" => Ok (DeviceBoundSessionFetchResult :: InvalidScopeSpecification) , "MissingScopeSpecificationType" | "missingscopespecificationtype" => Ok (DeviceBoundSessionFetchResult :: MissingScopeSpecificationType) , "EmptyScopeSpecificationDomain" | "emptyscopespecificationdomain" => Ok (DeviceBoundSessionFetchResult :: EmptyScopeSpecificationDomain) , "EmptyScopeSpecificationPath" | "emptyscopespecificationpath" => Ok (DeviceBoundSessionFetchResult :: EmptyScopeSpecificationPath) , "InvalidScopeSpecificationType" | "invalidscopespecificationtype" => Ok (DeviceBoundSessionFetchResult :: InvalidScopeSpecificationType) , "InvalidScopeIncludeSite" | "invalidscopeincludesite" => Ok (DeviceBoundSessionFetchResult :: InvalidScopeIncludeSite) , "MissingScopeIncludeSite" | "missingscopeincludesite" => Ok (DeviceBoundSessionFetchResult :: MissingScopeIncludeSite) , "FederatedNotAuthorizedByProvider" | "federatednotauthorizedbyprovider" => Ok (DeviceBoundSessionFetchResult :: FederatedNotAuthorizedByProvider) , "FederatedNotAuthorizedByRelyingParty" | "federatednotauthorizedbyrelyingparty" => Ok (DeviceBoundSessionFetchResult :: FederatedNotAuthorizedByRelyingParty) , "SessionProviderWellKnownMalformed" | "sessionproviderwellknownmalformed" => Ok (DeviceBoundSessionFetchResult :: SessionProviderWellKnownMalformed) , "SessionProviderWellKnownHasProviderOrigin" | "sessionproviderwellknownhasproviderorigin" => Ok (DeviceBoundSessionFetchResult :: SessionProviderWellKnownHasProviderOrigin) , "RelyingPartyWellKnownMalformed" | "relyingpartywellknownmalformed" => Ok (DeviceBoundSessionFetchResult :: RelyingPartyWellKnownMalformed) , "RelyingPartyWellKnownHasRelyingOrigins" | "relyingpartywellknownhasrelyingorigins" => Ok (DeviceBoundSessionFetchResult :: RelyingPartyWellKnownHasRelyingOrigins) , "InvalidFederatedSessionProviderSessionMissing" | "invalidfederatedsessionprovidersessionmissing" => Ok (DeviceBoundSessionFetchResult :: InvalidFederatedSessionProviderSessionMissing) , "InvalidFederatedSessionWrongProviderOrigin" | "invalidfederatedsessionwrongproviderorigin" => Ok (DeviceBoundSessionFetchResult :: InvalidFederatedSessionWrongProviderOrigin) , "InvalidCredentialsCookieCreationTime" | "invalidcredentialscookiecreationtime" => Ok (DeviceBoundSessionFetchResult :: InvalidCredentialsCookieCreationTime) , "InvalidCredentialsCookieName" | "invalidcredentialscookiename" => Ok (DeviceBoundSessionFetchResult :: InvalidCredentialsCookieName) , "InvalidCredentialsCookieParsing" | "invalidcredentialscookieparsing" => Ok (DeviceBoundSessionFetchResult :: InvalidCredentialsCookieParsing) , "InvalidCredentialsCookieUnpermittedAttribute" | "invalidcredentialscookieunpermittedattribute" => Ok (DeviceBoundSessionFetchResult :: InvalidCredentialsCookieUnpermittedAttribute) , "InvalidCredentialsCookieInvalidDomain" | "invalidcredentialscookieinvaliddomain" => Ok (DeviceBoundSessionFetchResult :: InvalidCredentialsCookieInvalidDomain) , "InvalidCredentialsCookiePrefix" | "invalidcredentialscookieprefix" => Ok (DeviceBoundSessionFetchResult :: InvalidCredentialsCookiePrefix) , "InvalidScopeRulePath" | "invalidscoperulepath" => Ok (DeviceBoundSessionFetchResult :: InvalidScopeRulePath) , "InvalidScopeRuleHostPattern" | "invalidscoperulehostpattern" => Ok (DeviceBoundSessionFetchResult :: InvalidScopeRuleHostPattern) , "ScopeRuleOriginScopedHostPatternMismatch" | "scoperuleoriginscopedhostpatternmismatch" => Ok (DeviceBoundSessionFetchResult :: ScopeRuleOriginScopedHostPatternMismatch) , "ScopeRuleSiteScopedHostPatternMismatch" | "scoperulesitescopedhostpatternmismatch" => Ok (DeviceBoundSessionFetchResult :: ScopeRuleSiteScopedHostPatternMismatch) , "SigningQuotaExceeded" | "signingquotaexceeded" => Ok (DeviceBoundSessionFetchResult :: SigningQuotaExceeded) , "InvalidConfigJson" | "invalidconfigjson" => Ok (DeviceBoundSessionFetchResult :: InvalidConfigJson) , "InvalidFederatedSessionProviderFailedToRestoreKey" | "invalidfederatedsessionproviderfailedtorestorekey" => Ok (DeviceBoundSessionFetchResult :: InvalidFederatedSessionProviderFailedToRestoreKey) , "FailedToUnwrapKey" | "failedtounwrapkey" => Ok (DeviceBoundSessionFetchResult :: FailedToUnwrapKey) , "SessionDeletedDuringRefresh" | "sessiondeletedduringrefresh" => Ok (DeviceBoundSessionFetchResult :: SessionDeletedDuringRefresh) , _ => Err (s . to_string ()) }
+            }
+        }
+        #[doc = "Session event details specific to creation.\n[CreationEventDetails](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-CreationEventDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CreationEventDetails {
+            #[doc = "The result of the fetch attempt."]
+            #[serde(rename = "fetchResult")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub fetch_result: DeviceBoundSessionFetchResult,
+            #[doc = "The session if there was a newly created session. This is populated for\nall successful creation events."]
+            #[serde(rename = "newSession")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub new_session: Option<DeviceBoundSession>,
+        }
+        impl CreationEventDetails {
+            pub fn new(fetch_result: impl Into<DeviceBoundSessionFetchResult>) -> Self {
+                Self {
+                    fetch_result: fetch_result.into(),
+                    new_session: None,
+                }
+            }
+        }
+        impl CreationEventDetails {
+            pub fn builder() -> CreationEventDetailsBuilder {
+                CreationEventDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CreationEventDetailsBuilder {
+            fetch_result: Option<DeviceBoundSessionFetchResult>,
+            new_session: Option<DeviceBoundSession>,
+        }
+        impl CreationEventDetailsBuilder {
+            pub fn fetch_result(
+                mut self,
+                fetch_result: impl Into<DeviceBoundSessionFetchResult>,
+            ) -> Self {
+                self.fetch_result = Some(fetch_result.into());
+                self
+            }
+            pub fn new_session(mut self, new_session: impl Into<DeviceBoundSession>) -> Self {
+                self.new_session = Some(new_session.into());
+                self
+            }
+            pub fn build(self) -> Result<CreationEventDetails, String> {
+                Ok(CreationEventDetails {
+                    fetch_result: self.fetch_result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(fetch_result))
+                    })?,
+                    new_session: self.new_session,
+                })
+            }
+        }
+        impl CreationEventDetails {
+            pub const IDENTIFIER: &'static str = "Network.CreationEventDetails";
+        }
+        #[doc = "Session event details specific to refresh.\n[RefreshEventDetails](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-RefreshEventDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RefreshEventDetails {
+            #[doc = "The result of a refresh."]
+            #[serde(rename = "refreshResult")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub refresh_result: RefreshEventDetailsRefreshResult,
+            #[doc = "If there was a fetch attempt, the result of that."]
+            #[serde(rename = "fetchResult")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub fetch_result: Option<DeviceBoundSessionFetchResult>,
+            #[doc = "The session display if there was a newly created session. This is populated\nfor any refresh event that modifies the session config."]
+            #[serde(rename = "newSession")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub new_session: Option<DeviceBoundSession>,
+            #[doc = "See comments on `net::device_bound_sessions::RefreshEventResult::was_fully_proactive_refresh`."]
+            #[serde(rename = "wasFullyProactiveRefresh")]
+            pub was_fully_proactive_refresh: bool,
+        }
+        #[doc = "The result of a refresh."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum RefreshEventDetailsRefreshResult {
+            #[serde(rename = "Refreshed")]
+            Refreshed,
+            #[serde(rename = "InitializedService")]
+            InitializedService,
+            #[serde(rename = "Unreachable")]
+            Unreachable,
+            #[serde(rename = "ServerError")]
+            ServerError,
+            #[serde(rename = "RefreshQuotaExceeded")]
+            RefreshQuotaExceeded,
+            #[serde(rename = "FatalError")]
+            FatalError,
+            #[serde(rename = "SigningQuotaExceeded")]
+            SigningQuotaExceeded,
+        }
+        impl AsRef<str> for RefreshEventDetailsRefreshResult {
+            fn as_ref(&self) -> &str {
+                match self {
+                    RefreshEventDetailsRefreshResult::Refreshed => "Refreshed",
+                    RefreshEventDetailsRefreshResult::InitializedService => "InitializedService",
+                    RefreshEventDetailsRefreshResult::Unreachable => "Unreachable",
+                    RefreshEventDetailsRefreshResult::ServerError => "ServerError",
+                    RefreshEventDetailsRefreshResult::RefreshQuotaExceeded => {
+                        "RefreshQuotaExceeded"
+                    }
+                    RefreshEventDetailsRefreshResult::FatalError => "FatalError",
+                    RefreshEventDetailsRefreshResult::SigningQuotaExceeded => {
+                        "SigningQuotaExceeded"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for RefreshEventDetailsRefreshResult {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Refreshed" | "refreshed" => Ok(RefreshEventDetailsRefreshResult::Refreshed),
+                    "InitializedService" | "initializedservice" => {
+                        Ok(RefreshEventDetailsRefreshResult::InitializedService)
+                    }
+                    "Unreachable" | "unreachable" => {
+                        Ok(RefreshEventDetailsRefreshResult::Unreachable)
+                    }
+                    "ServerError" | "servererror" => {
+                        Ok(RefreshEventDetailsRefreshResult::ServerError)
+                    }
+                    "RefreshQuotaExceeded" | "refreshquotaexceeded" => {
+                        Ok(RefreshEventDetailsRefreshResult::RefreshQuotaExceeded)
+                    }
+                    "FatalError" | "fatalerror" => Ok(RefreshEventDetailsRefreshResult::FatalError),
+                    "SigningQuotaExceeded" | "signingquotaexceeded" => {
+                        Ok(RefreshEventDetailsRefreshResult::SigningQuotaExceeded)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl RefreshEventDetails {
+            pub fn new(
+                refresh_result: impl Into<RefreshEventDetailsRefreshResult>,
+                was_fully_proactive_refresh: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    refresh_result: refresh_result.into(),
+                    was_fully_proactive_refresh: was_fully_proactive_refresh.into(),
+                    fetch_result: None,
+                    new_session: None,
+                }
+            }
+        }
+        impl RefreshEventDetails {
+            pub fn builder() -> RefreshEventDetailsBuilder {
+                RefreshEventDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RefreshEventDetailsBuilder {
+            refresh_result: Option<RefreshEventDetailsRefreshResult>,
+            fetch_result: Option<DeviceBoundSessionFetchResult>,
+            new_session: Option<DeviceBoundSession>,
+            was_fully_proactive_refresh: Option<bool>,
+        }
+        impl RefreshEventDetailsBuilder {
+            pub fn refresh_result(
+                mut self,
+                refresh_result: impl Into<RefreshEventDetailsRefreshResult>,
+            ) -> Self {
+                self.refresh_result = Some(refresh_result.into());
+                self
+            }
+            pub fn fetch_result(
+                mut self,
+                fetch_result: impl Into<DeviceBoundSessionFetchResult>,
+            ) -> Self {
+                self.fetch_result = Some(fetch_result.into());
+                self
+            }
+            pub fn new_session(mut self, new_session: impl Into<DeviceBoundSession>) -> Self {
+                self.new_session = Some(new_session.into());
+                self
+            }
+            pub fn was_fully_proactive_refresh(
+                mut self,
+                was_fully_proactive_refresh: impl Into<bool>,
+            ) -> Self {
+                self.was_fully_proactive_refresh = Some(was_fully_proactive_refresh.into());
+                self
+            }
+            pub fn build(self) -> Result<RefreshEventDetails, String> {
+                Ok(RefreshEventDetails {
+                    refresh_result: self.refresh_result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(refresh_result))
+                    })?,
+                    fetch_result: self.fetch_result,
+                    new_session: self.new_session,
+                    was_fully_proactive_refresh: self.was_fully_proactive_refresh.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(was_fully_proactive_refresh)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl RefreshEventDetails {
+            pub const IDENTIFIER: &'static str = "Network.RefreshEventDetails";
+        }
+        #[doc = "Session event details specific to termination.\n[TerminationEventDetails](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-TerminationEventDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TerminationEventDetails {
+            #[doc = "The reason for a session being deleted."]
+            #[serde(rename = "deletionReason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub deletion_reason: TerminationEventDetailsDeletionReason,
+        }
+        #[doc = "The reason for a session being deleted."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum TerminationEventDetailsDeletionReason {
+            #[serde(rename = "Expired")]
+            Expired,
+            #[serde(rename = "FailedToRestoreKey")]
+            FailedToRestoreKey,
+            #[serde(rename = "FailedToUnwrapKey")]
+            FailedToUnwrapKey,
+            #[serde(rename = "StoragePartitionCleared")]
+            StoragePartitionCleared,
+            #[serde(rename = "ClearBrowsingData")]
+            ClearBrowsingData,
+            #[serde(rename = "ServerRequested")]
+            ServerRequested,
+            #[serde(rename = "InvalidSessionParams")]
+            InvalidSessionParams,
+            #[serde(rename = "RefreshFatalError")]
+            RefreshFatalError,
+        }
+        impl AsRef<str> for TerminationEventDetailsDeletionReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    TerminationEventDetailsDeletionReason::Expired => "Expired",
+                    TerminationEventDetailsDeletionReason::FailedToRestoreKey => {
+                        "FailedToRestoreKey"
+                    }
+                    TerminationEventDetailsDeletionReason::FailedToUnwrapKey => "FailedToUnwrapKey",
+                    TerminationEventDetailsDeletionReason::StoragePartitionCleared => {
+                        "StoragePartitionCleared"
+                    }
+                    TerminationEventDetailsDeletionReason::ClearBrowsingData => "ClearBrowsingData",
+                    TerminationEventDetailsDeletionReason::ServerRequested => "ServerRequested",
+                    TerminationEventDetailsDeletionReason::InvalidSessionParams => {
+                        "InvalidSessionParams"
+                    }
+                    TerminationEventDetailsDeletionReason::RefreshFatalError => "RefreshFatalError",
+                }
+            }
+        }
+        impl ::std::str::FromStr for TerminationEventDetailsDeletionReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Expired" | "expired" => Ok(TerminationEventDetailsDeletionReason::Expired),
+                    "FailedToRestoreKey" | "failedtorestorekey" => {
+                        Ok(TerminationEventDetailsDeletionReason::FailedToRestoreKey)
+                    }
+                    "FailedToUnwrapKey" | "failedtounwrapkey" => {
+                        Ok(TerminationEventDetailsDeletionReason::FailedToUnwrapKey)
+                    }
+                    "StoragePartitionCleared" | "storagepartitioncleared" => {
+                        Ok(TerminationEventDetailsDeletionReason::StoragePartitionCleared)
+                    }
+                    "ClearBrowsingData" | "clearbrowsingdata" => {
+                        Ok(TerminationEventDetailsDeletionReason::ClearBrowsingData)
+                    }
+                    "ServerRequested" | "serverrequested" => {
+                        Ok(TerminationEventDetailsDeletionReason::ServerRequested)
+                    }
+                    "InvalidSessionParams" | "invalidsessionparams" => {
+                        Ok(TerminationEventDetailsDeletionReason::InvalidSessionParams)
+                    }
+                    "RefreshFatalError" | "refreshfatalerror" => {
+                        Ok(TerminationEventDetailsDeletionReason::RefreshFatalError)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl TerminationEventDetails {
+            pub fn new(deletion_reason: impl Into<TerminationEventDetailsDeletionReason>) -> Self {
+                Self {
+                    deletion_reason: deletion_reason.into(),
+                }
+            }
+        }
+        impl TerminationEventDetails {
+            pub fn builder() -> TerminationEventDetailsBuilder {
+                TerminationEventDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TerminationEventDetailsBuilder {
+            deletion_reason: Option<TerminationEventDetailsDeletionReason>,
+        }
+        impl TerminationEventDetailsBuilder {
+            pub fn deletion_reason(
+                mut self,
+                deletion_reason: impl Into<TerminationEventDetailsDeletionReason>,
+            ) -> Self {
+                self.deletion_reason = Some(deletion_reason.into());
+                self
+            }
+            pub fn build(self) -> Result<TerminationEventDetails, String> {
+                Ok(TerminationEventDetails {
+                    deletion_reason: self.deletion_reason.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(deletion_reason))
+                    })?,
+                })
+            }
+        }
+        impl TerminationEventDetails {
+            pub const IDENTIFIER: &'static str = "Network.TerminationEventDetails";
+        }
+        #[doc = "Session event details specific to challenges.\n[ChallengeEventDetails](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-ChallengeEventDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ChallengeEventDetails {
+            #[doc = "The result of a challenge."]
+            #[serde(rename = "challengeResult")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub challenge_result: ChallengeEventDetailsChallengeResult,
+            #[doc = "The challenge set."]
+            #[serde(rename = "challenge")]
+            pub challenge: String,
+        }
+        #[doc = "The result of a challenge."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ChallengeEventDetailsChallengeResult {
+            #[serde(rename = "Success")]
+            Success,
+            #[serde(rename = "NoSessionId")]
+            NoSessionId,
+            #[serde(rename = "NoSessionMatch")]
+            NoSessionMatch,
+            #[serde(rename = "CantSetBoundCookie")]
+            CantSetBoundCookie,
+        }
+        impl AsRef<str> for ChallengeEventDetailsChallengeResult {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ChallengeEventDetailsChallengeResult::Success => "Success",
+                    ChallengeEventDetailsChallengeResult::NoSessionId => "NoSessionId",
+                    ChallengeEventDetailsChallengeResult::NoSessionMatch => "NoSessionMatch",
+                    ChallengeEventDetailsChallengeResult::CantSetBoundCookie => {
+                        "CantSetBoundCookie"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for ChallengeEventDetailsChallengeResult {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Success" | "success" => Ok(ChallengeEventDetailsChallengeResult::Success),
+                    "NoSessionId" | "nosessionid" => {
+                        Ok(ChallengeEventDetailsChallengeResult::NoSessionId)
+                    }
+                    "NoSessionMatch" | "nosessionmatch" => {
+                        Ok(ChallengeEventDetailsChallengeResult::NoSessionMatch)
+                    }
+                    "CantSetBoundCookie" | "cantsetboundcookie" => {
+                        Ok(ChallengeEventDetailsChallengeResult::CantSetBoundCookie)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl ChallengeEventDetails {
+            pub fn new(
+                challenge_result: impl Into<ChallengeEventDetailsChallengeResult>,
+                challenge: impl Into<String>,
+            ) -> Self {
+                Self {
+                    challenge_result: challenge_result.into(),
+                    challenge: challenge.into(),
+                }
+            }
+        }
+        impl ChallengeEventDetails {
+            pub fn builder() -> ChallengeEventDetailsBuilder {
+                ChallengeEventDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ChallengeEventDetailsBuilder {
+            challenge_result: Option<ChallengeEventDetailsChallengeResult>,
+            challenge: Option<String>,
+        }
+        impl ChallengeEventDetailsBuilder {
+            pub fn challenge_result(
+                mut self,
+                challenge_result: impl Into<ChallengeEventDetailsChallengeResult>,
+            ) -> Self {
+                self.challenge_result = Some(challenge_result.into());
+                self
+            }
+            pub fn challenge(mut self, challenge: impl Into<String>) -> Self {
+                self.challenge = Some(challenge.into());
+                self
+            }
+            pub fn build(self) -> Result<ChallengeEventDetails, String> {
+                Ok(ChallengeEventDetails {
+                    challenge_result: self.challenge_result.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(challenge_result)
+                        )
+                    })?,
+                    challenge: self.challenge.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(challenge))
+                    })?,
+                })
+            }
+        }
+        impl ChallengeEventDetails {
+            pub const IDENTIFIER: &'static str = "Network.ChallengeEventDetails";
+        }
+        #[doc = "An object providing the result of a network resource load.\n[LoadNetworkResourcePageResult](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-LoadNetworkResourcePageResult)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LoadNetworkResourcePageResult {
+            #[serde(rename = "success")]
+            pub success: bool,
+            #[doc = "Optional values used for error reporting."]
+            #[serde(rename = "netError")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub net_error: Option<f64>,
+            #[serde(rename = "netErrorName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub net_error_name: Option<String>,
+            #[serde(rename = "httpStatusCode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub http_status_code: Option<f64>,
+            #[doc = "If successful, one of the following two fields holds the result."]
+            #[serde(rename = "stream")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stream: Option<super::io::StreamHandle>,
+            #[doc = "Response headers."]
+            #[serde(rename = "headers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub headers: Option<super::network::Headers>,
+        }
+        impl LoadNetworkResourcePageResult {
+            pub fn new(success: impl Into<bool>) -> Self {
+                Self {
+                    success: success.into(),
+                    net_error: None,
+                    net_error_name: None,
+                    http_status_code: None,
+                    stream: None,
+                    headers: None,
+                }
+            }
+        }
+        impl LoadNetworkResourcePageResult {
+            pub fn builder() -> LoadNetworkResourcePageResultBuilder {
+                LoadNetworkResourcePageResultBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LoadNetworkResourcePageResultBuilder {
+            success: Option<bool>,
+            net_error: Option<f64>,
+            net_error_name: Option<String>,
+            http_status_code: Option<f64>,
+            stream: Option<super::io::StreamHandle>,
+            headers: Option<super::network::Headers>,
+        }
+        impl LoadNetworkResourcePageResultBuilder {
+            pub fn success(mut self, success: impl Into<bool>) -> Self {
+                self.success = Some(success.into());
+                self
+            }
+            pub fn net_error(mut self, net_error: impl Into<f64>) -> Self {
+                self.net_error = Some(net_error.into());
+                self
+            }
+            pub fn net_error_name(mut self, net_error_name: impl Into<String>) -> Self {
+                self.net_error_name = Some(net_error_name.into());
+                self
+            }
+            pub fn http_status_code(mut self, http_status_code: impl Into<f64>) -> Self {
+                self.http_status_code = Some(http_status_code.into());
+                self
+            }
+            pub fn stream(mut self, stream: impl Into<super::io::StreamHandle>) -> Self {
+                self.stream = Some(stream.into());
+                self
+            }
+            pub fn headers(mut self, headers: impl Into<super::network::Headers>) -> Self {
+                self.headers = Some(headers.into());
+                self
+            }
+            pub fn build(self) -> Result<LoadNetworkResourcePageResult, String> {
+                Ok(LoadNetworkResourcePageResult {
+                    success: self.success.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(success))
+                    })?,
+                    net_error: self.net_error,
+                    net_error_name: self.net_error_name,
+                    http_status_code: self.http_status_code,
+                    stream: self.stream,
+                    headers: self.headers,
+                })
+            }
+        }
+        impl LoadNetworkResourcePageResult {
+            pub const IDENTIFIER: &'static str = "Network.LoadNetworkResourcePageResult";
+        }
+        #[doc = "An options object that may be extended later to better support CORS,\nCORB and streaming.\n[LoadNetworkResourceOptions](https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-LoadNetworkResourceOptions)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LoadNetworkResourceOptions {
+            #[serde(rename = "disableCache")]
+            pub disable_cache: bool,
+            #[serde(rename = "includeCredentials")]
+            pub include_credentials: bool,
+        }
+        impl LoadNetworkResourceOptions {
+            pub fn new(
+                disable_cache: impl Into<bool>,
+                include_credentials: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    disable_cache: disable_cache.into(),
+                    include_credentials: include_credentials.into(),
+                }
+            }
+        }
+        impl LoadNetworkResourceOptions {
+            pub fn builder() -> LoadNetworkResourceOptionsBuilder {
+                LoadNetworkResourceOptionsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LoadNetworkResourceOptionsBuilder {
+            disable_cache: Option<bool>,
+            include_credentials: Option<bool>,
+        }
+        impl LoadNetworkResourceOptionsBuilder {
+            pub fn disable_cache(mut self, disable_cache: impl Into<bool>) -> Self {
+                self.disable_cache = Some(disable_cache.into());
+                self
+            }
+            pub fn include_credentials(mut self, include_credentials: impl Into<bool>) -> Self {
+                self.include_credentials = Some(include_credentials.into());
+                self
+            }
+            pub fn build(self) -> Result<LoadNetworkResourceOptions, String> {
+                Ok(LoadNetworkResourceOptions {
+                    disable_cache: self.disable_cache.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(disable_cache))
+                    })?,
+                    include_credentials: self.include_credentials.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(include_credentials)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl LoadNetworkResourceOptions {
+            pub const IDENTIFIER: &'static str = "Network.LoadNetworkResourceOptions";
+        }
+        #[doc = "Sets a list of content encodings that will be accepted. Empty list means no encoding is accepted.\n[setAcceptedEncodings](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setAcceptedEncodings)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAcceptedEncodingsParams {
+            #[doc = "List of accepted content encodings."]
+            #[serde(rename = "encodings")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub encodings: Vec<ContentEncoding>,
+        }
+        impl SetAcceptedEncodingsParams {
+            pub fn new(encodings: Vec<ContentEncoding>) -> Self {
+                Self { encodings }
+            }
+        }
+        impl SetAcceptedEncodingsParams {
+            pub fn builder() -> SetAcceptedEncodingsParamsBuilder {
+                SetAcceptedEncodingsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAcceptedEncodingsParamsBuilder {
+            encodings: Option<Vec<ContentEncoding>>,
+        }
+        impl SetAcceptedEncodingsParamsBuilder {
+            pub fn encoding(mut self, encoding: impl Into<ContentEncoding>) -> Self {
+                let v = self.encodings.get_or_insert(Vec::new());
+                v.push(encoding.into());
+                self
+            }
+            pub fn encodings<I, S>(mut self, encodings: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ContentEncoding>,
+            {
+                let v = self.encodings.get_or_insert(Vec::new());
+                for val in encodings {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetAcceptedEncodingsParams, String> {
+                Ok(SetAcceptedEncodingsParams {
+                    encodings: self.encodings.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(encodings))
+                    })?,
+                })
+            }
+        }
+        impl SetAcceptedEncodingsParams {
+            pub const IDENTIFIER: &'static str = "Network.setAcceptedEncodings";
+        }
+        impl chromiumoxide_types::Method for SetAcceptedEncodingsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAcceptedEncodingsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets a list of content encodings that will be accepted. Empty list means no encoding is accepted.\n[setAcceptedEncodings](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setAcceptedEncodings)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAcceptedEncodingsReturns {}
+        impl chromiumoxide_types::Command for SetAcceptedEncodingsParams {
+            type Response = SetAcceptedEncodingsReturns;
+        }
+        #[doc = "Clears accepted encodings set by setAcceptedEncodings\n[clearAcceptedEncodingsOverride](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-clearAcceptedEncodingsOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearAcceptedEncodingsOverrideParams {}
+        impl ClearAcceptedEncodingsOverrideParams {
+            pub const IDENTIFIER: &'static str = "Network.clearAcceptedEncodingsOverride";
+        }
+        impl chromiumoxide_types::Method for ClearAcceptedEncodingsOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearAcceptedEncodingsOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears accepted encodings set by setAcceptedEncodings\n[clearAcceptedEncodingsOverride](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-clearAcceptedEncodingsOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearAcceptedEncodingsOverrideReturns {}
+        impl chromiumoxide_types::Command for ClearAcceptedEncodingsOverrideParams {
+            type Response = ClearAcceptedEncodingsOverrideReturns;
+        }
+        #[doc = "Clears browser cache.\n[clearBrowserCache](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-clearBrowserCache)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearBrowserCacheParams {}
+        impl ClearBrowserCacheParams {
+            pub const IDENTIFIER: &'static str = "Network.clearBrowserCache";
+        }
+        impl chromiumoxide_types::Method for ClearBrowserCacheParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearBrowserCacheParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears browser cache.\n[clearBrowserCache](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-clearBrowserCache)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearBrowserCacheReturns {}
+        impl chromiumoxide_types::Command for ClearBrowserCacheParams {
+            type Response = ClearBrowserCacheReturns;
+        }
+        #[doc = "Clears browser cookies.\n[clearBrowserCookies](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-clearBrowserCookies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearBrowserCookiesParams {}
+        impl ClearBrowserCookiesParams {
+            pub const IDENTIFIER: &'static str = "Network.clearBrowserCookies";
+        }
+        impl chromiumoxide_types::Method for ClearBrowserCookiesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearBrowserCookiesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears browser cookies.\n[clearBrowserCookies](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-clearBrowserCookies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearBrowserCookiesReturns {}
+        impl chromiumoxide_types::Command for ClearBrowserCookiesParams {
+            type Response = ClearBrowserCookiesReturns;
+        }
+        #[doc = "Deletes browser cookies with matching name and url or domain/path/partitionKey pair.\n[deleteCookies](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-deleteCookies)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeleteCookiesParams {
+            #[doc = "Name of the cookies to remove."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "If specified, deletes all the cookies with the given name where domain and path match\nprovided URL."]
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[doc = "If specified, deletes only cookies with the exact domain."]
+            #[serde(rename = "domain")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub domain: Option<String>,
+            #[doc = "If specified, deletes only cookies with the exact path."]
+            #[serde(rename = "path")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub path: Option<String>,
+            #[doc = "If specified, deletes only cookies with the the given name and partitionKey where\nall partition key attributes match the cookie partition key attribute."]
+            #[serde(rename = "partitionKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub partition_key: Option<CookiePartitionKey>,
+        }
+        impl DeleteCookiesParams {
+            pub fn new(name: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    url: None,
+                    domain: None,
+                    path: None,
+                    partition_key: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for DeleteCookiesParams {
+            fn from(url: T) -> Self {
+                DeleteCookiesParams::new(url)
+            }
+        }
+        impl DeleteCookiesParams {
+            pub fn builder() -> DeleteCookiesParamsBuilder {
+                DeleteCookiesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeleteCookiesParamsBuilder {
+            name: Option<String>,
+            url: Option<String>,
+            domain: Option<String>,
+            path: Option<String>,
+            partition_key: Option<CookiePartitionKey>,
+        }
+        impl DeleteCookiesParamsBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn domain(mut self, domain: impl Into<String>) -> Self {
+                self.domain = Some(domain.into());
+                self
+            }
+            pub fn path(mut self, path: impl Into<String>) -> Self {
+                self.path = Some(path.into());
+                self
+            }
+            pub fn partition_key(mut self, partition_key: impl Into<CookiePartitionKey>) -> Self {
+                self.partition_key = Some(partition_key.into());
+                self
+            }
+            pub fn build(self) -> Result<DeleteCookiesParams, String> {
+                Ok(DeleteCookiesParams {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    url: self.url,
+                    domain: self.domain,
+                    path: self.path,
+                    partition_key: self.partition_key,
+                })
+            }
+        }
+        impl DeleteCookiesParams {
+            pub const IDENTIFIER: &'static str = "Network.deleteCookies";
+        }
+        impl chromiumoxide_types::Method for DeleteCookiesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DeleteCookiesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Deletes browser cookies with matching name and url or domain/path/partitionKey pair.\n[deleteCookies](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-deleteCookies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DeleteCookiesReturns {}
+        impl chromiumoxide_types::Command for DeleteCookiesParams {
+            type Response = DeleteCookiesReturns;
+        }
+        #[doc = "Disables network tracking, prevents network events from being sent to the client.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Network.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables network tracking, prevents network events from being sent to the client.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[deprecated]
+        #[doc = "Activates emulation of network conditions. This command is deprecated in favor of the emulateNetworkConditionsByRule\nand overrideNetworkState commands, which can be used together to the same effect.\n[emulateNetworkConditions](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-emulateNetworkConditions)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EmulateNetworkConditionsParams {
+            #[doc = "True to emulate internet disconnection."]
+            #[serde(rename = "offline")]
+            pub offline: bool,
+            #[doc = "Minimum latency from request sent to response headers received (ms)."]
+            #[serde(rename = "latency")]
+            pub latency: f64,
+            #[doc = "Maximal aggregated download throughput (bytes/sec). -1 disables download throttling."]
+            #[serde(rename = "downloadThroughput")]
+            pub download_throughput: f64,
+            #[doc = "Maximal aggregated upload throughput (bytes/sec).  -1 disables upload throttling."]
+            #[serde(rename = "uploadThroughput")]
+            pub upload_throughput: f64,
+            #[doc = "Connection type if known."]
+            #[serde(rename = "connectionType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub connection_type: Option<ConnectionType>,
+            #[doc = "WebRTC packet loss (percent, 0-100). 0 disables packet loss emulation, 100 drops all the packets."]
+            #[serde(rename = "packetLoss")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub packet_loss: Option<f64>,
+            #[doc = "WebRTC packet queue length (packet). 0 removes any queue length limitations."]
+            #[serde(rename = "packetQueueLength")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub packet_queue_length: Option<i64>,
+            #[doc = "WebRTC packetReordering feature."]
+            #[serde(rename = "packetReordering")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub packet_reordering: Option<bool>,
+        }
+        impl EmulateNetworkConditionsParams {
+            pub fn new(
+                offline: impl Into<bool>,
+                latency: impl Into<f64>,
+                download_throughput: impl Into<f64>,
+                upload_throughput: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    offline: offline.into(),
+                    latency: latency.into(),
+                    download_throughput: download_throughput.into(),
+                    upload_throughput: upload_throughput.into(),
+                    connection_type: None,
+                    packet_loss: None,
+                    packet_queue_length: None,
+                    packet_reordering: None,
+                }
+            }
+        }
+        impl EmulateNetworkConditionsParams {
+            pub fn builder() -> EmulateNetworkConditionsParamsBuilder {
+                EmulateNetworkConditionsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EmulateNetworkConditionsParamsBuilder {
+            offline: Option<bool>,
+            latency: Option<f64>,
+            download_throughput: Option<f64>,
+            upload_throughput: Option<f64>,
+            connection_type: Option<ConnectionType>,
+            packet_loss: Option<f64>,
+            packet_queue_length: Option<i64>,
+            packet_reordering: Option<bool>,
+        }
+        impl EmulateNetworkConditionsParamsBuilder {
+            pub fn offline(mut self, offline: impl Into<bool>) -> Self {
+                self.offline = Some(offline.into());
+                self
+            }
+            pub fn latency(mut self, latency: impl Into<f64>) -> Self {
+                self.latency = Some(latency.into());
+                self
+            }
+            pub fn download_throughput(mut self, download_throughput: impl Into<f64>) -> Self {
+                self.download_throughput = Some(download_throughput.into());
+                self
+            }
+            pub fn upload_throughput(mut self, upload_throughput: impl Into<f64>) -> Self {
+                self.upload_throughput = Some(upload_throughput.into());
+                self
+            }
+            pub fn connection_type(mut self, connection_type: impl Into<ConnectionType>) -> Self {
+                self.connection_type = Some(connection_type.into());
+                self
+            }
+            pub fn packet_loss(mut self, packet_loss: impl Into<f64>) -> Self {
+                self.packet_loss = Some(packet_loss.into());
+                self
+            }
+            pub fn packet_queue_length(mut self, packet_queue_length: impl Into<i64>) -> Self {
+                self.packet_queue_length = Some(packet_queue_length.into());
+                self
+            }
+            pub fn packet_reordering(mut self, packet_reordering: impl Into<bool>) -> Self {
+                self.packet_reordering = Some(packet_reordering.into());
+                self
+            }
+            pub fn build(self) -> Result<EmulateNetworkConditionsParams, String> {
+                Ok(EmulateNetworkConditionsParams {
+                    offline: self.offline.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(offline))
+                    })?,
+                    latency: self.latency.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(latency))
+                    })?,
+                    download_throughput: self.download_throughput.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(download_throughput)
+                        )
+                    })?,
+                    upload_throughput: self.upload_throughput.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(upload_throughput)
+                        )
+                    })?,
+                    connection_type: self.connection_type,
+                    packet_loss: self.packet_loss,
+                    packet_queue_length: self.packet_queue_length,
+                    packet_reordering: self.packet_reordering,
+                })
+            }
+        }
+        impl EmulateNetworkConditionsParams {
+            pub const IDENTIFIER: &'static str = "Network.emulateNetworkConditions";
+        }
+        impl chromiumoxide_types::Method for EmulateNetworkConditionsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EmulateNetworkConditionsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Activates emulation of network conditions. This command is deprecated in favor of the emulateNetworkConditionsByRule\nand overrideNetworkState commands, which can be used together to the same effect.\n[emulateNetworkConditions](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-emulateNetworkConditions)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EmulateNetworkConditionsReturns {}
+        impl chromiumoxide_types::Command for EmulateNetworkConditionsParams {
+            type Response = EmulateNetworkConditionsReturns;
+        }
+        #[doc = "Activates emulation of network conditions for individual requests using URL match patterns. Unlike the deprecated\nNetwork.emulateNetworkConditions this method does not affect `navigator` state. Use Network.overrideNetworkState to\nexplicitly modify `navigator` behavior.\n[emulateNetworkConditionsByRule](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-emulateNetworkConditionsByRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EmulateNetworkConditionsByRuleParams {
+            #[doc = "True to emulate internet disconnection."]
+            #[serde(rename = "offline")]
+            pub offline: bool,
+            #[doc = "Configure conditions for matching requests. If multiple entries match a request, the first entry wins.  Global\nconditions can be configured by leaving the urlPattern for the conditions empty. These global conditions are\nalso applied for throttling of p2p connections."]
+            #[serde(rename = "matchedNetworkConditions")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub matched_network_conditions: Vec<NetworkConditions>,
+        }
+        impl EmulateNetworkConditionsByRuleParams {
+            pub fn new(
+                offline: impl Into<bool>,
+                matched_network_conditions: Vec<NetworkConditions>,
+            ) -> Self {
+                Self {
+                    offline: offline.into(),
+                    matched_network_conditions,
+                }
+            }
+        }
+        impl EmulateNetworkConditionsByRuleParams {
+            pub fn builder() -> EmulateNetworkConditionsByRuleParamsBuilder {
+                EmulateNetworkConditionsByRuleParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EmulateNetworkConditionsByRuleParamsBuilder {
+            offline: Option<bool>,
+            matched_network_conditions: Option<Vec<NetworkConditions>>,
+        }
+        impl EmulateNetworkConditionsByRuleParamsBuilder {
+            pub fn offline(mut self, offline: impl Into<bool>) -> Self {
+                self.offline = Some(offline.into());
+                self
+            }
+            pub fn matched_network_condition(
+                mut self,
+                matched_network_condition: impl Into<NetworkConditions>,
+            ) -> Self {
+                let v = self.matched_network_conditions.get_or_insert(Vec::new());
+                v.push(matched_network_condition.into());
+                self
+            }
+            pub fn matched_network_conditions<I, S>(mut self, matched_network_conditions: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NetworkConditions>,
+            {
+                let v = self.matched_network_conditions.get_or_insert(Vec::new());
+                for val in matched_network_conditions {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<EmulateNetworkConditionsByRuleParams, String> {
+                Ok(EmulateNetworkConditionsByRuleParams {
+                    offline: self.offline.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(offline))
+                    })?,
+                    matched_network_conditions: self.matched_network_conditions.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(matched_network_conditions)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl EmulateNetworkConditionsByRuleParams {
+            pub const IDENTIFIER: &'static str = "Network.emulateNetworkConditionsByRule";
+        }
+        impl chromiumoxide_types::Method for EmulateNetworkConditionsByRuleParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EmulateNetworkConditionsByRuleParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Activates emulation of network conditions for individual requests using URL match patterns. Unlike the deprecated\nNetwork.emulateNetworkConditions this method does not affect `navigator` state. Use Network.overrideNetworkState to\nexplicitly modify `navigator` behavior.\n[emulateNetworkConditionsByRule](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-emulateNetworkConditionsByRule)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EmulateNetworkConditionsByRuleReturns {
+            #[doc = "An id for each entry in matchedNetworkConditions. The id will be included in the requestWillBeSentExtraInfo for\nrequests affected by a rule."]
+            #[serde(rename = "ruleIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub rule_ids: Vec<String>,
+        }
+        impl EmulateNetworkConditionsByRuleReturns {
+            pub fn new(rule_ids: Vec<String>) -> Self {
+                Self { rule_ids }
+            }
+        }
+        impl EmulateNetworkConditionsByRuleReturns {
+            pub fn builder() -> EmulateNetworkConditionsByRuleReturnsBuilder {
+                EmulateNetworkConditionsByRuleReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EmulateNetworkConditionsByRuleReturnsBuilder {
+            rule_ids: Option<Vec<String>>,
+        }
+        impl EmulateNetworkConditionsByRuleReturnsBuilder {
+            pub fn rule_id(mut self, rule_id: impl Into<String>) -> Self {
+                let v = self.rule_ids.get_or_insert(Vec::new());
+                v.push(rule_id.into());
+                self
+            }
+            pub fn rule_ids<I, S>(mut self, rule_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.rule_ids.get_or_insert(Vec::new());
+                for val in rule_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<EmulateNetworkConditionsByRuleReturns, String> {
+                Ok(EmulateNetworkConditionsByRuleReturns {
+                    rule_ids: self.rule_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rule_ids))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for EmulateNetworkConditionsByRuleParams {
+            type Response = EmulateNetworkConditionsByRuleReturns;
+        }
+        #[doc = "Override the state of navigator.onLine and navigator.connection.\n[overrideNetworkState](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-overrideNetworkState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct OverrideNetworkStateParams {
+            #[doc = "True to emulate internet disconnection."]
+            #[serde(rename = "offline")]
+            pub offline: bool,
+            #[doc = "Minimum latency from request sent to response headers received (ms)."]
+            #[serde(rename = "latency")]
+            pub latency: f64,
+            #[doc = "Maximal aggregated download throughput (bytes/sec). -1 disables download throttling."]
+            #[serde(rename = "downloadThroughput")]
+            pub download_throughput: f64,
+            #[doc = "Maximal aggregated upload throughput (bytes/sec).  -1 disables upload throttling."]
+            #[serde(rename = "uploadThroughput")]
+            pub upload_throughput: f64,
+            #[doc = "Connection type if known."]
+            #[serde(rename = "connectionType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub connection_type: Option<ConnectionType>,
+        }
+        impl OverrideNetworkStateParams {
+            pub fn new(
+                offline: impl Into<bool>,
+                latency: impl Into<f64>,
+                download_throughput: impl Into<f64>,
+                upload_throughput: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    offline: offline.into(),
+                    latency: latency.into(),
+                    download_throughput: download_throughput.into(),
+                    upload_throughput: upload_throughput.into(),
+                    connection_type: None,
+                }
+            }
+        }
+        impl OverrideNetworkStateParams {
+            pub fn builder() -> OverrideNetworkStateParamsBuilder {
+                OverrideNetworkStateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct OverrideNetworkStateParamsBuilder {
+            offline: Option<bool>,
+            latency: Option<f64>,
+            download_throughput: Option<f64>,
+            upload_throughput: Option<f64>,
+            connection_type: Option<ConnectionType>,
+        }
+        impl OverrideNetworkStateParamsBuilder {
+            pub fn offline(mut self, offline: impl Into<bool>) -> Self {
+                self.offline = Some(offline.into());
+                self
+            }
+            pub fn latency(mut self, latency: impl Into<f64>) -> Self {
+                self.latency = Some(latency.into());
+                self
+            }
+            pub fn download_throughput(mut self, download_throughput: impl Into<f64>) -> Self {
+                self.download_throughput = Some(download_throughput.into());
+                self
+            }
+            pub fn upload_throughput(mut self, upload_throughput: impl Into<f64>) -> Self {
+                self.upload_throughput = Some(upload_throughput.into());
+                self
+            }
+            pub fn connection_type(mut self, connection_type: impl Into<ConnectionType>) -> Self {
+                self.connection_type = Some(connection_type.into());
+                self
+            }
+            pub fn build(self) -> Result<OverrideNetworkStateParams, String> {
+                Ok(OverrideNetworkStateParams {
+                    offline: self.offline.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(offline))
+                    })?,
+                    latency: self.latency.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(latency))
+                    })?,
+                    download_throughput: self.download_throughput.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(download_throughput)
+                        )
+                    })?,
+                    upload_throughput: self.upload_throughput.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(upload_throughput)
+                        )
+                    })?,
+                    connection_type: self.connection_type,
+                })
+            }
+        }
+        impl OverrideNetworkStateParams {
+            pub const IDENTIFIER: &'static str = "Network.overrideNetworkState";
+        }
+        impl chromiumoxide_types::Method for OverrideNetworkStateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for OverrideNetworkStateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Override the state of navigator.onLine and navigator.connection.\n[overrideNetworkState](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-overrideNetworkState)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct OverrideNetworkStateReturns {}
+        impl chromiumoxide_types::Command for OverrideNetworkStateParams {
+            type Response = OverrideNetworkStateReturns;
+        }
+        #[doc = "Enables network tracking, network events will now be delivered to the client.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[doc = "Buffer size in bytes to use when preserving network payloads (XHRs, etc)."]
+            #[serde(rename = "maxTotalBufferSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_total_buffer_size: Option<i64>,
+            #[doc = "Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc)."]
+            #[serde(rename = "maxResourceBufferSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_resource_buffer_size: Option<i64>,
+            #[doc = "Longest post body size (in bytes) that would be included in requestWillBeSent notification"]
+            #[serde(rename = "maxPostDataSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_post_data_size: Option<i64>,
+            #[doc = "Whether DirectSocket chunk send/receive events should be reported."]
+            #[serde(rename = "reportDirectSocketTraffic")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub report_direct_socket_traffic: Option<bool>,
+            #[doc = "Enable storing response bodies outside of renderer, so that these survive\na cross-process navigation. Requires maxTotalBufferSize to be set.\nCurrently defaults to false. This field is being deprecated in favor of the dedicated\nconfigureDurableMessages command, due to the possibility of deadlocks when awaiting\nNetwork.enable before issuing Runtime.runIfWaitingForDebugger."]
+            #[serde(rename = "enableDurableMessages")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub enable_durable_messages: Option<bool>,
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            max_total_buffer_size: Option<i64>,
+            max_resource_buffer_size: Option<i64>,
+            max_post_data_size: Option<i64>,
+            report_direct_socket_traffic: Option<bool>,
+            enable_durable_messages: Option<bool>,
+        }
+        impl EnableParamsBuilder {
+            pub fn max_total_buffer_size(mut self, max_total_buffer_size: impl Into<i64>) -> Self {
+                self.max_total_buffer_size = Some(max_total_buffer_size.into());
+                self
+            }
+            pub fn max_resource_buffer_size(
+                mut self,
+                max_resource_buffer_size: impl Into<i64>,
+            ) -> Self {
+                self.max_resource_buffer_size = Some(max_resource_buffer_size.into());
+                self
+            }
+            pub fn max_post_data_size(mut self, max_post_data_size: impl Into<i64>) -> Self {
+                self.max_post_data_size = Some(max_post_data_size.into());
+                self
+            }
+            pub fn report_direct_socket_traffic(
+                mut self,
+                report_direct_socket_traffic: impl Into<bool>,
+            ) -> Self {
+                self.report_direct_socket_traffic = Some(report_direct_socket_traffic.into());
+                self
+            }
+            pub fn enable_durable_messages(
+                mut self,
+                enable_durable_messages: impl Into<bool>,
+            ) -> Self {
+                self.enable_durable_messages = Some(enable_durable_messages.into());
+                self
+            }
+            pub fn build(self) -> EnableParams {
+                EnableParams {
+                    max_total_buffer_size: self.max_total_buffer_size,
+                    max_resource_buffer_size: self.max_resource_buffer_size,
+                    max_post_data_size: self.max_post_data_size,
+                    report_direct_socket_traffic: self.report_direct_socket_traffic,
+                    enable_durable_messages: self.enable_durable_messages,
+                }
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Network.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables network tracking, network events will now be delivered to the client.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Configures storing response bodies outside of renderer, so that these survive\na cross-process navigation.\nIf maxTotalBufferSize is not set, durable messages are disabled.\n[configureDurableMessages](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-configureDurableMessages)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ConfigureDurableMessagesParams {
+            #[doc = "Buffer size in bytes to use when preserving network payloads (XHRs, etc)."]
+            #[serde(rename = "maxTotalBufferSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_total_buffer_size: Option<i64>,
+            #[doc = "Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc)."]
+            #[serde(rename = "maxResourceBufferSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_resource_buffer_size: Option<i64>,
+        }
+        impl ConfigureDurableMessagesParams {
+            pub fn builder() -> ConfigureDurableMessagesParamsBuilder {
+                ConfigureDurableMessagesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ConfigureDurableMessagesParamsBuilder {
+            max_total_buffer_size: Option<i64>,
+            max_resource_buffer_size: Option<i64>,
+        }
+        impl ConfigureDurableMessagesParamsBuilder {
+            pub fn max_total_buffer_size(mut self, max_total_buffer_size: impl Into<i64>) -> Self {
+                self.max_total_buffer_size = Some(max_total_buffer_size.into());
+                self
+            }
+            pub fn max_resource_buffer_size(
+                mut self,
+                max_resource_buffer_size: impl Into<i64>,
+            ) -> Self {
+                self.max_resource_buffer_size = Some(max_resource_buffer_size.into());
+                self
+            }
+            pub fn build(self) -> ConfigureDurableMessagesParams {
+                ConfigureDurableMessagesParams {
+                    max_total_buffer_size: self.max_total_buffer_size,
+                    max_resource_buffer_size: self.max_resource_buffer_size,
+                }
+            }
+        }
+        impl ConfigureDurableMessagesParams {
+            pub const IDENTIFIER: &'static str = "Network.configureDurableMessages";
+        }
+        impl chromiumoxide_types::Method for ConfigureDurableMessagesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ConfigureDurableMessagesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Configures storing response bodies outside of renderer, so that these survive\na cross-process navigation.\nIf maxTotalBufferSize is not set, durable messages are disabled.\n[configureDurableMessages](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-configureDurableMessages)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ConfigureDurableMessagesReturns {}
+        impl chromiumoxide_types::Command for ConfigureDurableMessagesParams {
+            type Response = ConfigureDurableMessagesReturns;
+        }
+        #[doc = "Returns the DER-encoded certificate.\n[getCertificate](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getCertificate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCertificateParams {
+            #[doc = "Origin to get certificate for."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+        }
+        impl GetCertificateParams {
+            pub fn new(origin: impl Into<String>) -> Self {
+                Self {
+                    origin: origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetCertificateParams {
+            fn from(url: T) -> Self {
+                GetCertificateParams::new(url)
+            }
+        }
+        impl GetCertificateParams {
+            pub fn builder() -> GetCertificateParamsBuilder {
+                GetCertificateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCertificateParamsBuilder {
+            origin: Option<String>,
+        }
+        impl GetCertificateParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn build(self) -> Result<GetCertificateParams, String> {
+                Ok(GetCertificateParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                })
+            }
+        }
+        impl GetCertificateParams {
+            pub const IDENTIFIER: &'static str = "Network.getCertificate";
+        }
+        impl chromiumoxide_types::Method for GetCertificateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetCertificateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the DER-encoded certificate.\n[getCertificate](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getCertificate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCertificateReturns {
+            #[serde(rename = "tableNames")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub table_names: Vec<String>,
+        }
+        impl GetCertificateReturns {
+            pub fn new(table_names: Vec<String>) -> Self {
+                Self { table_names }
+            }
+        }
+        impl GetCertificateReturns {
+            pub fn builder() -> GetCertificateReturnsBuilder {
+                GetCertificateReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCertificateReturnsBuilder {
+            table_names: Option<Vec<String>>,
+        }
+        impl GetCertificateReturnsBuilder {
+            pub fn table_name(mut self, table_name: impl Into<String>) -> Self {
+                let v = self.table_names.get_or_insert(Vec::new());
+                v.push(table_name.into());
+                self
+            }
+            pub fn table_names<I, S>(mut self, table_names: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.table_names.get_or_insert(Vec::new());
+                for val in table_names {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetCertificateReturns, String> {
+                Ok(GetCertificateReturns {
+                    table_names: self.table_names.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(table_names))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetCertificateParams {
+            type Response = GetCertificateReturns;
+        }
+        #[doc = "Returns all browser cookies for the current URL. Depending on the backend support, will return\ndetailed cookie information in the `cookies` field.\n[getCookies](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getCookies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetCookiesParams {
+            #[doc = "The list of URLs for which applicable cookies will be fetched.\nIf not specified, it's assumed to be set to the list containing\nthe URLs of the page and all of its subframes."]
+            #[serde(rename = "urls")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub urls: Option<Vec<String>>,
+        }
+        impl GetCookiesParams {
+            pub fn builder() -> GetCookiesParamsBuilder {
+                GetCookiesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCookiesParamsBuilder {
+            urls: Option<Vec<String>>,
+        }
+        impl GetCookiesParamsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                let v = self.urls.get_or_insert(Vec::new());
+                v.push(url.into());
+                self
+            }
+            pub fn urls<I, S>(mut self, urls: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.urls.get_or_insert(Vec::new());
+                for val in urls {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> GetCookiesParams {
+                GetCookiesParams { urls: self.urls }
+            }
+        }
+        impl GetCookiesParams {
+            pub const IDENTIFIER: &'static str = "Network.getCookies";
+        }
+        impl chromiumoxide_types::Method for GetCookiesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetCookiesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns all browser cookies for the current URL. Depending on the backend support, will return\ndetailed cookie information in the `cookies` field.\n[getCookies](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getCookies)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCookiesReturns {
+            #[doc = "Array of cookie objects."]
+            #[serde(rename = "cookies")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub cookies: Vec<Cookie>,
+        }
+        impl GetCookiesReturns {
+            pub fn new(cookies: Vec<Cookie>) -> Self {
+                Self { cookies }
+            }
+        }
+        impl GetCookiesReturns {
+            pub fn builder() -> GetCookiesReturnsBuilder {
+                GetCookiesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCookiesReturnsBuilder {
+            cookies: Option<Vec<Cookie>>,
+        }
+        impl GetCookiesReturnsBuilder {
+            pub fn cookie(mut self, cookie: impl Into<Cookie>) -> Self {
+                let v = self.cookies.get_or_insert(Vec::new());
+                v.push(cookie.into());
+                self
+            }
+            pub fn cookies<I, S>(mut self, cookies: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Cookie>,
+            {
+                let v = self.cookies.get_or_insert(Vec::new());
+                for val in cookies {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetCookiesReturns, String> {
+                Ok(GetCookiesReturns {
+                    cookies: self.cookies.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cookies))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetCookiesParams {
+            type Response = GetCookiesReturns;
+        }
+        #[doc = "Returns content served for the given request.\n[getResponseBody](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getResponseBody)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetResponseBodyParams {
+            #[doc = "Identifier of the network request to get content for."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+        }
+        impl GetResponseBodyParams {
+            pub fn new(request_id: impl Into<RequestId>) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                }
+            }
+        }
+        impl GetResponseBodyParams {
+            pub fn builder() -> GetResponseBodyParamsBuilder {
+                GetResponseBodyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetResponseBodyParamsBuilder {
+            request_id: Option<RequestId>,
+        }
+        impl GetResponseBodyParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetResponseBodyParams, String> {
+                Ok(GetResponseBodyParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                })
+            }
+        }
+        impl GetResponseBodyParams {
+            pub const IDENTIFIER: &'static str = "Network.getResponseBody";
+        }
+        impl chromiumoxide_types::Method for GetResponseBodyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetResponseBodyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns content served for the given request.\n[getResponseBody](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getResponseBody)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetResponseBodyReturns {
+            #[doc = "Response body."]
+            #[serde(rename = "body")]
+            pub body: String,
+            #[doc = "True, if content was sent as base64."]
+            #[serde(rename = "base64Encoded")]
+            pub base64_encoded: bool,
+        }
+        impl GetResponseBodyReturns {
+            pub fn new(body: impl Into<String>, base64_encoded: impl Into<bool>) -> Self {
+                Self {
+                    body: body.into(),
+                    base64_encoded: base64_encoded.into(),
+                }
+            }
+        }
+        impl GetResponseBodyReturns {
+            pub fn builder() -> GetResponseBodyReturnsBuilder {
+                GetResponseBodyReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetResponseBodyReturnsBuilder {
+            body: Option<String>,
+            base64_encoded: Option<bool>,
+        }
+        impl GetResponseBodyReturnsBuilder {
+            pub fn body(mut self, body: impl Into<String>) -> Self {
+                self.body = Some(body.into());
+                self
+            }
+            pub fn base64_encoded(mut self, base64_encoded: impl Into<bool>) -> Self {
+                self.base64_encoded = Some(base64_encoded.into());
+                self
+            }
+            pub fn build(self) -> Result<GetResponseBodyReturns, String> {
+                Ok(GetResponseBodyReturns {
+                    body: self.body.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(body))
+                    })?,
+                    base64_encoded: self.base64_encoded.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(base64_encoded))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetResponseBodyParams {
+            type Response = GetResponseBodyReturns;
+        }
+        #[doc = "Returns post data sent with the request. Returns an error when no data was sent with the request.\n[getRequestPostData](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getRequestPostData)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetRequestPostDataParams {
+            #[doc = "Identifier of the network request to get content for."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+        }
+        impl GetRequestPostDataParams {
+            pub fn new(request_id: impl Into<RequestId>) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                }
+            }
+        }
+        impl GetRequestPostDataParams {
+            pub fn builder() -> GetRequestPostDataParamsBuilder {
+                GetRequestPostDataParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetRequestPostDataParamsBuilder {
+            request_id: Option<RequestId>,
+        }
+        impl GetRequestPostDataParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetRequestPostDataParams, String> {
+                Ok(GetRequestPostDataParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                })
+            }
+        }
+        impl GetRequestPostDataParams {
+            pub const IDENTIFIER: &'static str = "Network.getRequestPostData";
+        }
+        impl chromiumoxide_types::Method for GetRequestPostDataParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetRequestPostDataParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns post data sent with the request. Returns an error when no data was sent with the request.\n[getRequestPostData](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getRequestPostData)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetRequestPostDataReturns {
+            #[doc = "Request body string, omitting files from multipart requests"]
+            #[serde(rename = "postData")]
+            pub post_data: String,
+        }
+        impl GetRequestPostDataReturns {
+            pub fn new(post_data: impl Into<String>) -> Self {
+                Self {
+                    post_data: post_data.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetRequestPostDataReturns {
+            fn from(url: T) -> Self {
+                GetRequestPostDataReturns::new(url)
+            }
+        }
+        impl GetRequestPostDataReturns {
+            pub fn builder() -> GetRequestPostDataReturnsBuilder {
+                GetRequestPostDataReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetRequestPostDataReturnsBuilder {
+            post_data: Option<String>,
+        }
+        impl GetRequestPostDataReturnsBuilder {
+            pub fn post_data(mut self, post_data: impl Into<String>) -> Self {
+                self.post_data = Some(post_data.into());
+                self
+            }
+            pub fn build(self) -> Result<GetRequestPostDataReturns, String> {
+                Ok(GetRequestPostDataReturns {
+                    post_data: self.post_data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(post_data))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetRequestPostDataParams {
+            type Response = GetRequestPostDataReturns;
+        }
+        #[doc = "Returns content served for the given currently intercepted request.\n[getResponseBodyForInterception](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getResponseBodyForInterception)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetResponseBodyForInterceptionParams {
+            #[doc = "Identifier for the intercepted request to get body for."]
+            #[serde(rename = "interceptionId")]
+            pub interception_id: InterceptionId,
+        }
+        impl GetResponseBodyForInterceptionParams {
+            pub fn new(interception_id: impl Into<InterceptionId>) -> Self {
+                Self {
+                    interception_id: interception_id.into(),
+                }
+            }
+        }
+        impl GetResponseBodyForInterceptionParams {
+            pub fn builder() -> GetResponseBodyForInterceptionParamsBuilder {
+                GetResponseBodyForInterceptionParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetResponseBodyForInterceptionParamsBuilder {
+            interception_id: Option<InterceptionId>,
+        }
+        impl GetResponseBodyForInterceptionParamsBuilder {
+            pub fn interception_id(mut self, interception_id: impl Into<InterceptionId>) -> Self {
+                self.interception_id = Some(interception_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetResponseBodyForInterceptionParams, String> {
+                Ok(GetResponseBodyForInterceptionParams {
+                    interception_id: self.interception_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(interception_id))
+                    })?,
+                })
+            }
+        }
+        impl GetResponseBodyForInterceptionParams {
+            pub const IDENTIFIER: &'static str = "Network.getResponseBodyForInterception";
+        }
+        impl chromiumoxide_types::Method for GetResponseBodyForInterceptionParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetResponseBodyForInterceptionParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns content served for the given currently intercepted request.\n[getResponseBodyForInterception](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getResponseBodyForInterception)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetResponseBodyForInterceptionReturns {
+            #[doc = "Response body."]
+            #[serde(rename = "body")]
+            pub body: String,
+            #[doc = "True, if content was sent as base64."]
+            #[serde(rename = "base64Encoded")]
+            pub base64_encoded: bool,
+        }
+        impl GetResponseBodyForInterceptionReturns {
+            pub fn new(body: impl Into<String>, base64_encoded: impl Into<bool>) -> Self {
+                Self {
+                    body: body.into(),
+                    base64_encoded: base64_encoded.into(),
+                }
+            }
+        }
+        impl GetResponseBodyForInterceptionReturns {
+            pub fn builder() -> GetResponseBodyForInterceptionReturnsBuilder {
+                GetResponseBodyForInterceptionReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetResponseBodyForInterceptionReturnsBuilder {
+            body: Option<String>,
+            base64_encoded: Option<bool>,
+        }
+        impl GetResponseBodyForInterceptionReturnsBuilder {
+            pub fn body(mut self, body: impl Into<String>) -> Self {
+                self.body = Some(body.into());
+                self
+            }
+            pub fn base64_encoded(mut self, base64_encoded: impl Into<bool>) -> Self {
+                self.base64_encoded = Some(base64_encoded.into());
+                self
+            }
+            pub fn build(self) -> Result<GetResponseBodyForInterceptionReturns, String> {
+                Ok(GetResponseBodyForInterceptionReturns {
+                    body: self.body.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(body))
+                    })?,
+                    base64_encoded: self.base64_encoded.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(base64_encoded))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetResponseBodyForInterceptionParams {
+            type Response = GetResponseBodyForInterceptionReturns;
+        }
+        #[doc = "Returns a handle to the stream representing the response body. Note that after this command,\nthe intercepted request can't be continued as is -- you either need to cancel it or to provide\nthe response body. The stream only supports sequential read, IO.read will fail if the position\nis specified.\n[takeResponseBodyForInterceptionAsStream](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-takeResponseBodyForInterceptionAsStream)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TakeResponseBodyForInterceptionAsStreamParams {
+            #[serde(rename = "interceptionId")]
+            pub interception_id: InterceptionId,
+        }
+        impl TakeResponseBodyForInterceptionAsStreamParams {
+            pub fn new(interception_id: impl Into<InterceptionId>) -> Self {
+                Self {
+                    interception_id: interception_id.into(),
+                }
+            }
+        }
+        impl TakeResponseBodyForInterceptionAsStreamParams {
+            pub fn builder() -> TakeResponseBodyForInterceptionAsStreamParamsBuilder {
+                TakeResponseBodyForInterceptionAsStreamParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TakeResponseBodyForInterceptionAsStreamParamsBuilder {
+            interception_id: Option<InterceptionId>,
+        }
+        impl TakeResponseBodyForInterceptionAsStreamParamsBuilder {
+            pub fn interception_id(mut self, interception_id: impl Into<InterceptionId>) -> Self {
+                self.interception_id = Some(interception_id.into());
+                self
+            }
+            pub fn build(self) -> Result<TakeResponseBodyForInterceptionAsStreamParams, String> {
+                Ok(TakeResponseBodyForInterceptionAsStreamParams {
+                    interception_id: self.interception_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(interception_id))
+                    })?,
+                })
+            }
+        }
+        impl TakeResponseBodyForInterceptionAsStreamParams {
+            pub const IDENTIFIER: &'static str = "Network.takeResponseBodyForInterceptionAsStream";
+        }
+        impl chromiumoxide_types::Method for TakeResponseBodyForInterceptionAsStreamParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TakeResponseBodyForInterceptionAsStreamParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns a handle to the stream representing the response body. Note that after this command,\nthe intercepted request can't be continued as is -- you either need to cancel it or to provide\nthe response body. The stream only supports sequential read, IO.read will fail if the position\nis specified.\n[takeResponseBodyForInterceptionAsStream](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-takeResponseBodyForInterceptionAsStream)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TakeResponseBodyForInterceptionAsStreamReturns {
+            #[serde(rename = "stream")]
+            pub stream: super::io::StreamHandle,
+        }
+        impl TakeResponseBodyForInterceptionAsStreamReturns {
+            pub fn new(stream: impl Into<super::io::StreamHandle>) -> Self {
+                Self {
+                    stream: stream.into(),
+                }
+            }
+        }
+        impl TakeResponseBodyForInterceptionAsStreamReturns {
+            pub fn builder() -> TakeResponseBodyForInterceptionAsStreamReturnsBuilder {
+                TakeResponseBodyForInterceptionAsStreamReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TakeResponseBodyForInterceptionAsStreamReturnsBuilder {
+            stream: Option<super::io::StreamHandle>,
+        }
+        impl TakeResponseBodyForInterceptionAsStreamReturnsBuilder {
+            pub fn stream(mut self, stream: impl Into<super::io::StreamHandle>) -> Self {
+                self.stream = Some(stream.into());
+                self
+            }
+            pub fn build(self) -> Result<TakeResponseBodyForInterceptionAsStreamReturns, String> {
+                Ok(TakeResponseBodyForInterceptionAsStreamReturns {
+                    stream: self.stream.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(stream))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for TakeResponseBodyForInterceptionAsStreamParams {
+            type Response = TakeResponseBodyForInterceptionAsStreamReturns;
+        }
+        #[doc = "This method sends a new XMLHttpRequest which is identical to the original one. The following\nparameters should be identical: method, url, async, request body, extra headers, withCredentials\nattribute, user, password.\n[replayXHR](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-replayXHR)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ReplayXhrParams {
+            #[doc = "Identifier of XHR to replay."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+        }
+        impl ReplayXhrParams {
+            pub fn new(request_id: impl Into<RequestId>) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                }
+            }
+        }
+        impl ReplayXhrParams {
+            pub fn builder() -> ReplayXhrParamsBuilder {
+                ReplayXhrParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReplayXhrParamsBuilder {
+            request_id: Option<RequestId>,
+        }
+        impl ReplayXhrParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ReplayXhrParams, String> {
+                Ok(ReplayXhrParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                })
+            }
+        }
+        impl ReplayXhrParams {
+            pub const IDENTIFIER: &'static str = "Network.replayXHR";
+        }
+        impl chromiumoxide_types::Method for ReplayXhrParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ReplayXhrParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "This method sends a new XMLHttpRequest which is identical to the original one. The following\nparameters should be identical: method, url, async, request body, extra headers, withCredentials\nattribute, user, password.\n[replayXHR](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-replayXHR)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ReplayXhrReturns {}
+        impl chromiumoxide_types::Command for ReplayXhrParams {
+            type Response = ReplayXhrReturns;
+        }
+        #[doc = "Searches for given string in response content.\n[searchInResponseBody](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-searchInResponseBody)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SearchInResponseBodyParams {
+            #[doc = "Identifier of the network response to search."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "String to search for."]
+            #[serde(rename = "query")]
+            pub query: String,
+            #[doc = "If true, search is case sensitive."]
+            #[serde(rename = "caseSensitive")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub case_sensitive: Option<bool>,
+            #[doc = "If true, treats string parameter as regex."]
+            #[serde(rename = "isRegex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_regex: Option<bool>,
+        }
+        impl SearchInResponseBodyParams {
+            pub fn new(request_id: impl Into<RequestId>, query: impl Into<String>) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                    query: query.into(),
+                    case_sensitive: None,
+                    is_regex: None,
+                }
+            }
+        }
+        impl SearchInResponseBodyParams {
+            pub fn builder() -> SearchInResponseBodyParamsBuilder {
+                SearchInResponseBodyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SearchInResponseBodyParamsBuilder {
+            request_id: Option<RequestId>,
+            query: Option<String>,
+            case_sensitive: Option<bool>,
+            is_regex: Option<bool>,
+        }
+        impl SearchInResponseBodyParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn query(mut self, query: impl Into<String>) -> Self {
+                self.query = Some(query.into());
+                self
+            }
+            pub fn case_sensitive(mut self, case_sensitive: impl Into<bool>) -> Self {
+                self.case_sensitive = Some(case_sensitive.into());
+                self
+            }
+            pub fn is_regex(mut self, is_regex: impl Into<bool>) -> Self {
+                self.is_regex = Some(is_regex.into());
+                self
+            }
+            pub fn build(self) -> Result<SearchInResponseBodyParams, String> {
+                Ok(SearchInResponseBodyParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                    query: self.query.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(query))
+                    })?,
+                    case_sensitive: self.case_sensitive,
+                    is_regex: self.is_regex,
+                })
+            }
+        }
+        impl SearchInResponseBodyParams {
+            pub const IDENTIFIER: &'static str = "Network.searchInResponseBody";
+        }
+        impl chromiumoxide_types::Method for SearchInResponseBodyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SearchInResponseBodyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Searches for given string in response content.\n[searchInResponseBody](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-searchInResponseBody)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SearchInResponseBodyReturns {
+            #[doc = "List of search matches."]
+            #[serde(rename = "result")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub result: Vec<super::super::js_protocol::debugger::SearchMatch>,
+        }
+        impl SearchInResponseBodyReturns {
+            pub fn new(result: Vec<super::super::js_protocol::debugger::SearchMatch>) -> Self {
+                Self { result }
+            }
+        }
+        impl SearchInResponseBodyReturns {
+            pub fn builder() -> SearchInResponseBodyReturnsBuilder {
+                SearchInResponseBodyReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SearchInResponseBodyReturnsBuilder {
+            result: Option<Vec<super::super::js_protocol::debugger::SearchMatch>>,
+        }
+        impl SearchInResponseBodyReturnsBuilder {
+            pub fn result(
+                mut self,
+                result: impl Into<super::super::js_protocol::debugger::SearchMatch>,
+            ) -> Self {
+                let v = self.result.get_or_insert(Vec::new());
+                v.push(result.into());
+                self
+            }
+            pub fn results<I, S>(mut self, results: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::super::js_protocol::debugger::SearchMatch>,
+            {
+                let v = self.result.get_or_insert(Vec::new());
+                for val in results {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SearchInResponseBodyReturns, String> {
+                Ok(SearchInResponseBodyReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SearchInResponseBodyParams {
+            type Response = SearchInResponseBodyReturns;
+        }
+        #[doc = "Blocks URLs from loading.\n[setBlockedURLs](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setBlockedURLs)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetBlockedUrLsParams {
+            #[doc = "Patterns to match in the order in which they are given. These patterns\nalso take precedence over any wildcard patterns defined in `urls`."]
+            #[serde(rename = "urlPatterns")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url_patterns: Option<Vec<BlockPattern>>,
+        }
+        impl SetBlockedUrLsParams {
+            pub fn builder() -> SetBlockedUrLsParamsBuilder {
+                SetBlockedUrLsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBlockedUrLsParamsBuilder {
+            url_patterns: Option<Vec<BlockPattern>>,
+        }
+        impl SetBlockedUrLsParamsBuilder {
+            pub fn url_pattern(mut self, url_pattern: impl Into<BlockPattern>) -> Self {
+                let v = self.url_patterns.get_or_insert(Vec::new());
+                v.push(url_pattern.into());
+                self
+            }
+            pub fn url_patterns<I, S>(mut self, url_patterns: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<BlockPattern>,
+            {
+                let v = self.url_patterns.get_or_insert(Vec::new());
+                for val in url_patterns {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> SetBlockedUrLsParams {
+                SetBlockedUrLsParams {
+                    url_patterns: self.url_patterns,
+                }
+            }
+        }
+        impl SetBlockedUrLsParams {
+            pub const IDENTIFIER: &'static str = "Network.setBlockedURLs";
+        }
+        impl chromiumoxide_types::Method for SetBlockedUrLsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBlockedUrLsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Blocks URLs from loading.\n[setBlockedURLs](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setBlockedURLs)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetBlockedUrLsReturns {}
+        impl chromiumoxide_types::Command for SetBlockedUrLsParams {
+            type Response = SetBlockedUrLsReturns;
+        }
+        #[doc = "Toggles ignoring of service worker for each request.\n[setBypassServiceWorker](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setBypassServiceWorker)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBypassServiceWorkerParams {
+            #[doc = "Bypass service worker and load from network."]
+            #[serde(rename = "bypass")]
+            pub bypass: bool,
+        }
+        impl SetBypassServiceWorkerParams {
+            pub fn new(bypass: impl Into<bool>) -> Self {
+                Self {
+                    bypass: bypass.into(),
+                }
+            }
+        }
+        impl SetBypassServiceWorkerParams {
+            pub fn builder() -> SetBypassServiceWorkerParamsBuilder {
+                SetBypassServiceWorkerParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBypassServiceWorkerParamsBuilder {
+            bypass: Option<bool>,
+        }
+        impl SetBypassServiceWorkerParamsBuilder {
+            pub fn bypass(mut self, bypass: impl Into<bool>) -> Self {
+                self.bypass = Some(bypass.into());
+                self
+            }
+            pub fn build(self) -> Result<SetBypassServiceWorkerParams, String> {
+                Ok(SetBypassServiceWorkerParams {
+                    bypass: self.bypass.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bypass))
+                    })?,
+                })
+            }
+        }
+        impl SetBypassServiceWorkerParams {
+            pub const IDENTIFIER: &'static str = "Network.setBypassServiceWorker";
+        }
+        impl chromiumoxide_types::Method for SetBypassServiceWorkerParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBypassServiceWorkerParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Toggles ignoring of service worker for each request.\n[setBypassServiceWorker](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setBypassServiceWorker)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetBypassServiceWorkerReturns {}
+        impl chromiumoxide_types::Command for SetBypassServiceWorkerParams {
+            type Response = SetBypassServiceWorkerReturns;
+        }
+        #[doc = "Toggles ignoring cache for each request. If `true`, cache will not be used.\n[setCacheDisabled](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setCacheDisabled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetCacheDisabledParams {
+            #[doc = "Cache disabled state."]
+            #[serde(rename = "cacheDisabled")]
+            pub cache_disabled: bool,
+        }
+        impl SetCacheDisabledParams {
+            pub fn new(cache_disabled: impl Into<bool>) -> Self {
+                Self {
+                    cache_disabled: cache_disabled.into(),
+                }
+            }
+        }
+        impl SetCacheDisabledParams {
+            pub fn builder() -> SetCacheDisabledParamsBuilder {
+                SetCacheDisabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetCacheDisabledParamsBuilder {
+            cache_disabled: Option<bool>,
+        }
+        impl SetCacheDisabledParamsBuilder {
+            pub fn cache_disabled(mut self, cache_disabled: impl Into<bool>) -> Self {
+                self.cache_disabled = Some(cache_disabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetCacheDisabledParams, String> {
+                Ok(SetCacheDisabledParams {
+                    cache_disabled: self.cache_disabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cache_disabled))
+                    })?,
+                })
+            }
+        }
+        impl SetCacheDisabledParams {
+            pub const IDENTIFIER: &'static str = "Network.setCacheDisabled";
+        }
+        impl chromiumoxide_types::Method for SetCacheDisabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetCacheDisabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Toggles ignoring cache for each request. If `true`, cache will not be used.\n[setCacheDisabled](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setCacheDisabled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetCacheDisabledReturns {}
+        impl chromiumoxide_types::Command for SetCacheDisabledParams {
+            type Response = SetCacheDisabledReturns;
+        }
+        #[doc = "Sets a cookie with the given cookie data; may overwrite equivalent cookies if they exist.\n[setCookie](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setCookie)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetCookieParams {
+            #[doc = "Cookie name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Cookie value."]
+            #[serde(rename = "value")]
+            pub value: String,
+            #[doc = "The request-URI to associate with the setting of the cookie. This value can affect the\ndefault domain, path, source port, and source scheme values of the created cookie."]
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[doc = "Cookie domain."]
+            #[serde(rename = "domain")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub domain: Option<String>,
+            #[doc = "Cookie path."]
+            #[serde(rename = "path")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub path: Option<String>,
+            #[doc = "True if cookie is secure."]
+            #[serde(rename = "secure")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub secure: Option<bool>,
+            #[doc = "True if cookie is http-only."]
+            #[serde(rename = "httpOnly")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub http_only: Option<bool>,
+            #[doc = "Cookie SameSite type."]
+            #[serde(rename = "sameSite")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub same_site: Option<CookieSameSite>,
+            #[doc = "Cookie expiration date, session cookie if not set"]
+            #[serde(rename = "expires")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub expires: Option<TimeSinceEpoch>,
+            #[doc = "Cookie Priority type."]
+            #[serde(rename = "priority")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub priority: Option<CookiePriority>,
+            #[doc = "True if cookie is SameParty."]
+            #[serde(rename = "sameParty")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub same_party: Option<bool>,
+            #[doc = "Cookie source scheme type."]
+            #[serde(rename = "sourceScheme")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub source_scheme: Option<CookieSourceScheme>,
+            #[doc = "Cookie source port. Valid values are {-1, [1, 65535]}, -1 indicates an unspecified port.\nAn unspecified port value allows protocol clients to emulate legacy cookie scope for the port.\nThis is a temporary ability and it will be removed in the future."]
+            #[serde(rename = "sourcePort")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_port: Option<i64>,
+            #[doc = "Cookie partition key. If not set, the cookie will be set as not partitioned."]
+            #[serde(rename = "partitionKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub partition_key: Option<CookiePartitionKey>,
+        }
+        impl SetCookieParams {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                    url: None,
+                    domain: None,
+                    path: None,
+                    secure: None,
+                    http_only: None,
+                    same_site: None,
+                    expires: None,
+                    priority: None,
+                    same_party: None,
+                    source_scheme: None,
+                    source_port: None,
+                    partition_key: None,
+                }
+            }
+        }
+        impl SetCookieParams {
+            pub fn builder() -> SetCookieParamsBuilder {
+                SetCookieParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetCookieParamsBuilder {
+            name: Option<String>,
+            value: Option<String>,
+            url: Option<String>,
+            domain: Option<String>,
+            path: Option<String>,
+            secure: Option<bool>,
+            http_only: Option<bool>,
+            same_site: Option<CookieSameSite>,
+            expires: Option<TimeSinceEpoch>,
+            priority: Option<CookiePriority>,
+            same_party: Option<bool>,
+            source_scheme: Option<CookieSourceScheme>,
+            source_port: Option<i64>,
+            partition_key: Option<CookiePartitionKey>,
+        }
+        impl SetCookieParamsBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn domain(mut self, domain: impl Into<String>) -> Self {
+                self.domain = Some(domain.into());
+                self
+            }
+            pub fn path(mut self, path: impl Into<String>) -> Self {
+                self.path = Some(path.into());
+                self
+            }
+            pub fn secure(mut self, secure: impl Into<bool>) -> Self {
+                self.secure = Some(secure.into());
+                self
+            }
+            pub fn http_only(mut self, http_only: impl Into<bool>) -> Self {
+                self.http_only = Some(http_only.into());
+                self
+            }
+            pub fn same_site(mut self, same_site: impl Into<CookieSameSite>) -> Self {
+                self.same_site = Some(same_site.into());
+                self
+            }
+            pub fn expires(mut self, expires: impl Into<TimeSinceEpoch>) -> Self {
+                self.expires = Some(expires.into());
+                self
+            }
+            pub fn priority(mut self, priority: impl Into<CookiePriority>) -> Self {
+                self.priority = Some(priority.into());
+                self
+            }
+            pub fn same_party(mut self, same_party: impl Into<bool>) -> Self {
+                self.same_party = Some(same_party.into());
+                self
+            }
+            pub fn source_scheme(mut self, source_scheme: impl Into<CookieSourceScheme>) -> Self {
+                self.source_scheme = Some(source_scheme.into());
+                self
+            }
+            pub fn source_port(mut self, source_port: impl Into<i64>) -> Self {
+                self.source_port = Some(source_port.into());
+                self
+            }
+            pub fn partition_key(mut self, partition_key: impl Into<CookiePartitionKey>) -> Self {
+                self.partition_key = Some(partition_key.into());
+                self
+            }
+            pub fn build(self) -> Result<SetCookieParams, String> {
+                Ok(SetCookieParams {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    url: self.url,
+                    domain: self.domain,
+                    path: self.path,
+                    secure: self.secure,
+                    http_only: self.http_only,
+                    same_site: self.same_site,
+                    expires: self.expires,
+                    priority: self.priority,
+                    same_party: self.same_party,
+                    source_scheme: self.source_scheme,
+                    source_port: self.source_port,
+                    partition_key: self.partition_key,
+                })
+            }
+        }
+        impl SetCookieParams {
+            pub const IDENTIFIER: &'static str = "Network.setCookie";
+        }
+        impl chromiumoxide_types::Method for SetCookieParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetCookieParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets a cookie with the given cookie data; may overwrite equivalent cookies if they exist.\n[setCookie](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setCookie)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetCookieReturns {}
+        impl chromiumoxide_types::Command for SetCookieParams {
+            type Response = SetCookieReturns;
+        }
+        #[doc = "Sets given cookies.\n[setCookies](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setCookies)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetCookiesParams {
+            #[doc = "Cookies to be set."]
+            #[serde(rename = "cookies")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub cookies: Vec<CookieParam>,
+        }
+        impl SetCookiesParams {
+            pub fn new(cookies: Vec<CookieParam>) -> Self {
+                Self { cookies }
+            }
+        }
+        impl SetCookiesParams {
+            pub fn builder() -> SetCookiesParamsBuilder {
+                SetCookiesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetCookiesParamsBuilder {
+            cookies: Option<Vec<CookieParam>>,
+        }
+        impl SetCookiesParamsBuilder {
+            pub fn cookie(mut self, cookie: impl Into<CookieParam>) -> Self {
+                let v = self.cookies.get_or_insert(Vec::new());
+                v.push(cookie.into());
+                self
+            }
+            pub fn cookies<I, S>(mut self, cookies: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CookieParam>,
+            {
+                let v = self.cookies.get_or_insert(Vec::new());
+                for val in cookies {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetCookiesParams, String> {
+                Ok(SetCookiesParams {
+                    cookies: self.cookies.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cookies))
+                    })?,
+                })
+            }
+        }
+        impl SetCookiesParams {
+            pub const IDENTIFIER: &'static str = "Network.setCookies";
+        }
+        impl chromiumoxide_types::Method for SetCookiesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetCookiesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets given cookies.\n[setCookies](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setCookies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetCookiesReturns {}
+        impl chromiumoxide_types::Command for SetCookiesParams {
+            type Response = SetCookiesReturns;
+        }
+        #[doc = "Specifies whether to always send extra HTTP headers with the requests from this page.\n[setExtraHTTPHeaders](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setExtraHTTPHeaders)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetExtraHttpHeadersParams {
+            #[doc = "Map with extra HTTP headers."]
+            #[serde(rename = "headers")]
+            pub headers: Headers,
+        }
+        impl SetExtraHttpHeadersParams {
+            pub fn new(headers: impl Into<Headers>) -> Self {
+                Self {
+                    headers: headers.into(),
+                }
+            }
+        }
+        impl SetExtraHttpHeadersParams {
+            pub fn builder() -> SetExtraHttpHeadersParamsBuilder {
+                SetExtraHttpHeadersParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetExtraHttpHeadersParamsBuilder {
+            headers: Option<Headers>,
+        }
+        impl SetExtraHttpHeadersParamsBuilder {
+            pub fn headers(mut self, headers: impl Into<Headers>) -> Self {
+                self.headers = Some(headers.into());
+                self
+            }
+            pub fn build(self) -> Result<SetExtraHttpHeadersParams, String> {
+                Ok(SetExtraHttpHeadersParams {
+                    headers: self.headers.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(headers))
+                    })?,
+                })
+            }
+        }
+        impl SetExtraHttpHeadersParams {
+            pub const IDENTIFIER: &'static str = "Network.setExtraHTTPHeaders";
+        }
+        impl chromiumoxide_types::Method for SetExtraHttpHeadersParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetExtraHttpHeadersParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Specifies whether to always send extra HTTP headers with the requests from this page.\n[setExtraHTTPHeaders](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setExtraHTTPHeaders)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetExtraHttpHeadersReturns {}
+        impl chromiumoxide_types::Command for SetExtraHttpHeadersParams {
+            type Response = SetExtraHttpHeadersReturns;
+        }
+        #[doc = "Specifies whether to attach a page script stack id in requests\n[setAttachDebugStack](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setAttachDebugStack)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAttachDebugStackParams {
+            #[doc = "Whether to attach a page script stack for debugging purpose."]
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetAttachDebugStackParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetAttachDebugStackParams {
+            pub fn builder() -> SetAttachDebugStackParamsBuilder {
+                SetAttachDebugStackParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAttachDebugStackParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetAttachDebugStackParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAttachDebugStackParams, String> {
+                Ok(SetAttachDebugStackParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetAttachDebugStackParams {
+            pub const IDENTIFIER: &'static str = "Network.setAttachDebugStack";
+        }
+        impl chromiumoxide_types::Method for SetAttachDebugStackParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAttachDebugStackParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Specifies whether to attach a page script stack id in requests\n[setAttachDebugStack](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setAttachDebugStack)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAttachDebugStackReturns {}
+        impl chromiumoxide_types::Command for SetAttachDebugStackParams {
+            type Response = SetAttachDebugStackReturns;
+        }
+        #[doc = "Allows overriding user agent with the given string.\n[setUserAgentOverride](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setUserAgentOverride)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetUserAgentOverrideParams {
+            #[doc = "User agent to use."]
+            #[serde(rename = "userAgent")]
+            pub user_agent: String,
+            #[doc = "Browser language to emulate."]
+            #[serde(rename = "acceptLanguage")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub accept_language: Option<String>,
+            #[doc = "The platform navigator.platform should return."]
+            #[serde(rename = "platform")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub platform: Option<String>,
+            #[doc = "To be sent in Sec-CH-UA-* headers and returned in navigator.userAgentData"]
+            #[serde(rename = "userAgentMetadata")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub user_agent_metadata: Option<super::emulation::UserAgentMetadata>,
+        }
+        impl SetUserAgentOverrideParams {
+            pub fn new(user_agent: impl Into<String>) -> Self {
+                Self {
+                    user_agent: user_agent.into(),
+                    accept_language: None,
+                    platform: None,
+                    user_agent_metadata: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for SetUserAgentOverrideParams {
+            fn from(url: T) -> Self {
+                SetUserAgentOverrideParams::new(url)
+            }
+        }
+        impl SetUserAgentOverrideParams {
+            pub fn builder() -> SetUserAgentOverrideParamsBuilder {
+                SetUserAgentOverrideParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetUserAgentOverrideParamsBuilder {
+            user_agent: Option<String>,
+            accept_language: Option<String>,
+            platform: Option<String>,
+            user_agent_metadata: Option<super::emulation::UserAgentMetadata>,
+        }
+        impl SetUserAgentOverrideParamsBuilder {
+            pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
+                self.user_agent = Some(user_agent.into());
+                self
+            }
+            pub fn accept_language(mut self, accept_language: impl Into<String>) -> Self {
+                self.accept_language = Some(accept_language.into());
+                self
+            }
+            pub fn platform(mut self, platform: impl Into<String>) -> Self {
+                self.platform = Some(platform.into());
+                self
+            }
+            pub fn user_agent_metadata(
+                mut self,
+                user_agent_metadata: impl Into<super::emulation::UserAgentMetadata>,
+            ) -> Self {
+                self.user_agent_metadata = Some(user_agent_metadata.into());
+                self
+            }
+            pub fn build(self) -> Result<SetUserAgentOverrideParams, String> {
+                Ok(SetUserAgentOverrideParams {
+                    user_agent: self.user_agent.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(user_agent))
+                    })?,
+                    accept_language: self.accept_language,
+                    platform: self.platform,
+                    user_agent_metadata: self.user_agent_metadata,
+                })
+            }
+        }
+        impl SetUserAgentOverrideParams {
+            pub const IDENTIFIER: &'static str = "Network.setUserAgentOverride";
+        }
+        impl chromiumoxide_types::Method for SetUserAgentOverrideParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetUserAgentOverrideParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Allows overriding user agent with the given string.\n[setUserAgentOverride](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setUserAgentOverride)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetUserAgentOverrideReturns {}
+        impl chromiumoxide_types::Command for SetUserAgentOverrideParams {
+            type Response = SetUserAgentOverrideReturns;
+        }
+        #[doc = "Enables streaming of the response for the given requestId.\nIf enabled, the dataReceived event contains the data that was received during streaming.\n[streamResourceContent](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-streamResourceContent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StreamResourceContentParams {
+            #[doc = "Identifier of the request to stream."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+        }
+        impl StreamResourceContentParams {
+            pub fn new(request_id: impl Into<RequestId>) -> Self {
+                Self {
+                    request_id: request_id.into(),
+                }
+            }
+        }
+        impl StreamResourceContentParams {
+            pub fn builder() -> StreamResourceContentParamsBuilder {
+                StreamResourceContentParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StreamResourceContentParamsBuilder {
+            request_id: Option<RequestId>,
+        }
+        impl StreamResourceContentParamsBuilder {
+            pub fn request_id(mut self, request_id: impl Into<RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn build(self) -> Result<StreamResourceContentParams, String> {
+                Ok(StreamResourceContentParams {
+                    request_id: self.request_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(request_id))
+                    })?,
+                })
+            }
+        }
+        impl StreamResourceContentParams {
+            pub const IDENTIFIER: &'static str = "Network.streamResourceContent";
+        }
+        impl chromiumoxide_types::Method for StreamResourceContentParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StreamResourceContentParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables streaming of the response for the given requestId.\nIf enabled, the dataReceived event contains the data that was received during streaming.\n[streamResourceContent](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-streamResourceContent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StreamResourceContentReturns {
+            #[doc = "Data that has been buffered until streaming is enabled."]
+            #[serde(rename = "bufferedData")]
+            pub buffered_data: chromiumoxide_types::Binary,
+        }
+        impl StreamResourceContentReturns {
+            pub fn new(buffered_data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                Self {
+                    buffered_data: buffered_data.into(),
+                }
+            }
+        }
+        impl StreamResourceContentReturns {
+            pub fn builder() -> StreamResourceContentReturnsBuilder {
+                StreamResourceContentReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StreamResourceContentReturnsBuilder {
+            buffered_data: Option<chromiumoxide_types::Binary>,
+        }
+        impl StreamResourceContentReturnsBuilder {
+            pub fn buffered_data(
+                mut self,
+                buffered_data: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.buffered_data = Some(buffered_data.into());
+                self
+            }
+            pub fn build(self) -> Result<StreamResourceContentReturns, String> {
+                Ok(StreamResourceContentReturns {
+                    buffered_data: self.buffered_data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(buffered_data))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for StreamResourceContentParams {
+            type Response = StreamResourceContentReturns;
+        }
+        #[doc = "Returns information about the COEP/COOP isolation status.\n[getSecurityIsolationStatus](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getSecurityIsolationStatus)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetSecurityIsolationStatusParams {
+            #[doc = "If no frameId is provided, the status of the target is provided."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+        }
+        impl GetSecurityIsolationStatusParams {
+            pub fn builder() -> GetSecurityIsolationStatusParamsBuilder {
+                GetSecurityIsolationStatusParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSecurityIsolationStatusParamsBuilder {
+            frame_id: Option<super::page::FrameId>,
+        }
+        impl GetSecurityIsolationStatusParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> GetSecurityIsolationStatusParams {
+                GetSecurityIsolationStatusParams {
+                    frame_id: self.frame_id,
+                }
+            }
+        }
+        impl GetSecurityIsolationStatusParams {
+            pub const IDENTIFIER: &'static str = "Network.getSecurityIsolationStatus";
+        }
+        impl chromiumoxide_types::Method for GetSecurityIsolationStatusParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetSecurityIsolationStatusParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns information about the COEP/COOP isolation status.\n[getSecurityIsolationStatus](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-getSecurityIsolationStatus)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSecurityIsolationStatusReturns {
+            #[serde(rename = "status")]
+            pub status: SecurityIsolationStatus,
+        }
+        impl GetSecurityIsolationStatusReturns {
+            pub fn new(status: impl Into<SecurityIsolationStatus>) -> Self {
+                Self {
+                    status: status.into(),
+                }
+            }
+        }
+        impl GetSecurityIsolationStatusReturns {
+            pub fn builder() -> GetSecurityIsolationStatusReturnsBuilder {
+                GetSecurityIsolationStatusReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSecurityIsolationStatusReturnsBuilder {
+            status: Option<SecurityIsolationStatus>,
+        }
+        impl GetSecurityIsolationStatusReturnsBuilder {
+            pub fn status(mut self, status: impl Into<SecurityIsolationStatus>) -> Self {
+                self.status = Some(status.into());
+                self
+            }
+            pub fn build(self) -> Result<GetSecurityIsolationStatusReturns, String> {
+                Ok(GetSecurityIsolationStatusReturns {
+                    status: self.status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetSecurityIsolationStatusParams {
+            type Response = GetSecurityIsolationStatusReturns;
+        }
+        #[doc = "Enables tracking for the Reporting API, events generated by the Reporting API will now be delivered to the client.\nEnabling triggers 'reportingApiReportAdded' for all existing reports.\n[enableReportingApi](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-enableReportingApi)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EnableReportingApiParams {
+            #[doc = "Whether to enable or disable events for the Reporting API"]
+            #[serde(rename = "enable")]
+            pub enable: bool,
+        }
+        impl EnableReportingApiParams {
+            pub fn new(enable: impl Into<bool>) -> Self {
+                Self {
+                    enable: enable.into(),
+                }
+            }
+        }
+        impl EnableReportingApiParams {
+            pub fn builder() -> EnableReportingApiParamsBuilder {
+                EnableReportingApiParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableReportingApiParamsBuilder {
+            enable: Option<bool>,
+        }
+        impl EnableReportingApiParamsBuilder {
+            pub fn enable(mut self, enable: impl Into<bool>) -> Self {
+                self.enable = Some(enable.into());
+                self
+            }
+            pub fn build(self) -> Result<EnableReportingApiParams, String> {
+                Ok(EnableReportingApiParams {
+                    enable: self.enable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enable))
+                    })?,
+                })
+            }
+        }
+        impl EnableReportingApiParams {
+            pub const IDENTIFIER: &'static str = "Network.enableReportingApi";
+        }
+        impl chromiumoxide_types::Method for EnableReportingApiParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableReportingApiParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables tracking for the Reporting API, events generated by the Reporting API will now be delivered to the client.\nEnabling triggers 'reportingApiReportAdded' for all existing reports.\n[enableReportingApi](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-enableReportingApi)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReportingApiReturns {}
+        impl chromiumoxide_types::Command for EnableReportingApiParams {
+            type Response = EnableReportingApiReturns;
+        }
+        #[doc = "Sets up tracking device bound sessions and fetching of initial set of sessions.\n[enableDeviceBoundSessions](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-enableDeviceBoundSessions)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EnableDeviceBoundSessionsParams {
+            #[doc = "Whether to enable or disable events."]
+            #[serde(rename = "enable")]
+            pub enable: bool,
+        }
+        impl EnableDeviceBoundSessionsParams {
+            pub fn new(enable: impl Into<bool>) -> Self {
+                Self {
+                    enable: enable.into(),
+                }
+            }
+        }
+        impl EnableDeviceBoundSessionsParams {
+            pub fn builder() -> EnableDeviceBoundSessionsParamsBuilder {
+                EnableDeviceBoundSessionsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableDeviceBoundSessionsParamsBuilder {
+            enable: Option<bool>,
+        }
+        impl EnableDeviceBoundSessionsParamsBuilder {
+            pub fn enable(mut self, enable: impl Into<bool>) -> Self {
+                self.enable = Some(enable.into());
+                self
+            }
+            pub fn build(self) -> Result<EnableDeviceBoundSessionsParams, String> {
+                Ok(EnableDeviceBoundSessionsParams {
+                    enable: self.enable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enable))
+                    })?,
+                })
+            }
+        }
+        impl EnableDeviceBoundSessionsParams {
+            pub const IDENTIFIER: &'static str = "Network.enableDeviceBoundSessions";
+        }
+        impl chromiumoxide_types::Method for EnableDeviceBoundSessionsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableDeviceBoundSessionsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets up tracking device bound sessions and fetching of initial set of sessions.\n[enableDeviceBoundSessions](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-enableDeviceBoundSessions)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableDeviceBoundSessionsReturns {}
+        impl chromiumoxide_types::Command for EnableDeviceBoundSessionsParams {
+            type Response = EnableDeviceBoundSessionsReturns;
+        }
+        #[doc = "Fetches the schemeful site for a specific origin.\n[fetchSchemefulSite](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-fetchSchemefulSite)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FetchSchemefulSiteParams {
+            #[doc = "The URL origin."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+        }
+        impl FetchSchemefulSiteParams {
+            pub fn new(origin: impl Into<String>) -> Self {
+                Self {
+                    origin: origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for FetchSchemefulSiteParams {
+            fn from(url: T) -> Self {
+                FetchSchemefulSiteParams::new(url)
+            }
+        }
+        impl FetchSchemefulSiteParams {
+            pub fn builder() -> FetchSchemefulSiteParamsBuilder {
+                FetchSchemefulSiteParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FetchSchemefulSiteParamsBuilder {
+            origin: Option<String>,
+        }
+        impl FetchSchemefulSiteParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn build(self) -> Result<FetchSchemefulSiteParams, String> {
+                Ok(FetchSchemefulSiteParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                })
+            }
+        }
+        impl FetchSchemefulSiteParams {
+            pub const IDENTIFIER: &'static str = "Network.fetchSchemefulSite";
+        }
+        impl chromiumoxide_types::Method for FetchSchemefulSiteParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for FetchSchemefulSiteParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fetches the schemeful site for a specific origin.\n[fetchSchemefulSite](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-fetchSchemefulSite)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FetchSchemefulSiteReturns {
+            #[doc = "The corresponding schemeful site."]
+            #[serde(rename = "schemefulSite")]
+            pub schemeful_site: String,
+        }
+        impl FetchSchemefulSiteReturns {
+            pub fn new(schemeful_site: impl Into<String>) -> Self {
+                Self {
+                    schemeful_site: schemeful_site.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for FetchSchemefulSiteReturns {
+            fn from(url: T) -> Self {
+                FetchSchemefulSiteReturns::new(url)
+            }
+        }
+        impl FetchSchemefulSiteReturns {
+            pub fn builder() -> FetchSchemefulSiteReturnsBuilder {
+                FetchSchemefulSiteReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FetchSchemefulSiteReturnsBuilder {
+            schemeful_site: Option<String>,
+        }
+        impl FetchSchemefulSiteReturnsBuilder {
+            pub fn schemeful_site(mut self, schemeful_site: impl Into<String>) -> Self {
+                self.schemeful_site = Some(schemeful_site.into());
+                self
+            }
+            pub fn build(self) -> Result<FetchSchemefulSiteReturns, String> {
+                Ok(FetchSchemefulSiteReturns {
+                    schemeful_site: self.schemeful_site.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(schemeful_site))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for FetchSchemefulSiteParams {
+            type Response = FetchSchemefulSiteReturns;
+        }
+        #[doc = "Fetches the resource and returns the content.\n[loadNetworkResource](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-loadNetworkResource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LoadNetworkResourceParams {
+            #[doc = "Frame id to get the resource for. Mandatory for frame targets, and\nshould be omitted for worker targets."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+            #[doc = "URL of the resource to get content for."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Options for the request."]
+            #[serde(rename = "options")]
+            pub options: LoadNetworkResourceOptions,
+        }
+        impl LoadNetworkResourceParams {
+            pub fn new(
+                url: impl Into<String>,
+                options: impl Into<LoadNetworkResourceOptions>,
+            ) -> Self {
+                Self {
+                    url: url.into(),
+                    options: options.into(),
+                    frame_id: None,
+                }
+            }
+        }
+        impl LoadNetworkResourceParams {
+            pub fn builder() -> LoadNetworkResourceParamsBuilder {
+                LoadNetworkResourceParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LoadNetworkResourceParamsBuilder {
+            frame_id: Option<super::page::FrameId>,
+            url: Option<String>,
+            options: Option<LoadNetworkResourceOptions>,
+        }
+        impl LoadNetworkResourceParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn options(mut self, options: impl Into<LoadNetworkResourceOptions>) -> Self {
+                self.options = Some(options.into());
+                self
+            }
+            pub fn build(self) -> Result<LoadNetworkResourceParams, String> {
+                Ok(LoadNetworkResourceParams {
+                    frame_id: self.frame_id,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    options: self.options.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(options))
+                    })?,
+                })
+            }
+        }
+        impl LoadNetworkResourceParams {
+            pub const IDENTIFIER: &'static str = "Network.loadNetworkResource";
+        }
+        impl chromiumoxide_types::Method for LoadNetworkResourceParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for LoadNetworkResourceParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fetches the resource and returns the content.\n[loadNetworkResource](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-loadNetworkResource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LoadNetworkResourceReturns {
+            #[serde(rename = "resource")]
+            pub resource: LoadNetworkResourcePageResult,
+        }
+        impl LoadNetworkResourceReturns {
+            pub fn new(resource: impl Into<LoadNetworkResourcePageResult>) -> Self {
+                Self {
+                    resource: resource.into(),
+                }
+            }
+        }
+        impl LoadNetworkResourceReturns {
+            pub fn builder() -> LoadNetworkResourceReturnsBuilder {
+                LoadNetworkResourceReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LoadNetworkResourceReturnsBuilder {
+            resource: Option<LoadNetworkResourcePageResult>,
+        }
+        impl LoadNetworkResourceReturnsBuilder {
+            pub fn resource(mut self, resource: impl Into<LoadNetworkResourcePageResult>) -> Self {
+                self.resource = Some(resource.into());
+                self
+            }
+            pub fn build(self) -> Result<LoadNetworkResourceReturns, String> {
+                Ok(LoadNetworkResourceReturns {
+                    resource: self.resource.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(resource))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for LoadNetworkResourceParams {
+            type Response = LoadNetworkResourceReturns;
+        }
+        #[doc = "Sets Controls for third-party cookie access\nPage reload is required before the new cookie behavior will be observed\n[setCookieControls](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setCookieControls)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetCookieControlsParams {
+            #[doc = "Whether 3pc restriction is enabled."]
+            #[serde(rename = "enableThirdPartyCookieRestriction")]
+            pub enable_third_party_cookie_restriction: bool,
+            #[doc = "Whether 3pc grace period exception should be enabled; false by default."]
+            #[serde(rename = "disableThirdPartyCookieMetadata")]
+            pub disable_third_party_cookie_metadata: bool,
+            #[doc = "Whether 3pc heuristics exceptions should be enabled; false by default."]
+            #[serde(rename = "disableThirdPartyCookieHeuristics")]
+            pub disable_third_party_cookie_heuristics: bool,
+        }
+        impl SetCookieControlsParams {
+            pub fn new(
+                enable_third_party_cookie_restriction: impl Into<bool>,
+                disable_third_party_cookie_metadata: impl Into<bool>,
+                disable_third_party_cookie_heuristics: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    enable_third_party_cookie_restriction: enable_third_party_cookie_restriction
+                        .into(),
+                    disable_third_party_cookie_metadata: disable_third_party_cookie_metadata.into(),
+                    disable_third_party_cookie_heuristics: disable_third_party_cookie_heuristics
+                        .into(),
+                }
+            }
+        }
+        impl SetCookieControlsParams {
+            pub fn builder() -> SetCookieControlsParamsBuilder {
+                SetCookieControlsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetCookieControlsParamsBuilder {
+            enable_third_party_cookie_restriction: Option<bool>,
+            disable_third_party_cookie_metadata: Option<bool>,
+            disable_third_party_cookie_heuristics: Option<bool>,
+        }
+        impl SetCookieControlsParamsBuilder {
+            pub fn enable_third_party_cookie_restriction(
+                mut self,
+                enable_third_party_cookie_restriction: impl Into<bool>,
+            ) -> Self {
+                self.enable_third_party_cookie_restriction =
+                    Some(enable_third_party_cookie_restriction.into());
+                self
+            }
+            pub fn disable_third_party_cookie_metadata(
+                mut self,
+                disable_third_party_cookie_metadata: impl Into<bool>,
+            ) -> Self {
+                self.disable_third_party_cookie_metadata =
+                    Some(disable_third_party_cookie_metadata.into());
+                self
+            }
+            pub fn disable_third_party_cookie_heuristics(
+                mut self,
+                disable_third_party_cookie_heuristics: impl Into<bool>,
+            ) -> Self {
+                self.disable_third_party_cookie_heuristics =
+                    Some(disable_third_party_cookie_heuristics.into());
+                self
+            }
+            pub fn build(self) -> Result<SetCookieControlsParams, String> {
+                Ok(SetCookieControlsParams {
+                    enable_third_party_cookie_restriction: self
+                        .enable_third_party_cookie_restriction
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(enable_third_party_cookie_restriction)
+                            )
+                        })?,
+                    disable_third_party_cookie_metadata: self
+                        .disable_third_party_cookie_metadata
+                        .ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(disable_third_party_cookie_metadata)
+                        )
+                    })?,
+                    disable_third_party_cookie_heuristics: self
+                        .disable_third_party_cookie_heuristics
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(disable_third_party_cookie_heuristics)
+                            )
+                        })?,
+                })
+            }
+        }
+        impl SetCookieControlsParams {
+            pub const IDENTIFIER: &'static str = "Network.setCookieControls";
+        }
+        impl chromiumoxide_types::Method for SetCookieControlsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetCookieControlsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets Controls for third-party cookie access\nPage reload is required before the new cookie behavior will be observed\n[setCookieControls](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setCookieControls)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetCookieControlsReturns {}
+        impl chromiumoxide_types::Command for SetCookieControlsParams {
+            type Response = SetCookieControlsReturns;
+        }
+        #[doc = "Fired when data chunk was received over the network.\n[dataReceived](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-dataReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDataReceived {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "Data chunk length."]
+            #[serde(rename = "dataLength")]
+            pub data_length: i64,
+            #[doc = "Actual bytes received (might be less than dataLength for compressed encodings)."]
+            #[serde(rename = "encodedDataLength")]
+            pub encoded_data_length: i64,
+            #[doc = "Data that was received."]
+            #[serde(rename = "data")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub data: Option<chromiumoxide_types::Binary>,
+        }
+        impl EventDataReceived {
+            pub const IDENTIFIER: &'static str = "Network.dataReceived";
+        }
+        impl chromiumoxide_types::Method for EventDataReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDataReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when EventSource message is received.\n[eventSourceMessageReceived](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-eventSourceMessageReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventEventSourceMessageReceived {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "Message type."]
+            #[serde(rename = "eventName")]
+            pub event_name: String,
+            #[doc = "Message identifier."]
+            #[serde(rename = "eventId")]
+            pub event_id: String,
+            #[doc = "Message content."]
+            #[serde(rename = "data")]
+            pub data: String,
+        }
+        impl EventEventSourceMessageReceived {
+            pub const IDENTIFIER: &'static str = "Network.eventSourceMessageReceived";
+        }
+        impl chromiumoxide_types::Method for EventEventSourceMessageReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventEventSourceMessageReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when HTTP request has failed to load.\n[loadingFailed](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-loadingFailed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventLoadingFailed {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "Resource type."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: ResourceType,
+            #[doc = "Error message. List of network errors: https://cs.chromium.org/chromium/src/net/base/net_error_list.h"]
+            #[serde(rename = "errorText")]
+            pub error_text: String,
+            #[doc = "True if loading was canceled."]
+            #[serde(rename = "canceled")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub canceled: Option<bool>,
+            #[doc = "The reason why loading was blocked, if any."]
+            #[serde(rename = "blockedReason")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub blocked_reason: Option<BlockedReason>,
+            #[doc = "The reason why loading was blocked by CORS, if any."]
+            #[serde(rename = "corsErrorStatus")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cors_error_status: Option<CorsErrorStatus>,
+        }
+        impl EventLoadingFailed {
+            pub const IDENTIFIER: &'static str = "Network.loadingFailed";
+        }
+        impl chromiumoxide_types::Method for EventLoadingFailed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventLoadingFailed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when HTTP request has finished loading.\n[loadingFinished](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-loadingFinished)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventLoadingFinished {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "Total number of bytes received for this request."]
+            #[serde(rename = "encodedDataLength")]
+            pub encoded_data_length: f64,
+        }
+        impl EventLoadingFinished {
+            pub const IDENTIFIER: &'static str = "Network.loadingFinished";
+        }
+        impl chromiumoxide_types::Method for EventLoadingFinished {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventLoadingFinished {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired if request ended up loading from cache.\n[requestServedFromCache](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-requestServedFromCache)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventRequestServedFromCache {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+        }
+        impl EventRequestServedFromCache {
+            pub const IDENTIFIER: &'static str = "Network.requestServedFromCache";
+        }
+        impl chromiumoxide_types::Method for EventRequestServedFromCache {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventRequestServedFromCache {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when page is about to send HTTP request.\n[requestWillBeSent](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-requestWillBeSent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventRequestWillBeSent {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Loader identifier. Empty string if the request is fetched from worker."]
+            #[serde(rename = "loaderId")]
+            pub loader_id: LoaderId,
+            #[doc = "URL of the document this request is loaded for."]
+            #[serde(rename = "documentURL")]
+            pub document_url: String,
+            #[doc = "Request data."]
+            #[serde(rename = "request")]
+            pub request: Request,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "Timestamp."]
+            #[serde(rename = "wallTime")]
+            pub wall_time: TimeSinceEpoch,
+            #[doc = "Request initiator."]
+            #[serde(rename = "initiator")]
+            pub initiator: Initiator,
+            #[doc = "In the case that redirectResponse is populated, this flag indicates whether\nrequestWillBeSentExtraInfo and responseReceivedExtraInfo events will be or were emitted\nfor the request which was just redirected."]
+            #[serde(rename = "redirectHasExtraInfo")]
+            pub redirect_has_extra_info: bool,
+            #[doc = "Redirect response data."]
+            #[serde(rename = "redirectResponse")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub redirect_response: Option<Response>,
+            #[doc = "Type of this resource."]
+            #[serde(rename = "type")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub r#type: Option<ResourceType>,
+            #[doc = "Frame identifier."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+            #[doc = "Whether the request is initiated by a user gesture. Defaults to false."]
+            #[serde(rename = "hasUserGesture")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_user_gesture: Option<bool>,
+            #[doc = "The render blocking behavior of the request."]
+            #[serde(rename = "renderBlockingBehavior")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub render_blocking_behavior: Option<RenderBlockingBehavior>,
+        }
+        impl EventRequestWillBeSent {
+            pub const IDENTIFIER: &'static str = "Network.requestWillBeSent";
+        }
+        impl chromiumoxide_types::Method for EventRequestWillBeSent {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventRequestWillBeSent {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when resource loading priority is changed\n[resourceChangedPriority](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-resourceChangedPriority)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventResourceChangedPriority {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "New priority"]
+            #[serde(rename = "newPriority")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub new_priority: ResourcePriority,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventResourceChangedPriority {
+            pub const IDENTIFIER: &'static str = "Network.resourceChangedPriority";
+        }
+        impl chromiumoxide_types::Method for EventResourceChangedPriority {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventResourceChangedPriority {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a signed exchange was received over the network\n[signedExchangeReceived](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-signedExchangeReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventSignedExchangeReceived {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Information about the signed exchange response."]
+            #[serde(rename = "info")]
+            pub info: SignedExchangeInfo,
+        }
+        impl EventSignedExchangeReceived {
+            pub const IDENTIFIER: &'static str = "Network.signedExchangeReceived";
+        }
+        impl chromiumoxide_types::Method for EventSignedExchangeReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventSignedExchangeReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when HTTP response is available.\n[responseReceived](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-responseReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventResponseReceived {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Loader identifier. Empty string if the request is fetched from worker."]
+            #[serde(rename = "loaderId")]
+            pub loader_id: LoaderId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "Resource type."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: ResourceType,
+            #[doc = "Response data."]
+            #[serde(rename = "response")]
+            pub response: Response,
+            #[doc = "Indicates whether requestWillBeSentExtraInfo and responseReceivedExtraInfo events will be\nor were emitted for this request."]
+            #[serde(rename = "hasExtraInfo")]
+            pub has_extra_info: bool,
+            #[doc = "Frame identifier."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+        }
+        impl EventResponseReceived {
+            pub const IDENTIFIER: &'static str = "Network.responseReceived";
+        }
+        impl chromiumoxide_types::Method for EventResponseReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventResponseReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when WebSocket is closed.\n[webSocketClosed](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-webSocketClosed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWebSocketClosed {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventWebSocketClosed {
+            pub const IDENTIFIER: &'static str = "Network.webSocketClosed";
+        }
+        impl chromiumoxide_types::Method for EventWebSocketClosed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWebSocketClosed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired upon WebSocket creation.\n[webSocketCreated](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-webSocketCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWebSocketCreated {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "WebSocket request URL."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Request initiator."]
+            #[serde(rename = "initiator")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub initiator: Option<Initiator>,
+        }
+        impl EventWebSocketCreated {
+            pub const IDENTIFIER: &'static str = "Network.webSocketCreated";
+        }
+        impl chromiumoxide_types::Method for EventWebSocketCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWebSocketCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when WebSocket message error occurs.\n[webSocketFrameError](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-webSocketFrameError)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWebSocketFrameError {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "WebSocket error message."]
+            #[serde(rename = "errorMessage")]
+            pub error_message: String,
+        }
+        impl EventWebSocketFrameError {
+            pub const IDENTIFIER: &'static str = "Network.webSocketFrameError";
+        }
+        impl chromiumoxide_types::Method for EventWebSocketFrameError {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWebSocketFrameError {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when WebSocket message is received.\n[webSocketFrameReceived](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-webSocketFrameReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWebSocketFrameReceived {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "WebSocket response data."]
+            #[serde(rename = "response")]
+            pub response: WebSocketFrame,
+        }
+        impl EventWebSocketFrameReceived {
+            pub const IDENTIFIER: &'static str = "Network.webSocketFrameReceived";
+        }
+        impl chromiumoxide_types::Method for EventWebSocketFrameReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWebSocketFrameReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when WebSocket message is sent.\n[webSocketFrameSent](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-webSocketFrameSent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWebSocketFrameSent {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "WebSocket response data."]
+            #[serde(rename = "response")]
+            pub response: WebSocketFrame,
+        }
+        impl EventWebSocketFrameSent {
+            pub const IDENTIFIER: &'static str = "Network.webSocketFrameSent";
+        }
+        impl chromiumoxide_types::Method for EventWebSocketFrameSent {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWebSocketFrameSent {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when WebSocket handshake response becomes available.\n[webSocketHandshakeResponseReceived](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-webSocketHandshakeResponseReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWebSocketHandshakeResponseReceived {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "WebSocket response data."]
+            #[serde(rename = "response")]
+            pub response: WebSocketResponse,
+        }
+        impl EventWebSocketHandshakeResponseReceived {
+            pub const IDENTIFIER: &'static str = "Network.webSocketHandshakeResponseReceived";
+        }
+        impl chromiumoxide_types::Method for EventWebSocketHandshakeResponseReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWebSocketHandshakeResponseReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when WebSocket is about to initiate handshake.\n[webSocketWillSendHandshakeRequest](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-webSocketWillSendHandshakeRequest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWebSocketWillSendHandshakeRequest {
+            #[doc = "Request identifier."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "UTC Timestamp."]
+            #[serde(rename = "wallTime")]
+            pub wall_time: TimeSinceEpoch,
+            #[doc = "WebSocket request data."]
+            #[serde(rename = "request")]
+            pub request: WebSocketRequest,
+        }
+        impl EventWebSocketWillSendHandshakeRequest {
+            pub const IDENTIFIER: &'static str = "Network.webSocketWillSendHandshakeRequest";
+        }
+        impl chromiumoxide_types::Method for EventWebSocketWillSendHandshakeRequest {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWebSocketWillSendHandshakeRequest {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired upon WebTransport creation.\n[webTransportCreated](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-webTransportCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWebTransportCreated {
+            #[doc = "WebTransport identifier."]
+            #[serde(rename = "transportId")]
+            pub transport_id: RequestId,
+            #[doc = "WebTransport request URL."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[doc = "Request initiator."]
+            #[serde(rename = "initiator")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub initiator: Option<Initiator>,
+        }
+        impl EventWebTransportCreated {
+            pub const IDENTIFIER: &'static str = "Network.webTransportCreated";
+        }
+        impl chromiumoxide_types::Method for EventWebTransportCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWebTransportCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when WebTransport handshake is finished.\n[webTransportConnectionEstablished](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-webTransportConnectionEstablished)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWebTransportConnectionEstablished {
+            #[doc = "WebTransport identifier."]
+            #[serde(rename = "transportId")]
+            pub transport_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventWebTransportConnectionEstablished {
+            pub const IDENTIFIER: &'static str = "Network.webTransportConnectionEstablished";
+        }
+        impl chromiumoxide_types::Method for EventWebTransportConnectionEstablished {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWebTransportConnectionEstablished {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when WebTransport is disposed.\n[webTransportClosed](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-webTransportClosed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWebTransportClosed {
+            #[doc = "WebTransport identifier."]
+            #[serde(rename = "transportId")]
+            pub transport_id: RequestId,
+            #[doc = "Timestamp."]
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventWebTransportClosed {
+            pub const IDENTIFIER: &'static str = "Network.webTransportClosed";
+        }
+        impl chromiumoxide_types::Method for EventWebTransportClosed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWebTransportClosed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired upon direct_socket.TCPSocket creation.\n[directTCPSocketCreated](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directTCPSocketCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectTcpSocketCreated {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "remoteAddr")]
+            pub remote_addr: String,
+            #[doc = "Unsigned int 16."]
+            #[serde(rename = "remotePort")]
+            pub remote_port: i64,
+            #[serde(rename = "options")]
+            pub options: DirectTcpSocketOptions,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[serde(rename = "initiator")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub initiator: Option<Initiator>,
+        }
+        impl EventDirectTcpSocketCreated {
+            pub const IDENTIFIER: &'static str = "Network.directTCPSocketCreated";
+        }
+        impl chromiumoxide_types::Method for EventDirectTcpSocketCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectTcpSocketCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when direct_socket.TCPSocket connection is opened.\n[directTCPSocketOpened](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directTCPSocketOpened)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectTcpSocketOpened {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "remoteAddr")]
+            pub remote_addr: String,
+            #[doc = "Expected to be unsigned integer."]
+            #[serde(rename = "remotePort")]
+            pub remote_port: i64,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[serde(rename = "localAddr")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub local_addr: Option<String>,
+            #[doc = "Expected to be unsigned integer."]
+            #[serde(rename = "localPort")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub local_port: Option<i64>,
+        }
+        impl EventDirectTcpSocketOpened {
+            pub const IDENTIFIER: &'static str = "Network.directTCPSocketOpened";
+        }
+        impl chromiumoxide_types::Method for EventDirectTcpSocketOpened {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectTcpSocketOpened {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when direct_socket.TCPSocket is aborted.\n[directTCPSocketAborted](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directTCPSocketAborted)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectTcpSocketAborted {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "errorMessage")]
+            pub error_message: String,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventDirectTcpSocketAborted {
+            pub const IDENTIFIER: &'static str = "Network.directTCPSocketAborted";
+        }
+        impl chromiumoxide_types::Method for EventDirectTcpSocketAborted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectTcpSocketAborted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when direct_socket.TCPSocket is closed.\n[directTCPSocketClosed](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directTCPSocketClosed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectTcpSocketClosed {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventDirectTcpSocketClosed {
+            pub const IDENTIFIER: &'static str = "Network.directTCPSocketClosed";
+        }
+        impl chromiumoxide_types::Method for EventDirectTcpSocketClosed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectTcpSocketClosed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when data is sent to tcp direct socket stream.\n[directTCPSocketChunkSent](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directTCPSocketChunkSent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectTcpSocketChunkSent {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "data")]
+            pub data: chromiumoxide_types::Binary,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventDirectTcpSocketChunkSent {
+            pub const IDENTIFIER: &'static str = "Network.directTCPSocketChunkSent";
+        }
+        impl chromiumoxide_types::Method for EventDirectTcpSocketChunkSent {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectTcpSocketChunkSent {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when data is received from tcp direct socket stream.\n[directTCPSocketChunkReceived](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directTCPSocketChunkReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectTcpSocketChunkReceived {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "data")]
+            pub data: chromiumoxide_types::Binary,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventDirectTcpSocketChunkReceived {
+            pub const IDENTIFIER: &'static str = "Network.directTCPSocketChunkReceived";
+        }
+        impl chromiumoxide_types::Method for EventDirectTcpSocketChunkReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectTcpSocketChunkReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectUdpSocketJoinedMulticastGroup {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "IPAddress")]
+            pub ip_address: String,
+        }
+        impl EventDirectUdpSocketJoinedMulticastGroup {
+            pub const IDENTIFIER: &'static str = "Network.directUDPSocketJoinedMulticastGroup";
+        }
+        impl chromiumoxide_types::Method for EventDirectUdpSocketJoinedMulticastGroup {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectUdpSocketJoinedMulticastGroup {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectUdpSocketLeftMulticastGroup {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "IPAddress")]
+            pub ip_address: String,
+        }
+        impl EventDirectUdpSocketLeftMulticastGroup {
+            pub const IDENTIFIER: &'static str = "Network.directUDPSocketLeftMulticastGroup";
+        }
+        impl chromiumoxide_types::Method for EventDirectUdpSocketLeftMulticastGroup {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectUdpSocketLeftMulticastGroup {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired upon direct_socket.UDPSocket creation.\n[directUDPSocketCreated](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directUDPSocketCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectUdpSocketCreated {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "options")]
+            pub options: DirectUdpSocketOptions,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[serde(rename = "initiator")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub initiator: Option<Initiator>,
+        }
+        impl EventDirectUdpSocketCreated {
+            pub const IDENTIFIER: &'static str = "Network.directUDPSocketCreated";
+        }
+        impl chromiumoxide_types::Method for EventDirectUdpSocketCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectUdpSocketCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when direct_socket.UDPSocket connection is opened.\n[directUDPSocketOpened](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directUDPSocketOpened)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectUdpSocketOpened {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "localAddr")]
+            pub local_addr: String,
+            #[doc = "Expected to be unsigned integer."]
+            #[serde(rename = "localPort")]
+            pub local_port: i64,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+            #[serde(rename = "remoteAddr")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub remote_addr: Option<String>,
+            #[doc = "Expected to be unsigned integer."]
+            #[serde(rename = "remotePort")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub remote_port: Option<i64>,
+        }
+        impl EventDirectUdpSocketOpened {
+            pub const IDENTIFIER: &'static str = "Network.directUDPSocketOpened";
+        }
+        impl chromiumoxide_types::Method for EventDirectUdpSocketOpened {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectUdpSocketOpened {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when direct_socket.UDPSocket is aborted.\n[directUDPSocketAborted](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directUDPSocketAborted)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectUdpSocketAborted {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "errorMessage")]
+            pub error_message: String,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventDirectUdpSocketAborted {
+            pub const IDENTIFIER: &'static str = "Network.directUDPSocketAborted";
+        }
+        impl chromiumoxide_types::Method for EventDirectUdpSocketAborted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectUdpSocketAborted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when direct_socket.UDPSocket is closed.\n[directUDPSocketClosed](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directUDPSocketClosed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectUdpSocketClosed {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventDirectUdpSocketClosed {
+            pub const IDENTIFIER: &'static str = "Network.directUDPSocketClosed";
+        }
+        impl chromiumoxide_types::Method for EventDirectUdpSocketClosed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectUdpSocketClosed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when message is sent to udp direct socket stream.\n[directUDPSocketChunkSent](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directUDPSocketChunkSent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectUdpSocketChunkSent {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "message")]
+            pub message: DirectUdpMessage,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventDirectUdpSocketChunkSent {
+            pub const IDENTIFIER: &'static str = "Network.directUDPSocketChunkSent";
+        }
+        impl chromiumoxide_types::Method for EventDirectUdpSocketChunkSent {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectUdpSocketChunkSent {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when message is received from udp direct socket stream.\n[directUDPSocketChunkReceived](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-directUDPSocketChunkReceived)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDirectUdpSocketChunkReceived {
+            #[serde(rename = "identifier")]
+            pub identifier: RequestId,
+            #[serde(rename = "message")]
+            pub message: DirectUdpMessage,
+            #[serde(rename = "timestamp")]
+            pub timestamp: MonotonicTime,
+        }
+        impl EventDirectUdpSocketChunkReceived {
+            pub const IDENTIFIER: &'static str = "Network.directUDPSocketChunkReceived";
+        }
+        impl chromiumoxide_types::Method for EventDirectUdpSocketChunkReceived {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDirectUdpSocketChunkReceived {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when additional information about a requestWillBeSent event is available from the\nnetwork stack. Not every requestWillBeSent event will have an additional\nrequestWillBeSentExtraInfo fired for it, and there is no guarantee whether requestWillBeSent\nor requestWillBeSentExtraInfo will be fired first for the same request.\n[requestWillBeSentExtraInfo](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-requestWillBeSentExtraInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventRequestWillBeSentExtraInfo {
+            #[doc = "Request identifier. Used to match this information to an existing requestWillBeSent event."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "A list of cookies potentially associated to the requested URL. This includes both cookies sent with\nthe request and the ones not sent; the latter are distinguished by having blockedReasons field set."]
+            #[serde(rename = "associatedCookies")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub associated_cookies: Vec<AssociatedCookie>,
+            #[doc = "Raw request headers as they will be sent over the wire."]
+            #[serde(rename = "headers")]
+            pub headers: Headers,
+            #[doc = "Connection timing information for the request."]
+            #[serde(rename = "connectTiming")]
+            pub connect_timing: ConnectTiming,
+            #[doc = "The client security state set for the request."]
+            #[serde(rename = "clientSecurityState")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub client_security_state: Option<ClientSecurityState>,
+            #[doc = "Whether the site has partitioned cookies stored in a partition different than the current one."]
+            #[serde(rename = "siteHasCookieInOtherPartition")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub site_has_cookie_in_other_partition: Option<bool>,
+            #[doc = "The network conditions id if this request was affected by network conditions configured via\nemulateNetworkConditionsByRule."]
+            #[serde(rename = "appliedNetworkConditionsId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub applied_network_conditions_id: Option<String>,
+        }
+        impl EventRequestWillBeSentExtraInfo {
+            pub const IDENTIFIER: &'static str = "Network.requestWillBeSentExtraInfo";
+        }
+        impl chromiumoxide_types::Method for EventRequestWillBeSentExtraInfo {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventRequestWillBeSentExtraInfo {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when additional information about a responseReceived event is available from the network\nstack. Not every responseReceived event will have an additional responseReceivedExtraInfo for\nit, and responseReceivedExtraInfo may be fired before or after responseReceived.\n[responseReceivedExtraInfo](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-responseReceivedExtraInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventResponseReceivedExtraInfo {
+            #[doc = "Request identifier. Used to match this information to another responseReceived event."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "A list of cookies which were not stored from the response along with the corresponding\nreasons for blocking. The cookies here may not be valid due to syntax errors, which\nare represented by the invalid cookie line string instead of a proper cookie."]
+            #[serde(rename = "blockedCookies")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub blocked_cookies: Vec<BlockedSetCookieWithReason>,
+            #[doc = "Raw response headers as they were received over the wire.\nDuplicate headers in the response are represented as a single key with their values\nconcatentated using `\\n` as the separator.\nSee also `headersText` that contains verbatim text for HTTP/1.*."]
+            #[serde(rename = "headers")]
+            pub headers: Headers,
+            #[doc = "The IP address space of the resource. The address space can only be determined once the transport\nestablished the connection, so we can't send it in `requestWillBeSentExtraInfo`."]
+            #[serde(rename = "resourceIPAddressSpace")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub resource_ip_address_space: IpAddressSpace,
+            #[doc = "The status code of the response. This is useful in cases the request failed and no responseReceived\nevent is triggered, which is the case for, e.g., CORS errors. This is also the correct status code\nfor cached requests, where the status in responseReceived is a 200 and this will be 304."]
+            #[serde(rename = "statusCode")]
+            pub status_code: i64,
+            #[doc = "Raw response header text as it was received over the wire. The raw text may not always be\navailable, such as in the case of HTTP/2 or QUIC."]
+            #[serde(rename = "headersText")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub headers_text: Option<String>,
+            #[doc = "The cookie partition key that will be used to store partitioned cookies set in this response.\nOnly sent when partitioned cookies are enabled."]
+            #[serde(rename = "cookiePartitionKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cookie_partition_key: Option<CookiePartitionKey>,
+            #[doc = "True if partitioned cookies are enabled, but the partition key is not serializable to string."]
+            #[serde(rename = "cookiePartitionKeyOpaque")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cookie_partition_key_opaque: Option<bool>,
+            #[doc = "A list of cookies which should have been blocked by 3PCD but are exempted and stored from\nthe response with the corresponding reason."]
+            #[serde(rename = "exemptedCookies")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exempted_cookies: Option<Vec<ExemptedSetCookieWithReason>>,
+        }
+        impl EventResponseReceivedExtraInfo {
+            pub const IDENTIFIER: &'static str = "Network.responseReceivedExtraInfo";
+        }
+        impl chromiumoxide_types::Method for EventResponseReceivedExtraInfo {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventResponseReceivedExtraInfo {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when 103 Early Hints headers is received in addition to the common response.\nNot every responseReceived event will have an responseReceivedEarlyHints fired.\nOnly one responseReceivedEarlyHints may be fired for eached responseReceived event.\n[responseReceivedEarlyHints](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-responseReceivedEarlyHints)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventResponseReceivedEarlyHints {
+            #[doc = "Request identifier. Used to match this information to another responseReceived event."]
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Raw response headers as they were received over the wire.\nDuplicate headers in the response are represented as a single key with their values\nconcatentated using `\\n` as the separator.\nSee also `headersText` that contains verbatim text for HTTP/1.*."]
+            #[serde(rename = "headers")]
+            pub headers: Headers,
+        }
+        impl EventResponseReceivedEarlyHints {
+            pub const IDENTIFIER: &'static str = "Network.responseReceivedEarlyHints";
+        }
+        impl chromiumoxide_types::Method for EventResponseReceivedEarlyHints {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventResponseReceivedEarlyHints {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired exactly once for each Trust Token operation. Depending on\nthe type of the operation and whether the operation succeeded or\nfailed, the event is fired before the corresponding request was sent\nor after the response was received.\n[trustTokenOperationDone](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-trustTokenOperationDone)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventTrustTokenOperationDone {
+            #[doc = "Detailed success or error status of the operation.\n'AlreadyExists' also signifies a successful operation, as the result\nof the operation already exists und thus, the operation was abort\npreemptively (e.g. a cache hit)."]
+            #[serde(rename = "status")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub status: TrustTokenOperationDoneStatus,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: TrustTokenOperationType,
+            #[serde(rename = "requestId")]
+            pub request_id: RequestId,
+            #[doc = "Top level origin. The context in which the operation was attempted."]
+            #[serde(rename = "topLevelOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub top_level_origin: Option<String>,
+            #[doc = "Origin of the issuer in case of a \"Issuance\" or \"Redemption\" operation."]
+            #[serde(rename = "issuerOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub issuer_origin: Option<String>,
+            #[doc = "The number of obtained Trust Tokens on a successful \"Issuance\" operation."]
+            #[serde(rename = "issuedTokenCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub issued_token_count: Option<i64>,
+        }
+        #[doc = "Detailed success or error status of the operation.\n'AlreadyExists' also signifies a successful operation, as the result\nof the operation already exists und thus, the operation was abort\npreemptively (e.g. a cache hit)."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum TrustTokenOperationDoneStatus {
+            #[serde(rename = "Ok")]
+            Ok,
+            #[serde(rename = "InvalidArgument")]
+            InvalidArgument,
+            #[serde(rename = "MissingIssuerKeys")]
+            MissingIssuerKeys,
+            #[serde(rename = "FailedPrecondition")]
+            FailedPrecondition,
+            #[serde(rename = "ResourceExhausted")]
+            ResourceExhausted,
+            #[serde(rename = "AlreadyExists")]
+            AlreadyExists,
+            #[serde(rename = "ResourceLimited")]
+            ResourceLimited,
+            #[serde(rename = "Unauthorized")]
+            Unauthorized,
+            #[serde(rename = "BadResponse")]
+            BadResponse,
+            #[serde(rename = "InternalError")]
+            InternalError,
+            #[serde(rename = "UnknownError")]
+            UnknownError,
+            #[serde(rename = "FulfilledLocally")]
+            FulfilledLocally,
+            #[serde(rename = "SiteIssuerLimit")]
+            SiteIssuerLimit,
+        }
+        impl AsRef<str> for TrustTokenOperationDoneStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    TrustTokenOperationDoneStatus::Ok => "Ok",
+                    TrustTokenOperationDoneStatus::InvalidArgument => "InvalidArgument",
+                    TrustTokenOperationDoneStatus::MissingIssuerKeys => "MissingIssuerKeys",
+                    TrustTokenOperationDoneStatus::FailedPrecondition => "FailedPrecondition",
+                    TrustTokenOperationDoneStatus::ResourceExhausted => "ResourceExhausted",
+                    TrustTokenOperationDoneStatus::AlreadyExists => "AlreadyExists",
+                    TrustTokenOperationDoneStatus::ResourceLimited => "ResourceLimited",
+                    TrustTokenOperationDoneStatus::Unauthorized => "Unauthorized",
+                    TrustTokenOperationDoneStatus::BadResponse => "BadResponse",
+                    TrustTokenOperationDoneStatus::InternalError => "InternalError",
+                    TrustTokenOperationDoneStatus::UnknownError => "UnknownError",
+                    TrustTokenOperationDoneStatus::FulfilledLocally => "FulfilledLocally",
+                    TrustTokenOperationDoneStatus::SiteIssuerLimit => "SiteIssuerLimit",
+                }
+            }
+        }
+        impl ::std::str::FromStr for TrustTokenOperationDoneStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Ok" | "ok" => Ok(TrustTokenOperationDoneStatus::Ok),
+                    "InvalidArgument" | "invalidargument" => {
+                        Ok(TrustTokenOperationDoneStatus::InvalidArgument)
+                    }
+                    "MissingIssuerKeys" | "missingissuerkeys" => {
+                        Ok(TrustTokenOperationDoneStatus::MissingIssuerKeys)
+                    }
+                    "FailedPrecondition" | "failedprecondition" => {
+                        Ok(TrustTokenOperationDoneStatus::FailedPrecondition)
+                    }
+                    "ResourceExhausted" | "resourceexhausted" => {
+                        Ok(TrustTokenOperationDoneStatus::ResourceExhausted)
+                    }
+                    "AlreadyExists" | "alreadyexists" => {
+                        Ok(TrustTokenOperationDoneStatus::AlreadyExists)
+                    }
+                    "ResourceLimited" | "resourcelimited" => {
+                        Ok(TrustTokenOperationDoneStatus::ResourceLimited)
+                    }
+                    "Unauthorized" | "unauthorized" => {
+                        Ok(TrustTokenOperationDoneStatus::Unauthorized)
+                    }
+                    "BadResponse" | "badresponse" => Ok(TrustTokenOperationDoneStatus::BadResponse),
+                    "InternalError" | "internalerror" => {
+                        Ok(TrustTokenOperationDoneStatus::InternalError)
+                    }
+                    "UnknownError" | "unknownerror" => {
+                        Ok(TrustTokenOperationDoneStatus::UnknownError)
+                    }
+                    "FulfilledLocally" | "fulfilledlocally" => {
+                        Ok(TrustTokenOperationDoneStatus::FulfilledLocally)
+                    }
+                    "SiteIssuerLimit" | "siteissuerlimit" => {
+                        Ok(TrustTokenOperationDoneStatus::SiteIssuerLimit)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EventTrustTokenOperationDone {
+            pub const IDENTIFIER: &'static str = "Network.trustTokenOperationDone";
+        }
+        impl chromiumoxide_types::Method for EventTrustTokenOperationDone {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventTrustTokenOperationDone {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired once security policy has been updated.\n[policyUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-policyUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventPolicyUpdated {}
+        impl EventPolicyUpdated {
+            pub const IDENTIFIER: &'static str = "Network.policyUpdated";
+        }
+        impl chromiumoxide_types::Method for EventPolicyUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPolicyUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Is sent whenever a new report is added.\nAnd after 'enableReportingApi' for all existing reports.\n[reportingApiReportAdded](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-reportingApiReportAdded)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventReportingApiReportAdded {
+            #[serde(rename = "report")]
+            pub report: ReportingApiReport,
+        }
+        impl EventReportingApiReportAdded {
+            pub const IDENTIFIER: &'static str = "Network.reportingApiReportAdded";
+        }
+        impl chromiumoxide_types::Method for EventReportingApiReportAdded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventReportingApiReportAdded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventReportingApiReportUpdated {
+            #[serde(rename = "report")]
+            pub report: ReportingApiReport,
+        }
+        impl EventReportingApiReportUpdated {
+            pub const IDENTIFIER: &'static str = "Network.reportingApiReportUpdated";
+        }
+        impl chromiumoxide_types::Method for EventReportingApiReportUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventReportingApiReportUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventReportingApiEndpointsChangedForOrigin {
+            #[doc = "Origin of the document(s) which configured the endpoints."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[serde(rename = "endpoints")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub endpoints: Vec<ReportingApiEndpoint>,
+        }
+        impl EventReportingApiEndpointsChangedForOrigin {
+            pub const IDENTIFIER: &'static str = "Network.reportingApiEndpointsChangedForOrigin";
+        }
+        impl chromiumoxide_types::Method for EventReportingApiEndpointsChangedForOrigin {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventReportingApiEndpointsChangedForOrigin {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Triggered when the initial set of device bound sessions is added.\n[deviceBoundSessionsAdded](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-deviceBoundSessionsAdded)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDeviceBoundSessionsAdded {
+            #[doc = "The device bound sessions."]
+            #[serde(rename = "sessions")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub sessions: Vec<DeviceBoundSession>,
+        }
+        impl EventDeviceBoundSessionsAdded {
+            pub const IDENTIFIER: &'static str = "Network.deviceBoundSessionsAdded";
+        }
+        impl chromiumoxide_types::Method for EventDeviceBoundSessionsAdded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDeviceBoundSessionsAdded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Triggered when a device bound session event occurs.\n[deviceBoundSessionEventOccurred](https://chromedevtools.github.io/devtools-protocol/tot/Network/#event-deviceBoundSessionEventOccurred)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDeviceBoundSessionEventOccurred {
+            #[doc = "A unique identifier for this session event."]
+            #[serde(rename = "eventId")]
+            pub event_id: DeviceBoundSessionEventId,
+            #[doc = "The site this session event is associated with."]
+            #[serde(rename = "site")]
+            pub site: String,
+            #[doc = "Whether this event was considered successful."]
+            #[serde(rename = "succeeded")]
+            pub succeeded: bool,
+            #[doc = "The session ID this event is associated with. May not be populated for\nfailed events."]
+            #[serde(rename = "sessionId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub session_id: Option<String>,
+            #[doc = "The below are the different session event type details. Exactly one is populated."]
+            #[serde(rename = "creationEventDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub creation_event_details: Option<CreationEventDetails>,
+            #[serde(rename = "refreshEventDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub refresh_event_details: Option<RefreshEventDetails>,
+            #[serde(rename = "terminationEventDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub termination_event_details: Option<TerminationEventDetails>,
+            #[serde(rename = "challengeEventDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub challenge_event_details: Option<ChallengeEventDetails>,
+        }
+        impl EventDeviceBoundSessionEventOccurred {
+            pub const IDENTIFIER: &'static str = "Network.deviceBoundSessionEventOccurred";
+        }
+        impl chromiumoxide_types::Method for EventDeviceBoundSessionEventOccurred {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDeviceBoundSessionEventOccurred {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "This domain provides various functionality related to drawing atop the inspected page."]
+    pub mod overlay {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Configuration data for drawing the source order of an elements children.\n[SourceOrderConfig](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#type-SourceOrderConfig)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SourceOrderConfig {
+            #[doc = "the color to outline the given element in."]
+            #[serde(rename = "parentOutlineColor")]
+            pub parent_outline_color: super::dom::Rgba,
+            #[doc = "the color to outline the child elements in."]
+            #[serde(rename = "childOutlineColor")]
+            pub child_outline_color: super::dom::Rgba,
+        }
+        impl SourceOrderConfig {
+            pub fn new(
+                parent_outline_color: impl Into<super::dom::Rgba>,
+                child_outline_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                Self {
+                    parent_outline_color: parent_outline_color.into(),
+                    child_outline_color: child_outline_color.into(),
+                }
+            }
+        }
+        impl SourceOrderConfig {
+            pub fn builder() -> SourceOrderConfigBuilder {
+                SourceOrderConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SourceOrderConfigBuilder {
+            parent_outline_color: Option<super::dom::Rgba>,
+            child_outline_color: Option<super::dom::Rgba>,
+        }
+        impl SourceOrderConfigBuilder {
+            pub fn parent_outline_color(
+                mut self,
+                parent_outline_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.parent_outline_color = Some(parent_outline_color.into());
+                self
+            }
+            pub fn child_outline_color(
+                mut self,
+                child_outline_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.child_outline_color = Some(child_outline_color.into());
+                self
+            }
+            pub fn build(self) -> Result<SourceOrderConfig, String> {
+                Ok(SourceOrderConfig {
+                    parent_outline_color: self.parent_outline_color.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(parent_outline_color)
+                        )
+                    })?,
+                    child_outline_color: self.child_outline_color.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(child_outline_color)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl SourceOrderConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.SourceOrderConfig";
+        }
+        #[doc = "Configuration data for the highlighting of Grid elements.\n[GridHighlightConfig](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#type-GridHighlightConfig)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GridHighlightConfig {
+            #[doc = "Whether the extension lines from grid cells to the rulers should be shown (default: false)."]
+            #[serde(rename = "showGridExtensionLines")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_grid_extension_lines: Option<bool>,
+            #[doc = "Show Positive line number labels (default: false)."]
+            #[serde(rename = "showPositiveLineNumbers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_positive_line_numbers: Option<bool>,
+            #[doc = "Show Negative line number labels (default: false)."]
+            #[serde(rename = "showNegativeLineNumbers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_negative_line_numbers: Option<bool>,
+            #[doc = "Show area name labels (default: false)."]
+            #[serde(rename = "showAreaNames")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_area_names: Option<bool>,
+            #[doc = "Show line name labels (default: false)."]
+            #[serde(rename = "showLineNames")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_line_names: Option<bool>,
+            #[doc = "Show track size labels (default: false)."]
+            #[serde(rename = "showTrackSizes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_track_sizes: Option<bool>,
+            #[doc = "The grid container border highlight color (default: transparent)."]
+            #[serde(rename = "gridBorderColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub grid_border_color: Option<super::dom::Rgba>,
+            #[doc = "The row line color (default: transparent)."]
+            #[serde(rename = "rowLineColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub row_line_color: Option<super::dom::Rgba>,
+            #[doc = "The column line color (default: transparent)."]
+            #[serde(rename = "columnLineColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub column_line_color: Option<super::dom::Rgba>,
+            #[doc = "Whether the grid border is dashed (default: false)."]
+            #[serde(rename = "gridBorderDash")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub grid_border_dash: Option<bool>,
+            #[doc = "Whether row lines are dashed (default: false)."]
+            #[serde(rename = "rowLineDash")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub row_line_dash: Option<bool>,
+            #[doc = "Whether column lines are dashed (default: false)."]
+            #[serde(rename = "columnLineDash")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub column_line_dash: Option<bool>,
+            #[doc = "The row gap highlight fill color (default: transparent)."]
+            #[serde(rename = "rowGapColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub row_gap_color: Option<super::dom::Rgba>,
+            #[doc = "The row gap hatching fill color (default: transparent)."]
+            #[serde(rename = "rowHatchColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub row_hatch_color: Option<super::dom::Rgba>,
+            #[doc = "The column gap highlight fill color (default: transparent)."]
+            #[serde(rename = "columnGapColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub column_gap_color: Option<super::dom::Rgba>,
+            #[doc = "The column gap hatching fill color (default: transparent)."]
+            #[serde(rename = "columnHatchColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub column_hatch_color: Option<super::dom::Rgba>,
+            #[doc = "The named grid areas border color (Default: transparent)."]
+            #[serde(rename = "areaBorderColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub area_border_color: Option<super::dom::Rgba>,
+            #[doc = "The grid container background color (Default: transparent)."]
+            #[serde(rename = "gridBackgroundColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub grid_background_color: Option<super::dom::Rgba>,
+        }
+        impl GridHighlightConfig {
+            pub fn builder() -> GridHighlightConfigBuilder {
+                GridHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GridHighlightConfigBuilder {
+            show_grid_extension_lines: Option<bool>,
+            show_positive_line_numbers: Option<bool>,
+            show_negative_line_numbers: Option<bool>,
+            show_area_names: Option<bool>,
+            show_line_names: Option<bool>,
+            show_track_sizes: Option<bool>,
+            grid_border_color: Option<super::dom::Rgba>,
+            row_line_color: Option<super::dom::Rgba>,
+            column_line_color: Option<super::dom::Rgba>,
+            grid_border_dash: Option<bool>,
+            row_line_dash: Option<bool>,
+            column_line_dash: Option<bool>,
+            row_gap_color: Option<super::dom::Rgba>,
+            row_hatch_color: Option<super::dom::Rgba>,
+            column_gap_color: Option<super::dom::Rgba>,
+            column_hatch_color: Option<super::dom::Rgba>,
+            area_border_color: Option<super::dom::Rgba>,
+            grid_background_color: Option<super::dom::Rgba>,
+        }
+        impl GridHighlightConfigBuilder {
+            pub fn show_grid_extension_lines(
+                mut self,
+                show_grid_extension_lines: impl Into<bool>,
+            ) -> Self {
+                self.show_grid_extension_lines = Some(show_grid_extension_lines.into());
+                self
+            }
+            pub fn show_positive_line_numbers(
+                mut self,
+                show_positive_line_numbers: impl Into<bool>,
+            ) -> Self {
+                self.show_positive_line_numbers = Some(show_positive_line_numbers.into());
+                self
+            }
+            pub fn show_negative_line_numbers(
+                mut self,
+                show_negative_line_numbers: impl Into<bool>,
+            ) -> Self {
+                self.show_negative_line_numbers = Some(show_negative_line_numbers.into());
+                self
+            }
+            pub fn show_area_names(mut self, show_area_names: impl Into<bool>) -> Self {
+                self.show_area_names = Some(show_area_names.into());
+                self
+            }
+            pub fn show_line_names(mut self, show_line_names: impl Into<bool>) -> Self {
+                self.show_line_names = Some(show_line_names.into());
+                self
+            }
+            pub fn show_track_sizes(mut self, show_track_sizes: impl Into<bool>) -> Self {
+                self.show_track_sizes = Some(show_track_sizes.into());
+                self
+            }
+            pub fn grid_border_color(
+                mut self,
+                grid_border_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.grid_border_color = Some(grid_border_color.into());
+                self
+            }
+            pub fn row_line_color(mut self, row_line_color: impl Into<super::dom::Rgba>) -> Self {
+                self.row_line_color = Some(row_line_color.into());
+                self
+            }
+            pub fn column_line_color(
+                mut self,
+                column_line_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.column_line_color = Some(column_line_color.into());
+                self
+            }
+            pub fn grid_border_dash(mut self, grid_border_dash: impl Into<bool>) -> Self {
+                self.grid_border_dash = Some(grid_border_dash.into());
+                self
+            }
+            pub fn row_line_dash(mut self, row_line_dash: impl Into<bool>) -> Self {
+                self.row_line_dash = Some(row_line_dash.into());
+                self
+            }
+            pub fn column_line_dash(mut self, column_line_dash: impl Into<bool>) -> Self {
+                self.column_line_dash = Some(column_line_dash.into());
+                self
+            }
+            pub fn row_gap_color(mut self, row_gap_color: impl Into<super::dom::Rgba>) -> Self {
+                self.row_gap_color = Some(row_gap_color.into());
+                self
+            }
+            pub fn row_hatch_color(mut self, row_hatch_color: impl Into<super::dom::Rgba>) -> Self {
+                self.row_hatch_color = Some(row_hatch_color.into());
+                self
+            }
+            pub fn column_gap_color(
+                mut self,
+                column_gap_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.column_gap_color = Some(column_gap_color.into());
+                self
+            }
+            pub fn column_hatch_color(
+                mut self,
+                column_hatch_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.column_hatch_color = Some(column_hatch_color.into());
+                self
+            }
+            pub fn area_border_color(
+                mut self,
+                area_border_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.area_border_color = Some(area_border_color.into());
+                self
+            }
+            pub fn grid_background_color(
+                mut self,
+                grid_background_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.grid_background_color = Some(grid_background_color.into());
+                self
+            }
+            pub fn build(self) -> GridHighlightConfig {
+                GridHighlightConfig {
+                    show_grid_extension_lines: self.show_grid_extension_lines,
+                    show_positive_line_numbers: self.show_positive_line_numbers,
+                    show_negative_line_numbers: self.show_negative_line_numbers,
+                    show_area_names: self.show_area_names,
+                    show_line_names: self.show_line_names,
+                    show_track_sizes: self.show_track_sizes,
+                    grid_border_color: self.grid_border_color,
+                    row_line_color: self.row_line_color,
+                    column_line_color: self.column_line_color,
+                    grid_border_dash: self.grid_border_dash,
+                    row_line_dash: self.row_line_dash,
+                    column_line_dash: self.column_line_dash,
+                    row_gap_color: self.row_gap_color,
+                    row_hatch_color: self.row_hatch_color,
+                    column_gap_color: self.column_gap_color,
+                    column_hatch_color: self.column_hatch_color,
+                    area_border_color: self.area_border_color,
+                    grid_background_color: self.grid_background_color,
+                }
+            }
+        }
+        impl GridHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.GridHighlightConfig";
+        }
+        #[doc = "Configuration data for the highlighting of Flex container elements.\n[FlexContainerHighlightConfig](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#type-FlexContainerHighlightConfig)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct FlexContainerHighlightConfig {
+            #[doc = "The style of the container border"]
+            #[serde(rename = "containerBorder")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub container_border: Option<LineStyle>,
+            #[doc = "The style of the separator between lines"]
+            #[serde(rename = "lineSeparator")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub line_separator: Option<LineStyle>,
+            #[doc = "The style of the separator between items"]
+            #[serde(rename = "itemSeparator")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub item_separator: Option<LineStyle>,
+            #[doc = "Style of content-distribution space on the main axis (justify-content)."]
+            #[serde(rename = "mainDistributedSpace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub main_distributed_space: Option<BoxStyle>,
+            #[doc = "Style of content-distribution space on the cross axis (align-content)."]
+            #[serde(rename = "crossDistributedSpace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cross_distributed_space: Option<BoxStyle>,
+            #[doc = "Style of empty space caused by row gaps (gap/row-gap)."]
+            #[serde(rename = "rowGapSpace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub row_gap_space: Option<BoxStyle>,
+            #[doc = "Style of empty space caused by columns gaps (gap/column-gap)."]
+            #[serde(rename = "columnGapSpace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub column_gap_space: Option<BoxStyle>,
+            #[doc = "Style of the self-alignment line (align-items)."]
+            #[serde(rename = "crossAlignment")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cross_alignment: Option<LineStyle>,
+        }
+        impl FlexContainerHighlightConfig {
+            pub fn builder() -> FlexContainerHighlightConfigBuilder {
+                FlexContainerHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FlexContainerHighlightConfigBuilder {
+            container_border: Option<LineStyle>,
+            line_separator: Option<LineStyle>,
+            item_separator: Option<LineStyle>,
+            main_distributed_space: Option<BoxStyle>,
+            cross_distributed_space: Option<BoxStyle>,
+            row_gap_space: Option<BoxStyle>,
+            column_gap_space: Option<BoxStyle>,
+            cross_alignment: Option<LineStyle>,
+        }
+        impl FlexContainerHighlightConfigBuilder {
+            pub fn container_border(mut self, container_border: impl Into<LineStyle>) -> Self {
+                self.container_border = Some(container_border.into());
+                self
+            }
+            pub fn line_separator(mut self, line_separator: impl Into<LineStyle>) -> Self {
+                self.line_separator = Some(line_separator.into());
+                self
+            }
+            pub fn item_separator(mut self, item_separator: impl Into<LineStyle>) -> Self {
+                self.item_separator = Some(item_separator.into());
+                self
+            }
+            pub fn main_distributed_space(
+                mut self,
+                main_distributed_space: impl Into<BoxStyle>,
+            ) -> Self {
+                self.main_distributed_space = Some(main_distributed_space.into());
+                self
+            }
+            pub fn cross_distributed_space(
+                mut self,
+                cross_distributed_space: impl Into<BoxStyle>,
+            ) -> Self {
+                self.cross_distributed_space = Some(cross_distributed_space.into());
+                self
+            }
+            pub fn row_gap_space(mut self, row_gap_space: impl Into<BoxStyle>) -> Self {
+                self.row_gap_space = Some(row_gap_space.into());
+                self
+            }
+            pub fn column_gap_space(mut self, column_gap_space: impl Into<BoxStyle>) -> Self {
+                self.column_gap_space = Some(column_gap_space.into());
+                self
+            }
+            pub fn cross_alignment(mut self, cross_alignment: impl Into<LineStyle>) -> Self {
+                self.cross_alignment = Some(cross_alignment.into());
+                self
+            }
+            pub fn build(self) -> FlexContainerHighlightConfig {
+                FlexContainerHighlightConfig {
+                    container_border: self.container_border,
+                    line_separator: self.line_separator,
+                    item_separator: self.item_separator,
+                    main_distributed_space: self.main_distributed_space,
+                    cross_distributed_space: self.cross_distributed_space,
+                    row_gap_space: self.row_gap_space,
+                    column_gap_space: self.column_gap_space,
+                    cross_alignment: self.cross_alignment,
+                }
+            }
+        }
+        impl FlexContainerHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.FlexContainerHighlightConfig";
+        }
+        #[doc = "Configuration data for the highlighting of Flex item elements.\n[FlexItemHighlightConfig](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#type-FlexItemHighlightConfig)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct FlexItemHighlightConfig {
+            #[doc = "Style of the box representing the item's base size"]
+            #[serde(rename = "baseSizeBox")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub base_size_box: Option<BoxStyle>,
+            #[doc = "Style of the border around the box representing the item's base size"]
+            #[serde(rename = "baseSizeBorder")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub base_size_border: Option<LineStyle>,
+            #[doc = "Style of the arrow representing if the item grew or shrank"]
+            #[serde(rename = "flexibilityArrow")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub flexibility_arrow: Option<LineStyle>,
+        }
+        impl FlexItemHighlightConfig {
+            pub fn builder() -> FlexItemHighlightConfigBuilder {
+                FlexItemHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FlexItemHighlightConfigBuilder {
+            base_size_box: Option<BoxStyle>,
+            base_size_border: Option<LineStyle>,
+            flexibility_arrow: Option<LineStyle>,
+        }
+        impl FlexItemHighlightConfigBuilder {
+            pub fn base_size_box(mut self, base_size_box: impl Into<BoxStyle>) -> Self {
+                self.base_size_box = Some(base_size_box.into());
+                self
+            }
+            pub fn base_size_border(mut self, base_size_border: impl Into<LineStyle>) -> Self {
+                self.base_size_border = Some(base_size_border.into());
+                self
+            }
+            pub fn flexibility_arrow(mut self, flexibility_arrow: impl Into<LineStyle>) -> Self {
+                self.flexibility_arrow = Some(flexibility_arrow.into());
+                self
+            }
+            pub fn build(self) -> FlexItemHighlightConfig {
+                FlexItemHighlightConfig {
+                    base_size_box: self.base_size_box,
+                    base_size_border: self.base_size_border,
+                    flexibility_arrow: self.flexibility_arrow,
+                }
+            }
+        }
+        impl FlexItemHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.FlexItemHighlightConfig";
+        }
+        #[doc = "Style information for drawing a line.\n[LineStyle](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#type-LineStyle)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct LineStyle {
+            #[doc = "The color of the line (default: transparent)"]
+            #[serde(rename = "color")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub color: Option<super::dom::Rgba>,
+            #[doc = "The line pattern (default: solid)"]
+            #[serde(rename = "pattern")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub pattern: Option<LineStylePattern>,
+        }
+        #[doc = "The line pattern (default: solid)"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum LineStylePattern {
+            #[serde(rename = "dashed")]
+            Dashed,
+            #[serde(rename = "dotted")]
+            Dotted,
+        }
+        impl AsRef<str> for LineStylePattern {
+            fn as_ref(&self) -> &str {
+                match self {
+                    LineStylePattern::Dashed => "dashed",
+                    LineStylePattern::Dotted => "dotted",
+                }
+            }
+        }
+        impl ::std::str::FromStr for LineStylePattern {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "dashed" | "Dashed" => Ok(LineStylePattern::Dashed),
+                    "dotted" | "Dotted" => Ok(LineStylePattern::Dotted),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl LineStyle {
+            pub fn builder() -> LineStyleBuilder {
+                LineStyleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LineStyleBuilder {
+            color: Option<super::dom::Rgba>,
+            pattern: Option<LineStylePattern>,
+        }
+        impl LineStyleBuilder {
+            pub fn color(mut self, color: impl Into<super::dom::Rgba>) -> Self {
+                self.color = Some(color.into());
+                self
+            }
+            pub fn pattern(mut self, pattern: impl Into<LineStylePattern>) -> Self {
+                self.pattern = Some(pattern.into());
+                self
+            }
+            pub fn build(self) -> LineStyle {
+                LineStyle {
+                    color: self.color,
+                    pattern: self.pattern,
+                }
+            }
+        }
+        impl LineStyle {
+            pub const IDENTIFIER: &'static str = "Overlay.LineStyle";
+        }
+        #[doc = "Style information for drawing a box.\n[BoxStyle](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#type-BoxStyle)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct BoxStyle {
+            #[doc = "The background color for the box (default: transparent)"]
+            #[serde(rename = "fillColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub fill_color: Option<super::dom::Rgba>,
+            #[doc = "The hatching color for the box (default: transparent)"]
+            #[serde(rename = "hatchColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub hatch_color: Option<super::dom::Rgba>,
+        }
+        impl BoxStyle {
+            pub fn builder() -> BoxStyleBuilder {
+                BoxStyleBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BoxStyleBuilder {
+            fill_color: Option<super::dom::Rgba>,
+            hatch_color: Option<super::dom::Rgba>,
+        }
+        impl BoxStyleBuilder {
+            pub fn fill_color(mut self, fill_color: impl Into<super::dom::Rgba>) -> Self {
+                self.fill_color = Some(fill_color.into());
+                self
+            }
+            pub fn hatch_color(mut self, hatch_color: impl Into<super::dom::Rgba>) -> Self {
+                self.hatch_color = Some(hatch_color.into());
+                self
+            }
+            pub fn build(self) -> BoxStyle {
+                BoxStyle {
+                    fill_color: self.fill_color,
+                    hatch_color: self.hatch_color,
+                }
+            }
+        }
+        impl BoxStyle {
+            pub const IDENTIFIER: &'static str = "Overlay.BoxStyle";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ContrastAlgorithm {
+            #[serde(rename = "aa")]
+            Aa,
+            #[serde(rename = "aaa")]
+            Aaa,
+            #[serde(rename = "apca")]
+            Apca,
+        }
+        impl AsRef<str> for ContrastAlgorithm {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ContrastAlgorithm::Aa => "aa",
+                    ContrastAlgorithm::Aaa => "aaa",
+                    ContrastAlgorithm::Apca => "apca",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ContrastAlgorithm {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "aa" | "Aa" => Ok(ContrastAlgorithm::Aa),
+                    "aaa" | "Aaa" => Ok(ContrastAlgorithm::Aaa),
+                    "apca" | "Apca" => Ok(ContrastAlgorithm::Apca),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Configuration data for the highlighting of page elements.\n[HighlightConfig](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#type-HighlightConfig)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HighlightConfig {
+            #[doc = "Whether the node info tooltip should be shown (default: false)."]
+            #[serde(rename = "showInfo")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_info: Option<bool>,
+            #[doc = "Whether the node styles in the tooltip (default: false)."]
+            #[serde(rename = "showStyles")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_styles: Option<bool>,
+            #[doc = "Whether the rulers should be shown (default: false)."]
+            #[serde(rename = "showRulers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_rulers: Option<bool>,
+            #[doc = "Whether the a11y info should be shown (default: true)."]
+            #[serde(rename = "showAccessibilityInfo")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_accessibility_info: Option<bool>,
+            #[doc = "Whether the extension lines from node to the rulers should be shown (default: false)."]
+            #[serde(rename = "showExtensionLines")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_extension_lines: Option<bool>,
+            #[doc = "The content box highlight fill color (default: transparent)."]
+            #[serde(rename = "contentColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub content_color: Option<super::dom::Rgba>,
+            #[doc = "The padding highlight fill color (default: transparent)."]
+            #[serde(rename = "paddingColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub padding_color: Option<super::dom::Rgba>,
+            #[doc = "The border highlight fill color (default: transparent)."]
+            #[serde(rename = "borderColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub border_color: Option<super::dom::Rgba>,
+            #[doc = "The margin highlight fill color (default: transparent)."]
+            #[serde(rename = "marginColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub margin_color: Option<super::dom::Rgba>,
+            #[doc = "The event target element highlight fill color (default: transparent)."]
+            #[serde(rename = "eventTargetColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub event_target_color: Option<super::dom::Rgba>,
+            #[doc = "The shape outside fill color (default: transparent)."]
+            #[serde(rename = "shapeColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub shape_color: Option<super::dom::Rgba>,
+            #[doc = "The shape margin fill color (default: transparent)."]
+            #[serde(rename = "shapeMarginColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub shape_margin_color: Option<super::dom::Rgba>,
+            #[doc = "The grid layout color (default: transparent)."]
+            #[serde(rename = "cssGridColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub css_grid_color: Option<super::dom::Rgba>,
+            #[doc = "The color format used to format color styles (default: hex)."]
+            #[serde(rename = "colorFormat")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub color_format: Option<ColorFormat>,
+            #[doc = "The grid layout highlight configuration (default: all transparent)."]
+            #[serde(rename = "gridHighlightConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub grid_highlight_config: Option<GridHighlightConfig>,
+            #[doc = "The flex container highlight configuration (default: all transparent)."]
+            #[serde(rename = "flexContainerHighlightConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub flex_container_highlight_config: Option<FlexContainerHighlightConfig>,
+            #[doc = "The flex item highlight configuration (default: all transparent)."]
+            #[serde(rename = "flexItemHighlightConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub flex_item_highlight_config: Option<FlexItemHighlightConfig>,
+            #[doc = "The contrast algorithm to use for the contrast ratio (default: aa)."]
+            #[serde(rename = "contrastAlgorithm")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub contrast_algorithm: Option<ContrastAlgorithm>,
+            #[doc = "The container query container highlight configuration (default: all transparent)."]
+            #[serde(rename = "containerQueryContainerHighlightConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub container_query_container_highlight_config:
+                Option<ContainerQueryContainerHighlightConfig>,
+        }
+        impl HighlightConfig {
+            pub fn builder() -> HighlightConfigBuilder {
+                HighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HighlightConfigBuilder {
+            show_info: Option<bool>,
+            show_styles: Option<bool>,
+            show_rulers: Option<bool>,
+            show_accessibility_info: Option<bool>,
+            show_extension_lines: Option<bool>,
+            content_color: Option<super::dom::Rgba>,
+            padding_color: Option<super::dom::Rgba>,
+            border_color: Option<super::dom::Rgba>,
+            margin_color: Option<super::dom::Rgba>,
+            event_target_color: Option<super::dom::Rgba>,
+            shape_color: Option<super::dom::Rgba>,
+            shape_margin_color: Option<super::dom::Rgba>,
+            css_grid_color: Option<super::dom::Rgba>,
+            color_format: Option<ColorFormat>,
+            grid_highlight_config: Option<GridHighlightConfig>,
+            flex_container_highlight_config: Option<FlexContainerHighlightConfig>,
+            flex_item_highlight_config: Option<FlexItemHighlightConfig>,
+            contrast_algorithm: Option<ContrastAlgorithm>,
+            container_query_container_highlight_config:
+                Option<ContainerQueryContainerHighlightConfig>,
+        }
+        impl HighlightConfigBuilder {
+            pub fn show_info(mut self, show_info: impl Into<bool>) -> Self {
+                self.show_info = Some(show_info.into());
+                self
+            }
+            pub fn show_styles(mut self, show_styles: impl Into<bool>) -> Self {
+                self.show_styles = Some(show_styles.into());
+                self
+            }
+            pub fn show_rulers(mut self, show_rulers: impl Into<bool>) -> Self {
+                self.show_rulers = Some(show_rulers.into());
+                self
+            }
+            pub fn show_accessibility_info(
+                mut self,
+                show_accessibility_info: impl Into<bool>,
+            ) -> Self {
+                self.show_accessibility_info = Some(show_accessibility_info.into());
+                self
+            }
+            pub fn show_extension_lines(mut self, show_extension_lines: impl Into<bool>) -> Self {
+                self.show_extension_lines = Some(show_extension_lines.into());
+                self
+            }
+            pub fn content_color(mut self, content_color: impl Into<super::dom::Rgba>) -> Self {
+                self.content_color = Some(content_color.into());
+                self
+            }
+            pub fn padding_color(mut self, padding_color: impl Into<super::dom::Rgba>) -> Self {
+                self.padding_color = Some(padding_color.into());
+                self
+            }
+            pub fn border_color(mut self, border_color: impl Into<super::dom::Rgba>) -> Self {
+                self.border_color = Some(border_color.into());
+                self
+            }
+            pub fn margin_color(mut self, margin_color: impl Into<super::dom::Rgba>) -> Self {
+                self.margin_color = Some(margin_color.into());
+                self
+            }
+            pub fn event_target_color(
+                mut self,
+                event_target_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.event_target_color = Some(event_target_color.into());
+                self
+            }
+            pub fn shape_color(mut self, shape_color: impl Into<super::dom::Rgba>) -> Self {
+                self.shape_color = Some(shape_color.into());
+                self
+            }
+            pub fn shape_margin_color(
+                mut self,
+                shape_margin_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.shape_margin_color = Some(shape_margin_color.into());
+                self
+            }
+            pub fn css_grid_color(mut self, css_grid_color: impl Into<super::dom::Rgba>) -> Self {
+                self.css_grid_color = Some(css_grid_color.into());
+                self
+            }
+            pub fn color_format(mut self, color_format: impl Into<ColorFormat>) -> Self {
+                self.color_format = Some(color_format.into());
+                self
+            }
+            pub fn grid_highlight_config(
+                mut self,
+                grid_highlight_config: impl Into<GridHighlightConfig>,
+            ) -> Self {
+                self.grid_highlight_config = Some(grid_highlight_config.into());
+                self
+            }
+            pub fn flex_container_highlight_config(
+                mut self,
+                flex_container_highlight_config: impl Into<FlexContainerHighlightConfig>,
+            ) -> Self {
+                self.flex_container_highlight_config = Some(flex_container_highlight_config.into());
+                self
+            }
+            pub fn flex_item_highlight_config(
+                mut self,
+                flex_item_highlight_config: impl Into<FlexItemHighlightConfig>,
+            ) -> Self {
+                self.flex_item_highlight_config = Some(flex_item_highlight_config.into());
+                self
+            }
+            pub fn contrast_algorithm(
+                mut self,
+                contrast_algorithm: impl Into<ContrastAlgorithm>,
+            ) -> Self {
+                self.contrast_algorithm = Some(contrast_algorithm.into());
+                self
+            }
+            pub fn container_query_container_highlight_config(
+                mut self,
+                container_query_container_highlight_config: impl Into<
+                    ContainerQueryContainerHighlightConfig,
+                >,
+            ) -> Self {
+                self.container_query_container_highlight_config =
+                    Some(container_query_container_highlight_config.into());
+                self
+            }
+            pub fn build(self) -> HighlightConfig {
+                HighlightConfig {
+                    show_info: self.show_info,
+                    show_styles: self.show_styles,
+                    show_rulers: self.show_rulers,
+                    show_accessibility_info: self.show_accessibility_info,
+                    show_extension_lines: self.show_extension_lines,
+                    content_color: self.content_color,
+                    padding_color: self.padding_color,
+                    border_color: self.border_color,
+                    margin_color: self.margin_color,
+                    event_target_color: self.event_target_color,
+                    shape_color: self.shape_color,
+                    shape_margin_color: self.shape_margin_color,
+                    css_grid_color: self.css_grid_color,
+                    color_format: self.color_format,
+                    grid_highlight_config: self.grid_highlight_config,
+                    flex_container_highlight_config: self.flex_container_highlight_config,
+                    flex_item_highlight_config: self.flex_item_highlight_config,
+                    contrast_algorithm: self.contrast_algorithm,
+                    container_query_container_highlight_config: self
+                        .container_query_container_highlight_config,
+                }
+            }
+        }
+        impl HighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.HighlightConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ColorFormat {
+            #[serde(rename = "rgb")]
+            Rgb,
+            #[serde(rename = "hsl")]
+            Hsl,
+            #[serde(rename = "hwb")]
+            Hwb,
+            #[serde(rename = "hex")]
+            Hex,
+        }
+        impl AsRef<str> for ColorFormat {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ColorFormat::Rgb => "rgb",
+                    ColorFormat::Hsl => "hsl",
+                    ColorFormat::Hwb => "hwb",
+                    ColorFormat::Hex => "hex",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ColorFormat {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "rgb" | "Rgb" => Ok(ColorFormat::Rgb),
+                    "hsl" | "Hsl" => Ok(ColorFormat::Hsl),
+                    "hwb" | "Hwb" => Ok(ColorFormat::Hwb),
+                    "hex" | "Hex" => Ok(ColorFormat::Hex),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Configurations for Persistent Grid Highlight\n[GridNodeHighlightConfig](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#type-GridNodeHighlightConfig)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GridNodeHighlightConfig {
+            #[doc = "A descriptor for the highlight appearance."]
+            #[serde(rename = "gridHighlightConfig")]
+            pub grid_highlight_config: GridHighlightConfig,
+            #[doc = "Identifier of the node to highlight."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl GridNodeHighlightConfig {
+            pub fn new(
+                grid_highlight_config: impl Into<GridHighlightConfig>,
+                node_id: impl Into<super::dom::NodeId>,
+            ) -> Self {
+                Self {
+                    grid_highlight_config: grid_highlight_config.into(),
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GridNodeHighlightConfig {
+            pub fn builder() -> GridNodeHighlightConfigBuilder {
+                GridNodeHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GridNodeHighlightConfigBuilder {
+            grid_highlight_config: Option<GridHighlightConfig>,
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl GridNodeHighlightConfigBuilder {
+            pub fn grid_highlight_config(
+                mut self,
+                grid_highlight_config: impl Into<GridHighlightConfig>,
+            ) -> Self {
+                self.grid_highlight_config = Some(grid_highlight_config.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GridNodeHighlightConfig, String> {
+                Ok(GridNodeHighlightConfig {
+                    grid_highlight_config: self.grid_highlight_config.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(grid_highlight_config)
+                        )
+                    })?,
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GridNodeHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.GridNodeHighlightConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FlexNodeHighlightConfig {
+            #[doc = "A descriptor for the highlight appearance of flex containers."]
+            #[serde(rename = "flexContainerHighlightConfig")]
+            pub flex_container_highlight_config: FlexContainerHighlightConfig,
+            #[doc = "Identifier of the node to highlight."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl FlexNodeHighlightConfig {
+            pub fn new(
+                flex_container_highlight_config: impl Into<FlexContainerHighlightConfig>,
+                node_id: impl Into<super::dom::NodeId>,
+            ) -> Self {
+                Self {
+                    flex_container_highlight_config: flex_container_highlight_config.into(),
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl FlexNodeHighlightConfig {
+            pub fn builder() -> FlexNodeHighlightConfigBuilder {
+                FlexNodeHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FlexNodeHighlightConfigBuilder {
+            flex_container_highlight_config: Option<FlexContainerHighlightConfig>,
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl FlexNodeHighlightConfigBuilder {
+            pub fn flex_container_highlight_config(
+                mut self,
+                flex_container_highlight_config: impl Into<FlexContainerHighlightConfig>,
+            ) -> Self {
+                self.flex_container_highlight_config = Some(flex_container_highlight_config.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<FlexNodeHighlightConfig, String> {
+                Ok(FlexNodeHighlightConfig {
+                    flex_container_highlight_config: self
+                        .flex_container_highlight_config
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(flex_container_highlight_config)
+                            )
+                        })?,
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl FlexNodeHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.FlexNodeHighlightConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ScrollSnapContainerHighlightConfig {
+            #[doc = "The style of the snapport border (default: transparent)"]
+            #[serde(rename = "snapportBorder")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub snapport_border: Option<LineStyle>,
+            #[doc = "The style of the snap area border (default: transparent)"]
+            #[serde(rename = "snapAreaBorder")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub snap_area_border: Option<LineStyle>,
+            #[doc = "The margin highlight fill color (default: transparent)."]
+            #[serde(rename = "scrollMarginColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scroll_margin_color: Option<super::dom::Rgba>,
+            #[doc = "The padding highlight fill color (default: transparent)."]
+            #[serde(rename = "scrollPaddingColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scroll_padding_color: Option<super::dom::Rgba>,
+        }
+        impl ScrollSnapContainerHighlightConfig {
+            pub fn builder() -> ScrollSnapContainerHighlightConfigBuilder {
+                ScrollSnapContainerHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScrollSnapContainerHighlightConfigBuilder {
+            snapport_border: Option<LineStyle>,
+            snap_area_border: Option<LineStyle>,
+            scroll_margin_color: Option<super::dom::Rgba>,
+            scroll_padding_color: Option<super::dom::Rgba>,
+        }
+        impl ScrollSnapContainerHighlightConfigBuilder {
+            pub fn snapport_border(mut self, snapport_border: impl Into<LineStyle>) -> Self {
+                self.snapport_border = Some(snapport_border.into());
+                self
+            }
+            pub fn snap_area_border(mut self, snap_area_border: impl Into<LineStyle>) -> Self {
+                self.snap_area_border = Some(snap_area_border.into());
+                self
+            }
+            pub fn scroll_margin_color(
+                mut self,
+                scroll_margin_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.scroll_margin_color = Some(scroll_margin_color.into());
+                self
+            }
+            pub fn scroll_padding_color(
+                mut self,
+                scroll_padding_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.scroll_padding_color = Some(scroll_padding_color.into());
+                self
+            }
+            pub fn build(self) -> ScrollSnapContainerHighlightConfig {
+                ScrollSnapContainerHighlightConfig {
+                    snapport_border: self.snapport_border,
+                    snap_area_border: self.snap_area_border,
+                    scroll_margin_color: self.scroll_margin_color,
+                    scroll_padding_color: self.scroll_padding_color,
+                }
+            }
+        }
+        impl ScrollSnapContainerHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.ScrollSnapContainerHighlightConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScrollSnapHighlightConfig {
+            #[doc = "A descriptor for the highlight appearance of scroll snap containers."]
+            #[serde(rename = "scrollSnapContainerHighlightConfig")]
+            pub scroll_snap_container_highlight_config: ScrollSnapContainerHighlightConfig,
+            #[doc = "Identifier of the node to highlight."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl ScrollSnapHighlightConfig {
+            pub fn new(
+                scroll_snap_container_highlight_config: impl Into<ScrollSnapContainerHighlightConfig>,
+                node_id: impl Into<super::dom::NodeId>,
+            ) -> Self {
+                Self {
+                    scroll_snap_container_highlight_config: scroll_snap_container_highlight_config
+                        .into(),
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl ScrollSnapHighlightConfig {
+            pub fn builder() -> ScrollSnapHighlightConfigBuilder {
+                ScrollSnapHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScrollSnapHighlightConfigBuilder {
+            scroll_snap_container_highlight_config: Option<ScrollSnapContainerHighlightConfig>,
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl ScrollSnapHighlightConfigBuilder {
+            pub fn scroll_snap_container_highlight_config(
+                mut self,
+                scroll_snap_container_highlight_config: impl Into<ScrollSnapContainerHighlightConfig>,
+            ) -> Self {
+                self.scroll_snap_container_highlight_config =
+                    Some(scroll_snap_container_highlight_config.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ScrollSnapHighlightConfig, String> {
+                Ok(ScrollSnapHighlightConfig {
+                    scroll_snap_container_highlight_config: self
+                        .scroll_snap_container_highlight_config
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(scroll_snap_container_highlight_config)
+                            )
+                        })?,
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl ScrollSnapHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.ScrollSnapHighlightConfig";
+        }
+        #[doc = "Configuration for dual screen hinge\n[HingeConfig](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#type-HingeConfig)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct HingeConfig {
+            #[doc = "A rectangle represent hinge"]
+            #[serde(rename = "rect")]
+            pub rect: super::dom::Rect,
+            #[doc = "The content box highlight fill color (default: a dark color)."]
+            #[serde(rename = "contentColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub content_color: Option<super::dom::Rgba>,
+            #[doc = "The content box highlight outline color (default: transparent)."]
+            #[serde(rename = "outlineColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub outline_color: Option<super::dom::Rgba>,
+        }
+        impl HingeConfig {
+            pub fn new(rect: impl Into<super::dom::Rect>) -> Self {
+                Self {
+                    rect: rect.into(),
+                    content_color: None,
+                    outline_color: None,
+                }
+            }
+        }
+        impl HingeConfig {
+            pub fn builder() -> HingeConfigBuilder {
+                HingeConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HingeConfigBuilder {
+            rect: Option<super::dom::Rect>,
+            content_color: Option<super::dom::Rgba>,
+            outline_color: Option<super::dom::Rgba>,
+        }
+        impl HingeConfigBuilder {
+            pub fn rect(mut self, rect: impl Into<super::dom::Rect>) -> Self {
+                self.rect = Some(rect.into());
+                self
+            }
+            pub fn content_color(mut self, content_color: impl Into<super::dom::Rgba>) -> Self {
+                self.content_color = Some(content_color.into());
+                self
+            }
+            pub fn outline_color(mut self, outline_color: impl Into<super::dom::Rgba>) -> Self {
+                self.outline_color = Some(outline_color.into());
+                self
+            }
+            pub fn build(self) -> Result<HingeConfig, String> {
+                Ok(HingeConfig {
+                    rect: self.rect.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rect))
+                    })?,
+                    content_color: self.content_color,
+                    outline_color: self.outline_color,
+                })
+            }
+        }
+        impl HingeConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.HingeConfig";
+        }
+        #[doc = "Configuration for Window Controls Overlay\n[WindowControlsOverlayConfig](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#type-WindowControlsOverlayConfig)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct WindowControlsOverlayConfig {
+            #[doc = "Whether the title bar CSS should be shown when emulating the Window Controls Overlay."]
+            #[serde(rename = "showCSS")]
+            pub show_css: bool,
+            #[doc = "Selected platforms to show the overlay."]
+            #[serde(rename = "selectedPlatform")]
+            pub selected_platform: String,
+            #[doc = "The theme color defined in app manifest."]
+            #[serde(rename = "themeColor")]
+            pub theme_color: String,
+        }
+        impl WindowControlsOverlayConfig {
+            pub fn new(
+                show_css: impl Into<bool>,
+                selected_platform: impl Into<String>,
+                theme_color: impl Into<String>,
+            ) -> Self {
+                Self {
+                    show_css: show_css.into(),
+                    selected_platform: selected_platform.into(),
+                    theme_color: theme_color.into(),
+                }
+            }
+        }
+        impl WindowControlsOverlayConfig {
+            pub fn builder() -> WindowControlsOverlayConfigBuilder {
+                WindowControlsOverlayConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct WindowControlsOverlayConfigBuilder {
+            show_css: Option<bool>,
+            selected_platform: Option<String>,
+            theme_color: Option<String>,
+        }
+        impl WindowControlsOverlayConfigBuilder {
+            pub fn show_css(mut self, show_css: impl Into<bool>) -> Self {
+                self.show_css = Some(show_css.into());
+                self
+            }
+            pub fn selected_platform(mut self, selected_platform: impl Into<String>) -> Self {
+                self.selected_platform = Some(selected_platform.into());
+                self
+            }
+            pub fn theme_color(mut self, theme_color: impl Into<String>) -> Self {
+                self.theme_color = Some(theme_color.into());
+                self
+            }
+            pub fn build(self) -> Result<WindowControlsOverlayConfig, String> {
+                Ok(WindowControlsOverlayConfig {
+                    show_css: self.show_css.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(show_css))
+                    })?,
+                    selected_platform: self.selected_platform.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(selected_platform)
+                        )
+                    })?,
+                    theme_color: self.theme_color.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(theme_color))
+                    })?,
+                })
+            }
+        }
+        impl WindowControlsOverlayConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.WindowControlsOverlayConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ContainerQueryHighlightConfig {
+            #[doc = "A descriptor for the highlight appearance of container query containers."]
+            #[serde(rename = "containerQueryContainerHighlightConfig")]
+            pub container_query_container_highlight_config: ContainerQueryContainerHighlightConfig,
+            #[doc = "Identifier of the container node to highlight."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl ContainerQueryHighlightConfig {
+            pub fn new(
+                container_query_container_highlight_config: impl Into<
+                    ContainerQueryContainerHighlightConfig,
+                >,
+                node_id: impl Into<super::dom::NodeId>,
+            ) -> Self {
+                Self {
+                    container_query_container_highlight_config:
+                        container_query_container_highlight_config.into(),
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl ContainerQueryHighlightConfig {
+            pub fn builder() -> ContainerQueryHighlightConfigBuilder {
+                ContainerQueryHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ContainerQueryHighlightConfigBuilder {
+            container_query_container_highlight_config:
+                Option<ContainerQueryContainerHighlightConfig>,
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl ContainerQueryHighlightConfigBuilder {
+            pub fn container_query_container_highlight_config(
+                mut self,
+                container_query_container_highlight_config: impl Into<
+                    ContainerQueryContainerHighlightConfig,
+                >,
+            ) -> Self {
+                self.container_query_container_highlight_config =
+                    Some(container_query_container_highlight_config.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ContainerQueryHighlightConfig, String> {
+                Ok(ContainerQueryHighlightConfig {
+                    container_query_container_highlight_config: self
+                        .container_query_container_highlight_config
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(container_query_container_highlight_config)
+                            )
+                        })?,
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl ContainerQueryHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.ContainerQueryHighlightConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ContainerQueryContainerHighlightConfig {
+            #[doc = "The style of the container border."]
+            #[serde(rename = "containerBorder")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub container_border: Option<LineStyle>,
+            #[doc = "The style of the descendants' borders."]
+            #[serde(rename = "descendantBorder")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub descendant_border: Option<LineStyle>,
+        }
+        impl ContainerQueryContainerHighlightConfig {
+            pub fn builder() -> ContainerQueryContainerHighlightConfigBuilder {
+                ContainerQueryContainerHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ContainerQueryContainerHighlightConfigBuilder {
+            container_border: Option<LineStyle>,
+            descendant_border: Option<LineStyle>,
+        }
+        impl ContainerQueryContainerHighlightConfigBuilder {
+            pub fn container_border(mut self, container_border: impl Into<LineStyle>) -> Self {
+                self.container_border = Some(container_border.into());
+                self
+            }
+            pub fn descendant_border(mut self, descendant_border: impl Into<LineStyle>) -> Self {
+                self.descendant_border = Some(descendant_border.into());
+                self
+            }
+            pub fn build(self) -> ContainerQueryContainerHighlightConfig {
+                ContainerQueryContainerHighlightConfig {
+                    container_border: self.container_border,
+                    descendant_border: self.descendant_border,
+                }
+            }
+        }
+        impl ContainerQueryContainerHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.ContainerQueryContainerHighlightConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct IsolatedElementHighlightConfig {
+            #[doc = "A descriptor for the highlight appearance of an element in isolation mode."]
+            #[serde(rename = "isolationModeHighlightConfig")]
+            pub isolation_mode_highlight_config: IsolationModeHighlightConfig,
+            #[doc = "Identifier of the isolated element to highlight."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl IsolatedElementHighlightConfig {
+            pub fn new(
+                isolation_mode_highlight_config: impl Into<IsolationModeHighlightConfig>,
+                node_id: impl Into<super::dom::NodeId>,
+            ) -> Self {
+                Self {
+                    isolation_mode_highlight_config: isolation_mode_highlight_config.into(),
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl IsolatedElementHighlightConfig {
+            pub fn builder() -> IsolatedElementHighlightConfigBuilder {
+                IsolatedElementHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct IsolatedElementHighlightConfigBuilder {
+            isolation_mode_highlight_config: Option<IsolationModeHighlightConfig>,
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl IsolatedElementHighlightConfigBuilder {
+            pub fn isolation_mode_highlight_config(
+                mut self,
+                isolation_mode_highlight_config: impl Into<IsolationModeHighlightConfig>,
+            ) -> Self {
+                self.isolation_mode_highlight_config = Some(isolation_mode_highlight_config.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<IsolatedElementHighlightConfig, String> {
+                Ok(IsolatedElementHighlightConfig {
+                    isolation_mode_highlight_config: self
+                        .isolation_mode_highlight_config
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(isolation_mode_highlight_config)
+                            )
+                        })?,
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl IsolatedElementHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.IsolatedElementHighlightConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct IsolationModeHighlightConfig {
+            #[doc = "The fill color of the resizers (default: transparent)."]
+            #[serde(rename = "resizerColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub resizer_color: Option<super::dom::Rgba>,
+            #[doc = "The fill color for resizer handles (default: transparent)."]
+            #[serde(rename = "resizerHandleColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub resizer_handle_color: Option<super::dom::Rgba>,
+            #[doc = "The fill color for the mask covering non-isolated elements (default: transparent)."]
+            #[serde(rename = "maskColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub mask_color: Option<super::dom::Rgba>,
+        }
+        impl IsolationModeHighlightConfig {
+            pub fn builder() -> IsolationModeHighlightConfigBuilder {
+                IsolationModeHighlightConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct IsolationModeHighlightConfigBuilder {
+            resizer_color: Option<super::dom::Rgba>,
+            resizer_handle_color: Option<super::dom::Rgba>,
+            mask_color: Option<super::dom::Rgba>,
+        }
+        impl IsolationModeHighlightConfigBuilder {
+            pub fn resizer_color(mut self, resizer_color: impl Into<super::dom::Rgba>) -> Self {
+                self.resizer_color = Some(resizer_color.into());
+                self
+            }
+            pub fn resizer_handle_color(
+                mut self,
+                resizer_handle_color: impl Into<super::dom::Rgba>,
+            ) -> Self {
+                self.resizer_handle_color = Some(resizer_handle_color.into());
+                self
+            }
+            pub fn mask_color(mut self, mask_color: impl Into<super::dom::Rgba>) -> Self {
+                self.mask_color = Some(mask_color.into());
+                self
+            }
+            pub fn build(self) -> IsolationModeHighlightConfig {
+                IsolationModeHighlightConfig {
+                    resizer_color: self.resizer_color,
+                    resizer_handle_color: self.resizer_handle_color,
+                    mask_color: self.mask_color,
+                }
+            }
+        }
+        impl IsolationModeHighlightConfig {
+            pub const IDENTIFIER: &'static str = "Overlay.IsolationModeHighlightConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum InspectMode {
+            #[serde(rename = "searchForNode")]
+            SearchForNode,
+            #[serde(rename = "searchForUAShadowDOM")]
+            SearchForUaShadowDom,
+            #[serde(rename = "captureAreaScreenshot")]
+            CaptureAreaScreenshot,
+            #[serde(rename = "none")]
+            None,
+        }
+        impl AsRef<str> for InspectMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    InspectMode::SearchForNode => "searchForNode",
+                    InspectMode::SearchForUaShadowDom => "searchForUAShadowDOM",
+                    InspectMode::CaptureAreaScreenshot => "captureAreaScreenshot",
+                    InspectMode::None => "none",
+                }
+            }
+        }
+        impl ::std::str::FromStr for InspectMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "searchForNode" | "SearchForNode" | "searchfornode" => {
+                        Ok(InspectMode::SearchForNode)
+                    }
+                    "searchForUAShadowDOM" | "SearchForUaShadowDom" | "searchforuashadowdom" => {
+                        Ok(InspectMode::SearchForUaShadowDom)
+                    }
+                    "captureAreaScreenshot" | "CaptureAreaScreenshot" | "captureareascreenshot" => {
+                        Ok(InspectMode::CaptureAreaScreenshot)
+                    }
+                    "none" | "None" => Ok(InspectMode::None),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Disables domain notifications.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Overlay.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables domain notifications.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables domain notifications.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Overlay.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables domain notifications.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "For testing.\n[getHighlightObjectForTest](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-getHighlightObjectForTest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetHighlightObjectForTestParams {
+            #[doc = "Id of the node to get highlight object for."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+            #[doc = "Whether to include distance info."]
+            #[serde(rename = "includeDistance")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_distance: Option<bool>,
+            #[doc = "Whether to include style info."]
+            #[serde(rename = "includeStyle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_style: Option<bool>,
+            #[doc = "The color format to get config with (default: hex)."]
+            #[serde(rename = "colorFormat")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub color_format: Option<ColorFormat>,
+            #[doc = "Whether to show accessibility info (default: true)."]
+            #[serde(rename = "showAccessibilityInfo")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub show_accessibility_info: Option<bool>,
+        }
+        impl GetHighlightObjectForTestParams {
+            pub fn new(node_id: impl Into<super::dom::NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                    include_distance: None,
+                    include_style: None,
+                    color_format: None,
+                    show_accessibility_info: None,
+                }
+            }
+        }
+        impl GetHighlightObjectForTestParams {
+            pub fn builder() -> GetHighlightObjectForTestParamsBuilder {
+                GetHighlightObjectForTestParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetHighlightObjectForTestParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+            include_distance: Option<bool>,
+            include_style: Option<bool>,
+            color_format: Option<ColorFormat>,
+            show_accessibility_info: Option<bool>,
+        }
+        impl GetHighlightObjectForTestParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn include_distance(mut self, include_distance: impl Into<bool>) -> Self {
+                self.include_distance = Some(include_distance.into());
+                self
+            }
+            pub fn include_style(mut self, include_style: impl Into<bool>) -> Self {
+                self.include_style = Some(include_style.into());
+                self
+            }
+            pub fn color_format(mut self, color_format: impl Into<ColorFormat>) -> Self {
+                self.color_format = Some(color_format.into());
+                self
+            }
+            pub fn show_accessibility_info(
+                mut self,
+                show_accessibility_info: impl Into<bool>,
+            ) -> Self {
+                self.show_accessibility_info = Some(show_accessibility_info.into());
+                self
+            }
+            pub fn build(self) -> Result<GetHighlightObjectForTestParams, String> {
+                Ok(GetHighlightObjectForTestParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    include_distance: self.include_distance,
+                    include_style: self.include_style,
+                    color_format: self.color_format,
+                    show_accessibility_info: self.show_accessibility_info,
+                })
+            }
+        }
+        impl GetHighlightObjectForTestParams {
+            pub const IDENTIFIER: &'static str = "Overlay.getHighlightObjectForTest";
+        }
+        impl chromiumoxide_types::Method for GetHighlightObjectForTestParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetHighlightObjectForTestParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "For testing.\n[getHighlightObjectForTest](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-getHighlightObjectForTest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetHighlightObjectForTestReturns {
+            #[doc = "Highlight data for the node."]
+            #[serde(rename = "highlight")]
+            pub highlight: serde_json::Value,
+        }
+        impl GetHighlightObjectForTestReturns {
+            pub fn new(highlight: impl Into<serde_json::Value>) -> Self {
+                Self {
+                    highlight: highlight.into(),
+                }
+            }
+        }
+        impl GetHighlightObjectForTestReturns {
+            pub fn builder() -> GetHighlightObjectForTestReturnsBuilder {
+                GetHighlightObjectForTestReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetHighlightObjectForTestReturnsBuilder {
+            highlight: Option<serde_json::Value>,
+        }
+        impl GetHighlightObjectForTestReturnsBuilder {
+            pub fn highlight(mut self, highlight: impl Into<serde_json::Value>) -> Self {
+                self.highlight = Some(highlight.into());
+                self
+            }
+            pub fn build(self) -> Result<GetHighlightObjectForTestReturns, String> {
+                Ok(GetHighlightObjectForTestReturns {
+                    highlight: self.highlight.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(highlight))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetHighlightObjectForTestParams {
+            type Response = GetHighlightObjectForTestReturns;
+        }
+        #[doc = "For Persistent Grid testing.\n[getGridHighlightObjectsForTest](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-getGridHighlightObjectsForTest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetGridHighlightObjectsForTestParams {
+            #[doc = "Ids of the node to get highlight object for."]
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<super::dom::NodeId>,
+        }
+        impl GetGridHighlightObjectsForTestParams {
+            pub fn new(node_ids: Vec<super::dom::NodeId>) -> Self {
+                Self { node_ids }
+            }
+        }
+        impl GetGridHighlightObjectsForTestParams {
+            pub fn builder() -> GetGridHighlightObjectsForTestParamsBuilder {
+                GetGridHighlightObjectsForTestParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetGridHighlightObjectsForTestParamsBuilder {
+            node_ids: Option<Vec<super::dom::NodeId>>,
+        }
+        impl GetGridHighlightObjectsForTestParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                v.push(node_id.into());
+                self
+            }
+            pub fn node_ids<I, S>(mut self, node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::dom::NodeId>,
+            {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                for val in node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetGridHighlightObjectsForTestParams, String> {
+                Ok(GetGridHighlightObjectsForTestParams {
+                    node_ids: self.node_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_ids))
+                    })?,
+                })
+            }
+        }
+        impl GetGridHighlightObjectsForTestParams {
+            pub const IDENTIFIER: &'static str = "Overlay.getGridHighlightObjectsForTest";
+        }
+        impl chromiumoxide_types::Method for GetGridHighlightObjectsForTestParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetGridHighlightObjectsForTestParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "For Persistent Grid testing.\n[getGridHighlightObjectsForTest](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-getGridHighlightObjectsForTest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetGridHighlightObjectsForTestReturns {
+            #[doc = "Grid Highlight data for the node ids provided."]
+            #[serde(rename = "highlights")]
+            pub highlights: serde_json::Value,
+        }
+        impl GetGridHighlightObjectsForTestReturns {
+            pub fn new(highlights: impl Into<serde_json::Value>) -> Self {
+                Self {
+                    highlights: highlights.into(),
+                }
+            }
+        }
+        impl GetGridHighlightObjectsForTestReturns {
+            pub fn builder() -> GetGridHighlightObjectsForTestReturnsBuilder {
+                GetGridHighlightObjectsForTestReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetGridHighlightObjectsForTestReturnsBuilder {
+            highlights: Option<serde_json::Value>,
+        }
+        impl GetGridHighlightObjectsForTestReturnsBuilder {
+            pub fn highlights(mut self, highlights: impl Into<serde_json::Value>) -> Self {
+                self.highlights = Some(highlights.into());
+                self
+            }
+            pub fn build(self) -> Result<GetGridHighlightObjectsForTestReturns, String> {
+                Ok(GetGridHighlightObjectsForTestReturns {
+                    highlights: self.highlights.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(highlights))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetGridHighlightObjectsForTestParams {
+            type Response = GetGridHighlightObjectsForTestReturns;
+        }
+        #[doc = "For Source Order Viewer testing.\n[getSourceOrderHighlightObjectForTest](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-getSourceOrderHighlightObjectForTest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSourceOrderHighlightObjectForTestParams {
+            #[doc = "Id of the node to highlight."]
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl GetSourceOrderHighlightObjectForTestParams {
+            pub fn new(node_id: impl Into<super::dom::NodeId>) -> Self {
+                Self {
+                    node_id: node_id.into(),
+                }
+            }
+        }
+        impl GetSourceOrderHighlightObjectForTestParams {
+            pub fn builder() -> GetSourceOrderHighlightObjectForTestParamsBuilder {
+                GetSourceOrderHighlightObjectForTestParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSourceOrderHighlightObjectForTestParamsBuilder {
+            node_id: Option<super::dom::NodeId>,
+        }
+        impl GetSourceOrderHighlightObjectForTestParamsBuilder {
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetSourceOrderHighlightObjectForTestParams, String> {
+                Ok(GetSourceOrderHighlightObjectForTestParams {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                })
+            }
+        }
+        impl GetSourceOrderHighlightObjectForTestParams {
+            pub const IDENTIFIER: &'static str = "Overlay.getSourceOrderHighlightObjectForTest";
+        }
+        impl chromiumoxide_types::Method for GetSourceOrderHighlightObjectForTestParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetSourceOrderHighlightObjectForTestParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "For Source Order Viewer testing.\n[getSourceOrderHighlightObjectForTest](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-getSourceOrderHighlightObjectForTest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSourceOrderHighlightObjectForTestReturns {
+            #[doc = "Source order highlight data for the node id provided."]
+            #[serde(rename = "highlight")]
+            pub highlight: serde_json::Value,
+        }
+        impl GetSourceOrderHighlightObjectForTestReturns {
+            pub fn new(highlight: impl Into<serde_json::Value>) -> Self {
+                Self {
+                    highlight: highlight.into(),
+                }
+            }
+        }
+        impl GetSourceOrderHighlightObjectForTestReturns {
+            pub fn builder() -> GetSourceOrderHighlightObjectForTestReturnsBuilder {
+                GetSourceOrderHighlightObjectForTestReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSourceOrderHighlightObjectForTestReturnsBuilder {
+            highlight: Option<serde_json::Value>,
+        }
+        impl GetSourceOrderHighlightObjectForTestReturnsBuilder {
+            pub fn highlight(mut self, highlight: impl Into<serde_json::Value>) -> Self {
+                self.highlight = Some(highlight.into());
+                self
+            }
+            pub fn build(self) -> Result<GetSourceOrderHighlightObjectForTestReturns, String> {
+                Ok(GetSourceOrderHighlightObjectForTestReturns {
+                    highlight: self.highlight.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(highlight))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetSourceOrderHighlightObjectForTestParams {
+            type Response = GetSourceOrderHighlightObjectForTestReturns;
+        }
+        #[doc = "Hides any highlight.\n[hideHighlight](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-hideHighlight)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HideHighlightParams {}
+        impl HideHighlightParams {
+            pub const IDENTIFIER: &'static str = "Overlay.hideHighlight";
+        }
+        impl chromiumoxide_types::Method for HideHighlightParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for HideHighlightParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Hides any highlight.\n[hideHighlight](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-hideHighlight)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HideHighlightReturns {}
+        impl chromiumoxide_types::Command for HideHighlightParams {
+            type Response = HideHighlightReturns;
+        }
+        #[doc = "Highlights DOM node with given id or with the given JavaScript object wrapper. Either nodeId or\nobjectId must be specified.\n[highlightNode](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-highlightNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct HighlightNodeParams {
+            #[doc = "A descriptor for the highlight appearance."]
+            #[serde(rename = "highlightConfig")]
+            pub highlight_config: HighlightConfig,
+            #[doc = "Identifier of the node to highlight."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<super::dom::NodeId>,
+            #[doc = "Identifier of the backend node to highlight."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "JavaScript object id of the node to be highlighted."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            #[doc = "Selectors to highlight relevant nodes."]
+            #[serde(rename = "selector")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub selector: Option<String>,
+        }
+        impl HighlightNodeParams {
+            pub fn new(highlight_config: impl Into<HighlightConfig>) -> Self {
+                Self {
+                    highlight_config: highlight_config.into(),
+                    node_id: None,
+                    backend_node_id: None,
+                    object_id: None,
+                    selector: None,
+                }
+            }
+        }
+        impl HighlightNodeParams {
+            pub fn builder() -> HighlightNodeParamsBuilder {
+                HighlightNodeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HighlightNodeParamsBuilder {
+            highlight_config: Option<HighlightConfig>,
+            node_id: Option<super::dom::NodeId>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+            selector: Option<String>,
+        }
+        impl HighlightNodeParamsBuilder {
+            pub fn highlight_config(
+                mut self,
+                highlight_config: impl Into<HighlightConfig>,
+            ) -> Self {
+                self.highlight_config = Some(highlight_config.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn selector(mut self, selector: impl Into<String>) -> Self {
+                self.selector = Some(selector.into());
+                self
+            }
+            pub fn build(self) -> Result<HighlightNodeParams, String> {
+                Ok(HighlightNodeParams {
+                    highlight_config: self.highlight_config.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(highlight_config)
+                        )
+                    })?,
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                    selector: self.selector,
+                })
+            }
+        }
+        impl HighlightNodeParams {
+            pub const IDENTIFIER: &'static str = "Overlay.highlightNode";
+        }
+        impl chromiumoxide_types::Method for HighlightNodeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for HighlightNodeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Highlights DOM node with given id or with the given JavaScript object wrapper. Either nodeId or\nobjectId must be specified.\n[highlightNode](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-highlightNode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HighlightNodeReturns {}
+        impl chromiumoxide_types::Command for HighlightNodeParams {
+            type Response = HighlightNodeReturns;
+        }
+        #[doc = "Highlights given quad. Coordinates are absolute with respect to the main frame viewport.\n[highlightQuad](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-highlightQuad)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct HighlightQuadParams {
+            #[doc = "Quad to highlight"]
+            #[serde(rename = "quad")]
+            pub quad: super::dom::Quad,
+            #[doc = "The highlight fill color (default: transparent)."]
+            #[serde(rename = "color")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub color: Option<super::dom::Rgba>,
+            #[doc = "The highlight outline color (default: transparent)."]
+            #[serde(rename = "outlineColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub outline_color: Option<super::dom::Rgba>,
+        }
+        impl HighlightQuadParams {
+            pub fn new(quad: impl Into<super::dom::Quad>) -> Self {
+                Self {
+                    quad: quad.into(),
+                    color: None,
+                    outline_color: None,
+                }
+            }
+        }
+        impl HighlightQuadParams {
+            pub fn builder() -> HighlightQuadParamsBuilder {
+                HighlightQuadParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HighlightQuadParamsBuilder {
+            quad: Option<super::dom::Quad>,
+            color: Option<super::dom::Rgba>,
+            outline_color: Option<super::dom::Rgba>,
+        }
+        impl HighlightQuadParamsBuilder {
+            pub fn quad(mut self, quad: impl Into<super::dom::Quad>) -> Self {
+                self.quad = Some(quad.into());
+                self
+            }
+            pub fn color(mut self, color: impl Into<super::dom::Rgba>) -> Self {
+                self.color = Some(color.into());
+                self
+            }
+            pub fn outline_color(mut self, outline_color: impl Into<super::dom::Rgba>) -> Self {
+                self.outline_color = Some(outline_color.into());
+                self
+            }
+            pub fn build(self) -> Result<HighlightQuadParams, String> {
+                Ok(HighlightQuadParams {
+                    quad: self.quad.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(quad))
+                    })?,
+                    color: self.color,
+                    outline_color: self.outline_color,
+                })
+            }
+        }
+        impl HighlightQuadParams {
+            pub const IDENTIFIER: &'static str = "Overlay.highlightQuad";
+        }
+        impl chromiumoxide_types::Method for HighlightQuadParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for HighlightQuadParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Highlights given quad. Coordinates are absolute with respect to the main frame viewport.\n[highlightQuad](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-highlightQuad)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HighlightQuadReturns {}
+        impl chromiumoxide_types::Command for HighlightQuadParams {
+            type Response = HighlightQuadReturns;
+        }
+        #[doc = "Highlights given rectangle. Coordinates are absolute with respect to the main frame viewport.\nIssue: the method does not handle device pixel ratio (DPR) correctly.\nThe coordinates currently have to be adjusted by the client\nif DPR is not 1 (see crbug.com/437807128).\n[highlightRect](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-highlightRect)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct HighlightRectParams {
+            #[doc = "X coordinate"]
+            #[serde(rename = "x")]
+            pub x: i64,
+            #[doc = "Y coordinate"]
+            #[serde(rename = "y")]
+            pub y: i64,
+            #[doc = "Rectangle width"]
+            #[serde(rename = "width")]
+            pub width: i64,
+            #[doc = "Rectangle height"]
+            #[serde(rename = "height")]
+            pub height: i64,
+            #[doc = "The highlight fill color (default: transparent)."]
+            #[serde(rename = "color")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub color: Option<super::dom::Rgba>,
+            #[doc = "The highlight outline color (default: transparent)."]
+            #[serde(rename = "outlineColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub outline_color: Option<super::dom::Rgba>,
+        }
+        impl HighlightRectParams {
+            pub fn new(
+                x: impl Into<i64>,
+                y: impl Into<i64>,
+                width: impl Into<i64>,
+                height: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    x: x.into(),
+                    y: y.into(),
+                    width: width.into(),
+                    height: height.into(),
+                    color: None,
+                    outline_color: None,
+                }
+            }
+        }
+        impl HighlightRectParams {
+            pub fn builder() -> HighlightRectParamsBuilder {
+                HighlightRectParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HighlightRectParamsBuilder {
+            x: Option<i64>,
+            y: Option<i64>,
+            width: Option<i64>,
+            height: Option<i64>,
+            color: Option<super::dom::Rgba>,
+            outline_color: Option<super::dom::Rgba>,
+        }
+        impl HighlightRectParamsBuilder {
+            pub fn x(mut self, x: impl Into<i64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<i64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn width(mut self, width: impl Into<i64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<i64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn color(mut self, color: impl Into<super::dom::Rgba>) -> Self {
+                self.color = Some(color.into());
+                self
+            }
+            pub fn outline_color(mut self, outline_color: impl Into<super::dom::Rgba>) -> Self {
+                self.outline_color = Some(outline_color.into());
+                self
+            }
+            pub fn build(self) -> Result<HighlightRectParams, String> {
+                Ok(HighlightRectParams {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    width: self.width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(width))
+                    })?,
+                    height: self.height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(height))
+                    })?,
+                    color: self.color,
+                    outline_color: self.outline_color,
+                })
+            }
+        }
+        impl HighlightRectParams {
+            pub const IDENTIFIER: &'static str = "Overlay.highlightRect";
+        }
+        impl chromiumoxide_types::Method for HighlightRectParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for HighlightRectParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Highlights given rectangle. Coordinates are absolute with respect to the main frame viewport.\nIssue: the method does not handle device pixel ratio (DPR) correctly.\nThe coordinates currently have to be adjusted by the client\nif DPR is not 1 (see crbug.com/437807128).\n[highlightRect](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-highlightRect)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HighlightRectReturns {}
+        impl chromiumoxide_types::Command for HighlightRectParams {
+            type Response = HighlightRectReturns;
+        }
+        #[doc = "Highlights the source order of the children of the DOM node with given id or with the given\nJavaScript object wrapper. Either nodeId or objectId must be specified.\n[highlightSourceOrder](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-highlightSourceOrder)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct HighlightSourceOrderParams {
+            #[doc = "A descriptor for the appearance of the overlay drawing."]
+            #[serde(rename = "sourceOrderConfig")]
+            pub source_order_config: SourceOrderConfig,
+            #[doc = "Identifier of the node to highlight."]
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<super::dom::NodeId>,
+            #[doc = "Identifier of the backend node to highlight."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+            #[doc = "JavaScript object id of the node to be highlighted."]
+            #[serde(rename = "objectId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl HighlightSourceOrderParams {
+            pub fn new(source_order_config: impl Into<SourceOrderConfig>) -> Self {
+                Self {
+                    source_order_config: source_order_config.into(),
+                    node_id: None,
+                    backend_node_id: None,
+                    object_id: None,
+                }
+            }
+        }
+        impl HighlightSourceOrderParams {
+            pub fn builder() -> HighlightSourceOrderParamsBuilder {
+                HighlightSourceOrderParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HighlightSourceOrderParamsBuilder {
+            source_order_config: Option<SourceOrderConfig>,
+            node_id: Option<super::dom::NodeId>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+            object_id: Option<super::super::js_protocol::runtime::RemoteObjectId>,
+        }
+        impl HighlightSourceOrderParamsBuilder {
+            pub fn source_order_config(
+                mut self,
+                source_order_config: impl Into<SourceOrderConfig>,
+            ) -> Self {
+                self.source_order_config = Some(source_order_config.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::NodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn object_id(
+                mut self,
+                object_id: impl Into<super::super::js_protocol::runtime::RemoteObjectId>,
+            ) -> Self {
+                self.object_id = Some(object_id.into());
+                self
+            }
+            pub fn build(self) -> Result<HighlightSourceOrderParams, String> {
+                Ok(HighlightSourceOrderParams {
+                    source_order_config: self.source_order_config.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(source_order_config)
+                        )
+                    })?,
+                    node_id: self.node_id,
+                    backend_node_id: self.backend_node_id,
+                    object_id: self.object_id,
+                })
+            }
+        }
+        impl HighlightSourceOrderParams {
+            pub const IDENTIFIER: &'static str = "Overlay.highlightSourceOrder";
+        }
+        impl chromiumoxide_types::Method for HighlightSourceOrderParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for HighlightSourceOrderParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Highlights the source order of the children of the DOM node with given id or with the given\nJavaScript object wrapper. Either nodeId or objectId must be specified.\n[highlightSourceOrder](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-highlightSourceOrder)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HighlightSourceOrderReturns {}
+        impl chromiumoxide_types::Command for HighlightSourceOrderParams {
+            type Response = HighlightSourceOrderReturns;
+        }
+        #[doc = "Enters the 'inspect' mode. In this mode, elements that user is hovering over are highlighted.\nBackend then generates 'inspectNodeRequested' event upon element selection.\n[setInspectMode](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setInspectMode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetInspectModeParams {
+            #[doc = "Set an inspection mode."]
+            #[serde(rename = "mode")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub mode: InspectMode,
+            #[doc = "A descriptor for the highlight appearance of hovered-over nodes. May be omitted if `enabled\n== false`."]
+            #[serde(rename = "highlightConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub highlight_config: Option<HighlightConfig>,
+        }
+        impl SetInspectModeParams {
+            pub fn new(mode: impl Into<InspectMode>) -> Self {
+                Self {
+                    mode: mode.into(),
+                    highlight_config: None,
+                }
+            }
+        }
+        impl SetInspectModeParams {
+            pub fn builder() -> SetInspectModeParamsBuilder {
+                SetInspectModeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetInspectModeParamsBuilder {
+            mode: Option<InspectMode>,
+            highlight_config: Option<HighlightConfig>,
+        }
+        impl SetInspectModeParamsBuilder {
+            pub fn mode(mut self, mode: impl Into<InspectMode>) -> Self {
+                self.mode = Some(mode.into());
+                self
+            }
+            pub fn highlight_config(
+                mut self,
+                highlight_config: impl Into<HighlightConfig>,
+            ) -> Self {
+                self.highlight_config = Some(highlight_config.into());
+                self
+            }
+            pub fn build(self) -> Result<SetInspectModeParams, String> {
+                Ok(SetInspectModeParams {
+                    mode: self.mode.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mode))
+                    })?,
+                    highlight_config: self.highlight_config,
+                })
+            }
+        }
+        impl SetInspectModeParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setInspectMode";
+        }
+        impl chromiumoxide_types::Method for SetInspectModeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetInspectModeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enters the 'inspect' mode. In this mode, elements that user is hovering over are highlighted.\nBackend then generates 'inspectNodeRequested' event upon element selection.\n[setInspectMode](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setInspectMode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetInspectModeReturns {}
+        impl chromiumoxide_types::Command for SetInspectModeParams {
+            type Response = SetInspectModeReturns;
+        }
+        #[doc = "Highlights owner element of all frames detected to be ads.\n[setShowAdHighlights](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowAdHighlights)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowAdHighlightsParams {
+            #[doc = "True for showing ad highlights"]
+            #[serde(rename = "show")]
+            pub show: bool,
+        }
+        impl SetShowAdHighlightsParams {
+            pub fn new(show: impl Into<bool>) -> Self {
+                Self { show: show.into() }
+            }
+        }
+        impl SetShowAdHighlightsParams {
+            pub fn builder() -> SetShowAdHighlightsParamsBuilder {
+                SetShowAdHighlightsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowAdHighlightsParamsBuilder {
+            show: Option<bool>,
+        }
+        impl SetShowAdHighlightsParamsBuilder {
+            pub fn show(mut self, show: impl Into<bool>) -> Self {
+                self.show = Some(show.into());
+                self
+            }
+            pub fn build(self) -> Result<SetShowAdHighlightsParams, String> {
+                Ok(SetShowAdHighlightsParams {
+                    show: self.show.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(show))
+                    })?,
+                })
+            }
+        }
+        impl SetShowAdHighlightsParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowAdHighlights";
+        }
+        impl chromiumoxide_types::Method for SetShowAdHighlightsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowAdHighlightsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Highlights owner element of all frames detected to be ads.\n[setShowAdHighlights](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowAdHighlights)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowAdHighlightsReturns {}
+        impl chromiumoxide_types::Command for SetShowAdHighlightsParams {
+            type Response = SetShowAdHighlightsReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPausedInDebuggerMessageParams {
+            #[doc = "The message to display, also triggers resume and step over controls."]
+            #[serde(rename = "message")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub message: Option<String>,
+        }
+        impl SetPausedInDebuggerMessageParams {
+            pub fn builder() -> SetPausedInDebuggerMessageParamsBuilder {
+                SetPausedInDebuggerMessageParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPausedInDebuggerMessageParamsBuilder {
+            message: Option<String>,
+        }
+        impl SetPausedInDebuggerMessageParamsBuilder {
+            pub fn message(mut self, message: impl Into<String>) -> Self {
+                self.message = Some(message.into());
+                self
+            }
+            pub fn build(self) -> SetPausedInDebuggerMessageParams {
+                SetPausedInDebuggerMessageParams {
+                    message: self.message,
+                }
+            }
+        }
+        impl SetPausedInDebuggerMessageParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setPausedInDebuggerMessage";
+        }
+        impl chromiumoxide_types::Method for SetPausedInDebuggerMessageParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPausedInDebuggerMessageParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPausedInDebuggerMessageReturns {}
+        impl chromiumoxide_types::Command for SetPausedInDebuggerMessageParams {
+            type Response = SetPausedInDebuggerMessageReturns;
+        }
+        #[doc = "Requests that backend shows debug borders on layers\n[setShowDebugBorders](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowDebugBorders)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowDebugBordersParams {
+            #[doc = "True for showing debug borders"]
+            #[serde(rename = "show")]
+            pub show: bool,
+        }
+        impl SetShowDebugBordersParams {
+            pub fn new(show: impl Into<bool>) -> Self {
+                Self { show: show.into() }
+            }
+        }
+        impl SetShowDebugBordersParams {
+            pub fn builder() -> SetShowDebugBordersParamsBuilder {
+                SetShowDebugBordersParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowDebugBordersParamsBuilder {
+            show: Option<bool>,
+        }
+        impl SetShowDebugBordersParamsBuilder {
+            pub fn show(mut self, show: impl Into<bool>) -> Self {
+                self.show = Some(show.into());
+                self
+            }
+            pub fn build(self) -> Result<SetShowDebugBordersParams, String> {
+                Ok(SetShowDebugBordersParams {
+                    show: self.show.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(show))
+                    })?,
+                })
+            }
+        }
+        impl SetShowDebugBordersParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowDebugBorders";
+        }
+        impl chromiumoxide_types::Method for SetShowDebugBordersParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowDebugBordersParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests that backend shows debug borders on layers\n[setShowDebugBorders](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowDebugBorders)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowDebugBordersReturns {}
+        impl chromiumoxide_types::Command for SetShowDebugBordersParams {
+            type Response = SetShowDebugBordersReturns;
+        }
+        #[doc = "Requests that backend shows the FPS counter\n[setShowFPSCounter](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowFPSCounter)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowFpsCounterParams {
+            #[doc = "True for showing the FPS counter"]
+            #[serde(rename = "show")]
+            pub show: bool,
+        }
+        impl SetShowFpsCounterParams {
+            pub fn new(show: impl Into<bool>) -> Self {
+                Self { show: show.into() }
+            }
+        }
+        impl SetShowFpsCounterParams {
+            pub fn builder() -> SetShowFpsCounterParamsBuilder {
+                SetShowFpsCounterParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowFpsCounterParamsBuilder {
+            show: Option<bool>,
+        }
+        impl SetShowFpsCounterParamsBuilder {
+            pub fn show(mut self, show: impl Into<bool>) -> Self {
+                self.show = Some(show.into());
+                self
+            }
+            pub fn build(self) -> Result<SetShowFpsCounterParams, String> {
+                Ok(SetShowFpsCounterParams {
+                    show: self.show.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(show))
+                    })?,
+                })
+            }
+        }
+        impl SetShowFpsCounterParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowFPSCounter";
+        }
+        impl chromiumoxide_types::Method for SetShowFpsCounterParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowFpsCounterParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests that backend shows the FPS counter\n[setShowFPSCounter](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowFPSCounter)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowFpsCounterReturns {}
+        impl chromiumoxide_types::Command for SetShowFpsCounterParams {
+            type Response = SetShowFpsCounterReturns;
+        }
+        #[doc = "Highlight multiple elements with the CSS Grid overlay.\n[setShowGridOverlays](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowGridOverlays)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowGridOverlaysParams {
+            #[doc = "An array of node identifiers and descriptors for the highlight appearance."]
+            #[serde(rename = "gridNodeHighlightConfigs")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub grid_node_highlight_configs: Vec<GridNodeHighlightConfig>,
+        }
+        impl SetShowGridOverlaysParams {
+            pub fn new(grid_node_highlight_configs: Vec<GridNodeHighlightConfig>) -> Self {
+                Self {
+                    grid_node_highlight_configs,
+                }
+            }
+        }
+        impl SetShowGridOverlaysParams {
+            pub fn builder() -> SetShowGridOverlaysParamsBuilder {
+                SetShowGridOverlaysParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowGridOverlaysParamsBuilder {
+            grid_node_highlight_configs: Option<Vec<GridNodeHighlightConfig>>,
+        }
+        impl SetShowGridOverlaysParamsBuilder {
+            pub fn grid_node_highlight_config(
+                mut self,
+                grid_node_highlight_config: impl Into<GridNodeHighlightConfig>,
+            ) -> Self {
+                let v = self.grid_node_highlight_configs.get_or_insert(Vec::new());
+                v.push(grid_node_highlight_config.into());
+                self
+            }
+            pub fn grid_node_highlight_configs<I, S>(
+                mut self,
+                grid_node_highlight_configs: I,
+            ) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<GridNodeHighlightConfig>,
+            {
+                let v = self.grid_node_highlight_configs.get_or_insert(Vec::new());
+                for val in grid_node_highlight_configs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetShowGridOverlaysParams, String> {
+                Ok(SetShowGridOverlaysParams {
+                    grid_node_highlight_configs: self.grid_node_highlight_configs.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(grid_node_highlight_configs)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl SetShowGridOverlaysParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowGridOverlays";
+        }
+        impl chromiumoxide_types::Method for SetShowGridOverlaysParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowGridOverlaysParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Highlight multiple elements with the CSS Grid overlay.\n[setShowGridOverlays](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowGridOverlays)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowGridOverlaysReturns {}
+        impl chromiumoxide_types::Command for SetShowGridOverlaysParams {
+            type Response = SetShowGridOverlaysReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowFlexOverlaysParams {
+            #[doc = "An array of node identifiers and descriptors for the highlight appearance."]
+            #[serde(rename = "flexNodeHighlightConfigs")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub flex_node_highlight_configs: Vec<FlexNodeHighlightConfig>,
+        }
+        impl SetShowFlexOverlaysParams {
+            pub fn new(flex_node_highlight_configs: Vec<FlexNodeHighlightConfig>) -> Self {
+                Self {
+                    flex_node_highlight_configs,
+                }
+            }
+        }
+        impl SetShowFlexOverlaysParams {
+            pub fn builder() -> SetShowFlexOverlaysParamsBuilder {
+                SetShowFlexOverlaysParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowFlexOverlaysParamsBuilder {
+            flex_node_highlight_configs: Option<Vec<FlexNodeHighlightConfig>>,
+        }
+        impl SetShowFlexOverlaysParamsBuilder {
+            pub fn flex_node_highlight_config(
+                mut self,
+                flex_node_highlight_config: impl Into<FlexNodeHighlightConfig>,
+            ) -> Self {
+                let v = self.flex_node_highlight_configs.get_or_insert(Vec::new());
+                v.push(flex_node_highlight_config.into());
+                self
+            }
+            pub fn flex_node_highlight_configs<I, S>(
+                mut self,
+                flex_node_highlight_configs: I,
+            ) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FlexNodeHighlightConfig>,
+            {
+                let v = self.flex_node_highlight_configs.get_or_insert(Vec::new());
+                for val in flex_node_highlight_configs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetShowFlexOverlaysParams, String> {
+                Ok(SetShowFlexOverlaysParams {
+                    flex_node_highlight_configs: self.flex_node_highlight_configs.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(flex_node_highlight_configs)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl SetShowFlexOverlaysParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowFlexOverlays";
+        }
+        impl chromiumoxide_types::Method for SetShowFlexOverlaysParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowFlexOverlaysParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowFlexOverlaysReturns {}
+        impl chromiumoxide_types::Command for SetShowFlexOverlaysParams {
+            type Response = SetShowFlexOverlaysReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowScrollSnapOverlaysParams {
+            #[doc = "An array of node identifiers and descriptors for the highlight appearance."]
+            #[serde(rename = "scrollSnapHighlightConfigs")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub scroll_snap_highlight_configs: Vec<ScrollSnapHighlightConfig>,
+        }
+        impl SetShowScrollSnapOverlaysParams {
+            pub fn new(scroll_snap_highlight_configs: Vec<ScrollSnapHighlightConfig>) -> Self {
+                Self {
+                    scroll_snap_highlight_configs,
+                }
+            }
+        }
+        impl SetShowScrollSnapOverlaysParams {
+            pub fn builder() -> SetShowScrollSnapOverlaysParamsBuilder {
+                SetShowScrollSnapOverlaysParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowScrollSnapOverlaysParamsBuilder {
+            scroll_snap_highlight_configs: Option<Vec<ScrollSnapHighlightConfig>>,
+        }
+        impl SetShowScrollSnapOverlaysParamsBuilder {
+            pub fn scroll_snap_highlight_config(
+                mut self,
+                scroll_snap_highlight_config: impl Into<ScrollSnapHighlightConfig>,
+            ) -> Self {
+                let v = self.scroll_snap_highlight_configs.get_or_insert(Vec::new());
+                v.push(scroll_snap_highlight_config.into());
+                self
+            }
+            pub fn scroll_snap_highlight_configs<I, S>(
+                mut self,
+                scroll_snap_highlight_configs: I,
+            ) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ScrollSnapHighlightConfig>,
+            {
+                let v = self.scroll_snap_highlight_configs.get_or_insert(Vec::new());
+                for val in scroll_snap_highlight_configs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetShowScrollSnapOverlaysParams, String> {
+                Ok(SetShowScrollSnapOverlaysParams {
+                    scroll_snap_highlight_configs: self.scroll_snap_highlight_configs.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(scroll_snap_highlight_configs)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl SetShowScrollSnapOverlaysParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowScrollSnapOverlays";
+        }
+        impl chromiumoxide_types::Method for SetShowScrollSnapOverlaysParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowScrollSnapOverlaysParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowScrollSnapOverlaysReturns {}
+        impl chromiumoxide_types::Command for SetShowScrollSnapOverlaysParams {
+            type Response = SetShowScrollSnapOverlaysReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowContainerQueryOverlaysParams {
+            #[doc = "An array of node identifiers and descriptors for the highlight appearance."]
+            #[serde(rename = "containerQueryHighlightConfigs")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub container_query_highlight_configs: Vec<ContainerQueryHighlightConfig>,
+        }
+        impl SetShowContainerQueryOverlaysParams {
+            pub fn new(
+                container_query_highlight_configs: Vec<ContainerQueryHighlightConfig>,
+            ) -> Self {
+                Self {
+                    container_query_highlight_configs,
+                }
+            }
+        }
+        impl SetShowContainerQueryOverlaysParams {
+            pub fn builder() -> SetShowContainerQueryOverlaysParamsBuilder {
+                SetShowContainerQueryOverlaysParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowContainerQueryOverlaysParamsBuilder {
+            container_query_highlight_configs: Option<Vec<ContainerQueryHighlightConfig>>,
+        }
+        impl SetShowContainerQueryOverlaysParamsBuilder {
+            pub fn container_query_highlight_config(
+                mut self,
+                container_query_highlight_config: impl Into<ContainerQueryHighlightConfig>,
+            ) -> Self {
+                let v = self
+                    .container_query_highlight_configs
+                    .get_or_insert(Vec::new());
+                v.push(container_query_highlight_config.into());
+                self
+            }
+            pub fn container_query_highlight_configs<I, S>(
+                mut self,
+                container_query_highlight_configs: I,
+            ) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ContainerQueryHighlightConfig>,
+            {
+                let v = self
+                    .container_query_highlight_configs
+                    .get_or_insert(Vec::new());
+                for val in container_query_highlight_configs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetShowContainerQueryOverlaysParams, String> {
+                Ok(SetShowContainerQueryOverlaysParams {
+                    container_query_highlight_configs: self
+                        .container_query_highlight_configs
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(container_query_highlight_configs)
+                            )
+                        })?,
+                })
+            }
+        }
+        impl SetShowContainerQueryOverlaysParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowContainerQueryOverlays";
+        }
+        impl chromiumoxide_types::Method for SetShowContainerQueryOverlaysParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowContainerQueryOverlaysParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowContainerQueryOverlaysReturns {}
+        impl chromiumoxide_types::Command for SetShowContainerQueryOverlaysParams {
+            type Response = SetShowContainerQueryOverlaysReturns;
+        }
+        #[doc = "Requests that backend shows paint rectangles\n[setShowPaintRects](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowPaintRects)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowPaintRectsParams {
+            #[doc = "True for showing paint rectangles"]
+            #[serde(rename = "result")]
+            pub result: bool,
+        }
+        impl SetShowPaintRectsParams {
+            pub fn new(result: impl Into<bool>) -> Self {
+                Self {
+                    result: result.into(),
+                }
+            }
+        }
+        impl SetShowPaintRectsParams {
+            pub fn builder() -> SetShowPaintRectsParamsBuilder {
+                SetShowPaintRectsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowPaintRectsParamsBuilder {
+            result: Option<bool>,
+        }
+        impl SetShowPaintRectsParamsBuilder {
+            pub fn result(mut self, result: impl Into<bool>) -> Self {
+                self.result = Some(result.into());
+                self
+            }
+            pub fn build(self) -> Result<SetShowPaintRectsParams, String> {
+                Ok(SetShowPaintRectsParams {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                })
+            }
+        }
+        impl SetShowPaintRectsParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowPaintRects";
+        }
+        impl chromiumoxide_types::Method for SetShowPaintRectsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowPaintRectsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests that backend shows paint rectangles\n[setShowPaintRects](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowPaintRects)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowPaintRectsReturns {}
+        impl chromiumoxide_types::Command for SetShowPaintRectsParams {
+            type Response = SetShowPaintRectsReturns;
+        }
+        #[doc = "Requests that backend shows layout shift regions\n[setShowLayoutShiftRegions](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowLayoutShiftRegions)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowLayoutShiftRegionsParams {
+            #[doc = "True for showing layout shift regions"]
+            #[serde(rename = "result")]
+            pub result: bool,
+        }
+        impl SetShowLayoutShiftRegionsParams {
+            pub fn new(result: impl Into<bool>) -> Self {
+                Self {
+                    result: result.into(),
+                }
+            }
+        }
+        impl SetShowLayoutShiftRegionsParams {
+            pub fn builder() -> SetShowLayoutShiftRegionsParamsBuilder {
+                SetShowLayoutShiftRegionsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowLayoutShiftRegionsParamsBuilder {
+            result: Option<bool>,
+        }
+        impl SetShowLayoutShiftRegionsParamsBuilder {
+            pub fn result(mut self, result: impl Into<bool>) -> Self {
+                self.result = Some(result.into());
+                self
+            }
+            pub fn build(self) -> Result<SetShowLayoutShiftRegionsParams, String> {
+                Ok(SetShowLayoutShiftRegionsParams {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                })
+            }
+        }
+        impl SetShowLayoutShiftRegionsParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowLayoutShiftRegions";
+        }
+        impl chromiumoxide_types::Method for SetShowLayoutShiftRegionsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowLayoutShiftRegionsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests that backend shows layout shift regions\n[setShowLayoutShiftRegions](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowLayoutShiftRegions)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowLayoutShiftRegionsReturns {}
+        impl chromiumoxide_types::Command for SetShowLayoutShiftRegionsParams {
+            type Response = SetShowLayoutShiftRegionsReturns;
+        }
+        #[doc = "Requests that backend shows scroll bottleneck rects\n[setShowScrollBottleneckRects](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowScrollBottleneckRects)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowScrollBottleneckRectsParams {
+            #[doc = "True for showing scroll bottleneck rects"]
+            #[serde(rename = "show")]
+            pub show: bool,
+        }
+        impl SetShowScrollBottleneckRectsParams {
+            pub fn new(show: impl Into<bool>) -> Self {
+                Self { show: show.into() }
+            }
+        }
+        impl SetShowScrollBottleneckRectsParams {
+            pub fn builder() -> SetShowScrollBottleneckRectsParamsBuilder {
+                SetShowScrollBottleneckRectsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowScrollBottleneckRectsParamsBuilder {
+            show: Option<bool>,
+        }
+        impl SetShowScrollBottleneckRectsParamsBuilder {
+            pub fn show(mut self, show: impl Into<bool>) -> Self {
+                self.show = Some(show.into());
+                self
+            }
+            pub fn build(self) -> Result<SetShowScrollBottleneckRectsParams, String> {
+                Ok(SetShowScrollBottleneckRectsParams {
+                    show: self.show.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(show))
+                    })?,
+                })
+            }
+        }
+        impl SetShowScrollBottleneckRectsParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowScrollBottleneckRects";
+        }
+        impl chromiumoxide_types::Method for SetShowScrollBottleneckRectsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowScrollBottleneckRectsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests that backend shows scroll bottleneck rects\n[setShowScrollBottleneckRects](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowScrollBottleneckRects)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowScrollBottleneckRectsReturns {}
+        impl chromiumoxide_types::Command for SetShowScrollBottleneckRectsParams {
+            type Response = SetShowScrollBottleneckRectsReturns;
+        }
+        #[doc = "Paints viewport size upon main frame resize.\n[setShowViewportSizeOnResize](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowViewportSizeOnResize)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowViewportSizeOnResizeParams {
+            #[doc = "Whether to paint size or not."]
+            #[serde(rename = "show")]
+            pub show: bool,
+        }
+        impl SetShowViewportSizeOnResizeParams {
+            pub fn new(show: impl Into<bool>) -> Self {
+                Self { show: show.into() }
+            }
+        }
+        impl SetShowViewportSizeOnResizeParams {
+            pub fn builder() -> SetShowViewportSizeOnResizeParamsBuilder {
+                SetShowViewportSizeOnResizeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowViewportSizeOnResizeParamsBuilder {
+            show: Option<bool>,
+        }
+        impl SetShowViewportSizeOnResizeParamsBuilder {
+            pub fn show(mut self, show: impl Into<bool>) -> Self {
+                self.show = Some(show.into());
+                self
+            }
+            pub fn build(self) -> Result<SetShowViewportSizeOnResizeParams, String> {
+                Ok(SetShowViewportSizeOnResizeParams {
+                    show: self.show.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(show))
+                    })?,
+                })
+            }
+        }
+        impl SetShowViewportSizeOnResizeParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowViewportSizeOnResize";
+        }
+        impl chromiumoxide_types::Method for SetShowViewportSizeOnResizeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowViewportSizeOnResizeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Paints viewport size upon main frame resize.\n[setShowViewportSizeOnResize](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowViewportSizeOnResize)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowViewportSizeOnResizeReturns {}
+        impl chromiumoxide_types::Command for SetShowViewportSizeOnResizeParams {
+            type Response = SetShowViewportSizeOnResizeReturns;
+        }
+        #[doc = "Add a dual screen device hinge\n[setShowHinge](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowHinge)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowHingeParams {
+            #[doc = "hinge data, null means hideHinge"]
+            #[serde(rename = "hingeConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub hinge_config: Option<HingeConfig>,
+        }
+        impl SetShowHingeParams {
+            pub fn builder() -> SetShowHingeParamsBuilder {
+                SetShowHingeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowHingeParamsBuilder {
+            hinge_config: Option<HingeConfig>,
+        }
+        impl SetShowHingeParamsBuilder {
+            pub fn hinge_config(mut self, hinge_config: impl Into<HingeConfig>) -> Self {
+                self.hinge_config = Some(hinge_config.into());
+                self
+            }
+            pub fn build(self) -> SetShowHingeParams {
+                SetShowHingeParams {
+                    hinge_config: self.hinge_config,
+                }
+            }
+        }
+        impl SetShowHingeParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowHinge";
+        }
+        impl chromiumoxide_types::Method for SetShowHingeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowHingeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Add a dual screen device hinge\n[setShowHinge](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowHinge)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowHingeReturns {}
+        impl chromiumoxide_types::Command for SetShowHingeParams {
+            type Response = SetShowHingeReturns;
+        }
+        #[doc = "Show elements in isolation mode with overlays.\n[setShowIsolatedElements](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowIsolatedElements)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetShowIsolatedElementsParams {
+            #[doc = "An array of node identifiers and descriptors for the highlight appearance."]
+            #[serde(rename = "isolatedElementHighlightConfigs")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub isolated_element_highlight_configs: Vec<IsolatedElementHighlightConfig>,
+        }
+        impl SetShowIsolatedElementsParams {
+            pub fn new(
+                isolated_element_highlight_configs: Vec<IsolatedElementHighlightConfig>,
+            ) -> Self {
+                Self {
+                    isolated_element_highlight_configs,
+                }
+            }
+        }
+        impl SetShowIsolatedElementsParams {
+            pub fn builder() -> SetShowIsolatedElementsParamsBuilder {
+                SetShowIsolatedElementsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowIsolatedElementsParamsBuilder {
+            isolated_element_highlight_configs: Option<Vec<IsolatedElementHighlightConfig>>,
+        }
+        impl SetShowIsolatedElementsParamsBuilder {
+            pub fn isolated_element_highlight_config(
+                mut self,
+                isolated_element_highlight_config: impl Into<IsolatedElementHighlightConfig>,
+            ) -> Self {
+                let v = self
+                    .isolated_element_highlight_configs
+                    .get_or_insert(Vec::new());
+                v.push(isolated_element_highlight_config.into());
+                self
+            }
+            pub fn isolated_element_highlight_configs<I, S>(
+                mut self,
+                isolated_element_highlight_configs: I,
+            ) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<IsolatedElementHighlightConfig>,
+            {
+                let v = self
+                    .isolated_element_highlight_configs
+                    .get_or_insert(Vec::new());
+                for val in isolated_element_highlight_configs {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetShowIsolatedElementsParams, String> {
+                Ok(SetShowIsolatedElementsParams {
+                    isolated_element_highlight_configs: self
+                        .isolated_element_highlight_configs
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(isolated_element_highlight_configs)
+                            )
+                        })?,
+                })
+            }
+        }
+        impl SetShowIsolatedElementsParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowIsolatedElements";
+        }
+        impl chromiumoxide_types::Method for SetShowIsolatedElementsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowIsolatedElementsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Show elements in isolation mode with overlays.\n[setShowIsolatedElements](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowIsolatedElements)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowIsolatedElementsReturns {}
+        impl chromiumoxide_types::Command for SetShowIsolatedElementsParams {
+            type Response = SetShowIsolatedElementsReturns;
+        }
+        #[doc = "Show Window Controls Overlay for PWA\n[setShowWindowControlsOverlay](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowWindowControlsOverlay)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowWindowControlsOverlayParams {
+            #[doc = "Window Controls Overlay data, null means hide Window Controls Overlay"]
+            #[serde(rename = "windowControlsOverlayConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub window_controls_overlay_config: Option<WindowControlsOverlayConfig>,
+        }
+        impl SetShowWindowControlsOverlayParams {
+            pub fn builder() -> SetShowWindowControlsOverlayParamsBuilder {
+                SetShowWindowControlsOverlayParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetShowWindowControlsOverlayParamsBuilder {
+            window_controls_overlay_config: Option<WindowControlsOverlayConfig>,
+        }
+        impl SetShowWindowControlsOverlayParamsBuilder {
+            pub fn window_controls_overlay_config(
+                mut self,
+                window_controls_overlay_config: impl Into<WindowControlsOverlayConfig>,
+            ) -> Self {
+                self.window_controls_overlay_config = Some(window_controls_overlay_config.into());
+                self
+            }
+            pub fn build(self) -> SetShowWindowControlsOverlayParams {
+                SetShowWindowControlsOverlayParams {
+                    window_controls_overlay_config: self.window_controls_overlay_config,
+                }
+            }
+        }
+        impl SetShowWindowControlsOverlayParams {
+            pub const IDENTIFIER: &'static str = "Overlay.setShowWindowControlsOverlay";
+        }
+        impl chromiumoxide_types::Method for SetShowWindowControlsOverlayParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetShowWindowControlsOverlayParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Show Window Controls Overlay for PWA\n[setShowWindowControlsOverlay](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#method-setShowWindowControlsOverlay)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetShowWindowControlsOverlayReturns {}
+        impl chromiumoxide_types::Command for SetShowWindowControlsOverlayParams {
+            type Response = SetShowWindowControlsOverlayReturns;
+        }
+        #[doc = "Fired when the node should be inspected. This happens after call to `setInspectMode` or when\nuser manually inspects an element.\n[inspectNodeRequested](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#event-inspectNodeRequested)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventInspectNodeRequested {
+            #[doc = "Id of the node to inspect."]
+            #[serde(rename = "backendNodeId")]
+            pub backend_node_id: super::dom::BackendNodeId,
+        }
+        impl EventInspectNodeRequested {
+            pub const IDENTIFIER: &'static str = "Overlay.inspectNodeRequested";
+        }
+        impl chromiumoxide_types::Method for EventInspectNodeRequested {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventInspectNodeRequested {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when the node should be highlighted. This happens after call to `setInspectMode`.\n[nodeHighlightRequested](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#event-nodeHighlightRequested)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventNodeHighlightRequested {
+            #[serde(rename = "nodeId")]
+            pub node_id: super::dom::NodeId,
+        }
+        impl EventNodeHighlightRequested {
+            pub const IDENTIFIER: &'static str = "Overlay.nodeHighlightRequested";
+        }
+        impl chromiumoxide_types::Method for EventNodeHighlightRequested {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventNodeHighlightRequested {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when user asks to capture screenshot of some area on the page.\n[screenshotRequested](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#event-screenshotRequested)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventScreenshotRequested {
+            #[doc = "Viewport to capture, in device independent pixels (dip)."]
+            #[serde(rename = "viewport")]
+            pub viewport: super::page::Viewport,
+        }
+        impl EventScreenshotRequested {
+            pub const IDENTIFIER: &'static str = "Overlay.screenshotRequested";
+        }
+        impl chromiumoxide_types::Method for EventScreenshotRequested {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventScreenshotRequested {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when user cancels the inspect mode.\n[inspectModeCanceled](https://chromedevtools.github.io/devtools-protocol/tot/Overlay/#event-inspectModeCanceled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventInspectModeCanceled {}
+        impl EventInspectModeCanceled {
+            pub const IDENTIFIER: &'static str = "Overlay.inspectModeCanceled";
+        }
+        impl chromiumoxide_types::Method for EventInspectModeCanceled {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventInspectModeCanceled {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "This domain allows interacting with the browser to control PWAs."]
+    pub mod pwa {
+        use serde::{Deserialize, Serialize};
+        #[doc = "The following types are the replica of\nhttps://crsrc.org/c/chrome/browser/web_applications/proto/web_app_os_integration_state.proto;drc=9910d3be894c8f142c977ba1023f30a656bc13fc;l=67\n[FileHandlerAccept](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#type-FileHandlerAccept)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FileHandlerAccept {
+            #[doc = "New name of the mimetype according to\nhttps://www.iana.org/assignments/media-types/media-types.xhtml"]
+            #[serde(rename = "mediaType")]
+            pub media_type: String,
+            #[serde(rename = "fileExtensions")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub file_extensions: Vec<String>,
+        }
+        impl FileHandlerAccept {
+            pub fn new(media_type: impl Into<String>, file_extensions: Vec<String>) -> Self {
+                Self {
+                    media_type: media_type.into(),
+                    file_extensions,
+                }
+            }
+        }
+        impl FileHandlerAccept {
+            pub fn builder() -> FileHandlerAcceptBuilder {
+                FileHandlerAcceptBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FileHandlerAcceptBuilder {
+            media_type: Option<String>,
+            file_extensions: Option<Vec<String>>,
+        }
+        impl FileHandlerAcceptBuilder {
+            pub fn media_type(mut self, media_type: impl Into<String>) -> Self {
+                self.media_type = Some(media_type.into());
+                self
+            }
+            pub fn file_extension(mut self, file_extension: impl Into<String>) -> Self {
+                let v = self.file_extensions.get_or_insert(Vec::new());
+                v.push(file_extension.into());
+                self
+            }
+            pub fn file_extensions<I, S>(mut self, file_extensions: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.file_extensions.get_or_insert(Vec::new());
+                for val in file_extensions {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<FileHandlerAccept, String> {
+                Ok(FileHandlerAccept {
+                    media_type: self.media_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(media_type))
+                    })?,
+                    file_extensions: self.file_extensions.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(file_extensions))
+                    })?,
+                })
+            }
+        }
+        impl FileHandlerAccept {
+            pub const IDENTIFIER: &'static str = "PWA.FileHandlerAccept";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FileHandler {
+            #[serde(rename = "action")]
+            pub action: String,
+            #[serde(rename = "accepts")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub accepts: Vec<FileHandlerAccept>,
+            #[serde(rename = "displayName")]
+            pub display_name: String,
+        }
+        impl FileHandler {
+            pub fn new(
+                action: impl Into<String>,
+                accepts: Vec<FileHandlerAccept>,
+                display_name: impl Into<String>,
+            ) -> Self {
+                Self {
+                    action: action.into(),
+                    accepts,
+                    display_name: display_name.into(),
+                }
+            }
+        }
+        impl FileHandler {
+            pub fn builder() -> FileHandlerBuilder {
+                FileHandlerBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FileHandlerBuilder {
+            action: Option<String>,
+            accepts: Option<Vec<FileHandlerAccept>>,
+            display_name: Option<String>,
+        }
+        impl FileHandlerBuilder {
+            pub fn action(mut self, action: impl Into<String>) -> Self {
+                self.action = Some(action.into());
+                self
+            }
+            pub fn accept(mut self, accept: impl Into<FileHandlerAccept>) -> Self {
+                let v = self.accepts.get_or_insert(Vec::new());
+                v.push(accept.into());
+                self
+            }
+            pub fn accepts<I, S>(mut self, accepts: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FileHandlerAccept>,
+            {
+                let v = self.accepts.get_or_insert(Vec::new());
+                for val in accepts {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn display_name(mut self, display_name: impl Into<String>) -> Self {
+                self.display_name = Some(display_name.into());
+                self
+            }
+            pub fn build(self) -> Result<FileHandler, String> {
+                Ok(FileHandler {
+                    action: self.action.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(action))
+                    })?,
+                    accepts: self.accepts.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(accepts))
+                    })?,
+                    display_name: self.display_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(display_name))
+                    })?,
+                })
+            }
+        }
+        impl FileHandler {
+            pub const IDENTIFIER: &'static str = "PWA.FileHandler";
+        }
+        #[doc = "If user prefers opening the app in browser or an app window."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DisplayMode {
+            #[serde(rename = "standalone")]
+            Standalone,
+            #[serde(rename = "browser")]
+            Browser,
+        }
+        impl AsRef<str> for DisplayMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DisplayMode::Standalone => "standalone",
+                    DisplayMode::Browser => "browser",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DisplayMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "standalone" | "Standalone" => Ok(DisplayMode::Standalone),
+                    "browser" | "Browser" => Ok(DisplayMode::Browser),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Returns the following OS state for the given manifest id.\n[getOsAppState](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-getOsAppState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetOsAppStateParams {
+            #[doc = "The id from the webapp's manifest file, commonly it's the url of the\nsite installing the webapp. See\nhttps://web.dev/learn/pwa/web-app-manifest."]
+            #[serde(rename = "manifestId")]
+            pub manifest_id: String,
+        }
+        impl GetOsAppStateParams {
+            pub fn new(manifest_id: impl Into<String>) -> Self {
+                Self {
+                    manifest_id: manifest_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetOsAppStateParams {
+            fn from(url: T) -> Self {
+                GetOsAppStateParams::new(url)
+            }
+        }
+        impl GetOsAppStateParams {
+            pub fn builder() -> GetOsAppStateParamsBuilder {
+                GetOsAppStateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetOsAppStateParamsBuilder {
+            manifest_id: Option<String>,
+        }
+        impl GetOsAppStateParamsBuilder {
+            pub fn manifest_id(mut self, manifest_id: impl Into<String>) -> Self {
+                self.manifest_id = Some(manifest_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetOsAppStateParams, String> {
+                Ok(GetOsAppStateParams {
+                    manifest_id: self.manifest_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(manifest_id))
+                    })?,
+                })
+            }
+        }
+        impl GetOsAppStateParams {
+            pub const IDENTIFIER: &'static str = "PWA.getOsAppState";
+        }
+        impl chromiumoxide_types::Method for GetOsAppStateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetOsAppStateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the following OS state for the given manifest id.\n[getOsAppState](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-getOsAppState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetOsAppStateReturns {
+            #[serde(rename = "badgeCount")]
+            pub badge_count: i64,
+            #[serde(rename = "fileHandlers")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub file_handlers: Vec<FileHandler>,
+        }
+        impl GetOsAppStateReturns {
+            pub fn new(badge_count: impl Into<i64>, file_handlers: Vec<FileHandler>) -> Self {
+                Self {
+                    badge_count: badge_count.into(),
+                    file_handlers,
+                }
+            }
+        }
+        impl GetOsAppStateReturns {
+            pub fn builder() -> GetOsAppStateReturnsBuilder {
+                GetOsAppStateReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetOsAppStateReturnsBuilder {
+            badge_count: Option<i64>,
+            file_handlers: Option<Vec<FileHandler>>,
+        }
+        impl GetOsAppStateReturnsBuilder {
+            pub fn badge_count(mut self, badge_count: impl Into<i64>) -> Self {
+                self.badge_count = Some(badge_count.into());
+                self
+            }
+            pub fn file_handler(mut self, file_handler: impl Into<FileHandler>) -> Self {
+                let v = self.file_handlers.get_or_insert(Vec::new());
+                v.push(file_handler.into());
+                self
+            }
+            pub fn file_handlers<I, S>(mut self, file_handlers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FileHandler>,
+            {
+                let v = self.file_handlers.get_or_insert(Vec::new());
+                for val in file_handlers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetOsAppStateReturns, String> {
+                Ok(GetOsAppStateReturns {
+                    badge_count: self.badge_count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(badge_count))
+                    })?,
+                    file_handlers: self.file_handlers.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(file_handlers))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetOsAppStateParams {
+            type Response = GetOsAppStateReturns;
+        }
+        #[doc = "Installs the given manifest identity, optionally using the given installUrlOrBundleUrl\n\nIWA-specific install description:\nmanifestId corresponds to isolated-app:// + web_package::SignedWebBundleId\n\nFile installation mode:\nThe installUrlOrBundleUrl can be either file:// or http(s):// pointing\nto a signed web bundle (.swbn). In this case SignedWebBundleId must correspond to\nThe .swbn file's signing key.\n\nDev proxy installation mode:\ninstallUrlOrBundleUrl must be http(s):// that serves dev mode IWA.\nweb_package::SignedWebBundleId must be of type dev proxy.\n\nThe advantage of dev proxy mode is that all changes to IWA\nautomatically will be reflected in the running app without\nreinstallation.\n\nTo generate bundle id for proxy mode:\n1. Generate 32 random bytes.\n2. Add a specific suffix at the end following the documentation\nhttps://github.com/WICG/isolated-web-apps/blob/main/Scheme.md#suffix\n3. Encode the entire sequence using Base32 without padding.\n\nIf Chrome is not in IWA dev\nmode, the installation will fail, regardless of the state of the allowlist.\n[install](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-install)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct InstallParams {
+            #[serde(rename = "manifestId")]
+            pub manifest_id: String,
+            #[doc = "The location of the app or bundle overriding the one derived from the\nmanifestId."]
+            #[serde(rename = "installUrlOrBundleUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub install_url_or_bundle_url: Option<String>,
+        }
+        impl InstallParams {
+            pub fn new(manifest_id: impl Into<String>) -> Self {
+                Self {
+                    manifest_id: manifest_id.into(),
+                    install_url_or_bundle_url: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for InstallParams {
+            fn from(url: T) -> Self {
+                InstallParams::new(url)
+            }
+        }
+        impl InstallParams {
+            pub fn builder() -> InstallParamsBuilder {
+                InstallParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InstallParamsBuilder {
+            manifest_id: Option<String>,
+            install_url_or_bundle_url: Option<String>,
+        }
+        impl InstallParamsBuilder {
+            pub fn manifest_id(mut self, manifest_id: impl Into<String>) -> Self {
+                self.manifest_id = Some(manifest_id.into());
+                self
+            }
+            pub fn install_url_or_bundle_url(
+                mut self,
+                install_url_or_bundle_url: impl Into<String>,
+            ) -> Self {
+                self.install_url_or_bundle_url = Some(install_url_or_bundle_url.into());
+                self
+            }
+            pub fn build(self) -> Result<InstallParams, String> {
+                Ok(InstallParams {
+                    manifest_id: self.manifest_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(manifest_id))
+                    })?,
+                    install_url_or_bundle_url: self.install_url_or_bundle_url,
+                })
+            }
+        }
+        impl InstallParams {
+            pub const IDENTIFIER: &'static str = "PWA.install";
+        }
+        impl chromiumoxide_types::Method for InstallParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for InstallParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Installs the given manifest identity, optionally using the given installUrlOrBundleUrl\n\nIWA-specific install description:\nmanifestId corresponds to isolated-app:// + web_package::SignedWebBundleId\n\nFile installation mode:\nThe installUrlOrBundleUrl can be either file:// or http(s):// pointing\nto a signed web bundle (.swbn). In this case SignedWebBundleId must correspond to\nThe .swbn file's signing key.\n\nDev proxy installation mode:\ninstallUrlOrBundleUrl must be http(s):// that serves dev mode IWA.\nweb_package::SignedWebBundleId must be of type dev proxy.\n\nThe advantage of dev proxy mode is that all changes to IWA\nautomatically will be reflected in the running app without\nreinstallation.\n\nTo generate bundle id for proxy mode:\n1. Generate 32 random bytes.\n2. Add a specific suffix at the end following the documentation\nhttps://github.com/WICG/isolated-web-apps/blob/main/Scheme.md#suffix\n3. Encode the entire sequence using Base32 without padding.\n\nIf Chrome is not in IWA dev\nmode, the installation will fail, regardless of the state of the allowlist.\n[install](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-install)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct InstallReturns {}
+        impl chromiumoxide_types::Command for InstallParams {
+            type Response = InstallReturns;
+        }
+        #[doc = "Uninstalls the given manifest_id and closes any opened app windows.\n[uninstall](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-uninstall)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UninstallParams {
+            #[serde(rename = "manifestId")]
+            pub manifest_id: String,
+        }
+        impl UninstallParams {
+            pub fn new(manifest_id: impl Into<String>) -> Self {
+                Self {
+                    manifest_id: manifest_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for UninstallParams {
+            fn from(url: T) -> Self {
+                UninstallParams::new(url)
+            }
+        }
+        impl UninstallParams {
+            pub fn builder() -> UninstallParamsBuilder {
+                UninstallParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UninstallParamsBuilder {
+            manifest_id: Option<String>,
+        }
+        impl UninstallParamsBuilder {
+            pub fn manifest_id(mut self, manifest_id: impl Into<String>) -> Self {
+                self.manifest_id = Some(manifest_id.into());
+                self
+            }
+            pub fn build(self) -> Result<UninstallParams, String> {
+                Ok(UninstallParams {
+                    manifest_id: self.manifest_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(manifest_id))
+                    })?,
+                })
+            }
+        }
+        impl UninstallParams {
+            pub const IDENTIFIER: &'static str = "PWA.uninstall";
+        }
+        impl chromiumoxide_types::Method for UninstallParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for UninstallParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Uninstalls the given manifest_id and closes any opened app windows.\n[uninstall](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-uninstall)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UninstallReturns {}
+        impl chromiumoxide_types::Command for UninstallParams {
+            type Response = UninstallReturns;
+        }
+        #[doc = "Launches the installed web app, or an url in the same web app instead of the\ndefault start url if it is provided. Returns a page Target.TargetID which\ncan be used to attach to via Target.attachToTarget or similar APIs.\n[launch](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-launch)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LaunchParams {
+            #[serde(rename = "manifestId")]
+            pub manifest_id: String,
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+        }
+        impl LaunchParams {
+            pub fn new(manifest_id: impl Into<String>) -> Self {
+                Self {
+                    manifest_id: manifest_id.into(),
+                    url: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for LaunchParams {
+            fn from(url: T) -> Self {
+                LaunchParams::new(url)
+            }
+        }
+        impl LaunchParams {
+            pub fn builder() -> LaunchParamsBuilder {
+                LaunchParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LaunchParamsBuilder {
+            manifest_id: Option<String>,
+            url: Option<String>,
+        }
+        impl LaunchParamsBuilder {
+            pub fn manifest_id(mut self, manifest_id: impl Into<String>) -> Self {
+                self.manifest_id = Some(manifest_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn build(self) -> Result<LaunchParams, String> {
+                Ok(LaunchParams {
+                    manifest_id: self.manifest_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(manifest_id))
+                    })?,
+                    url: self.url,
+                })
+            }
+        }
+        impl LaunchParams {
+            pub const IDENTIFIER: &'static str = "PWA.launch";
+        }
+        impl chromiumoxide_types::Method for LaunchParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for LaunchParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Launches the installed web app, or an url in the same web app instead of the\ndefault start url if it is provided. Returns a page Target.TargetID which\ncan be used to attach to via Target.attachToTarget or similar APIs.\n[launch](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-launch)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LaunchReturns {
+            #[doc = "ID of the tab target created as a result."]
+            #[serde(rename = "targetId")]
+            pub target_id: super::target::TargetId,
+        }
+        impl LaunchReturns {
+            pub fn new(target_id: impl Into<super::target::TargetId>) -> Self {
+                Self {
+                    target_id: target_id.into(),
+                }
+            }
+        }
+        impl LaunchReturns {
+            pub fn builder() -> LaunchReturnsBuilder {
+                LaunchReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LaunchReturnsBuilder {
+            target_id: Option<super::target::TargetId>,
+        }
+        impl LaunchReturnsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<super::target::TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn build(self) -> Result<LaunchReturns, String> {
+                Ok(LaunchReturns {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for LaunchParams {
+            type Response = LaunchReturns;
+        }
+        #[doc = "Opens one or more local files from an installed web app identified by its\nmanifestId. The web app needs to have file handlers registered to process\nthe files. The API returns one or more page Target.TargetIDs which can be\nused to attach to via Target.attachToTarget or similar APIs.\nIf some files in the parameters cannot be handled by the web app, they will\nbe ignored. If none of the files can be handled, this API returns an error.\nIf no files are provided as the parameter, this API also returns an error.\n\nAccording to the definition of the file handlers in the manifest file, one\nTarget.TargetID may represent a page handling one or more files. The order\nof the returned Target.TargetIDs is not guaranteed.\n\nTODO(crbug.com/339454034): Check the existences of the input files.\n[launchFilesInApp](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-launchFilesInApp)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LaunchFilesInAppParams {
+            #[serde(rename = "manifestId")]
+            pub manifest_id: String,
+            #[serde(rename = "files")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub files: Vec<String>,
+        }
+        impl LaunchFilesInAppParams {
+            pub fn new(manifest_id: impl Into<String>, files: Vec<String>) -> Self {
+                Self {
+                    manifest_id: manifest_id.into(),
+                    files,
+                }
+            }
+        }
+        impl LaunchFilesInAppParams {
+            pub fn builder() -> LaunchFilesInAppParamsBuilder {
+                LaunchFilesInAppParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LaunchFilesInAppParamsBuilder {
+            manifest_id: Option<String>,
+            files: Option<Vec<String>>,
+        }
+        impl LaunchFilesInAppParamsBuilder {
+            pub fn manifest_id(mut self, manifest_id: impl Into<String>) -> Self {
+                self.manifest_id = Some(manifest_id.into());
+                self
+            }
+            pub fn file(mut self, file: impl Into<String>) -> Self {
+                let v = self.files.get_or_insert(Vec::new());
+                v.push(file.into());
+                self
+            }
+            pub fn files<I, S>(mut self, files: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.files.get_or_insert(Vec::new());
+                for val in files {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<LaunchFilesInAppParams, String> {
+                Ok(LaunchFilesInAppParams {
+                    manifest_id: self.manifest_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(manifest_id))
+                    })?,
+                    files: self.files.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(files))
+                    })?,
+                })
+            }
+        }
+        impl LaunchFilesInAppParams {
+            pub const IDENTIFIER: &'static str = "PWA.launchFilesInApp";
+        }
+        impl chromiumoxide_types::Method for LaunchFilesInAppParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for LaunchFilesInAppParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Opens one or more local files from an installed web app identified by its\nmanifestId. The web app needs to have file handlers registered to process\nthe files. The API returns one or more page Target.TargetIDs which can be\nused to attach to via Target.attachToTarget or similar APIs.\nIf some files in the parameters cannot be handled by the web app, they will\nbe ignored. If none of the files can be handled, this API returns an error.\nIf no files are provided as the parameter, this API also returns an error.\n\nAccording to the definition of the file handlers in the manifest file, one\nTarget.TargetID may represent a page handling one or more files. The order\nof the returned Target.TargetIDs is not guaranteed.\n\nTODO(crbug.com/339454034): Check the existences of the input files.\n[launchFilesInApp](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-launchFilesInApp)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LaunchFilesInAppReturns {
+            #[doc = "IDs of the tab targets created as the result."]
+            #[serde(rename = "targetIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub target_ids: Vec<super::target::TargetId>,
+        }
+        impl LaunchFilesInAppReturns {
+            pub fn new(target_ids: Vec<super::target::TargetId>) -> Self {
+                Self { target_ids }
+            }
+        }
+        impl LaunchFilesInAppReturns {
+            pub fn builder() -> LaunchFilesInAppReturnsBuilder {
+                LaunchFilesInAppReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LaunchFilesInAppReturnsBuilder {
+            target_ids: Option<Vec<super::target::TargetId>>,
+        }
+        impl LaunchFilesInAppReturnsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<super::target::TargetId>) -> Self {
+                let v = self.target_ids.get_or_insert(Vec::new());
+                v.push(target_id.into());
+                self
+            }
+            pub fn target_ids<I, S>(mut self, target_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::target::TargetId>,
+            {
+                let v = self.target_ids.get_or_insert(Vec::new());
+                for val in target_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<LaunchFilesInAppReturns, String> {
+                Ok(LaunchFilesInAppReturns {
+                    target_ids: self.target_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_ids))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for LaunchFilesInAppParams {
+            type Response = LaunchFilesInAppReturns;
+        }
+        #[doc = "Opens the current page in its web app identified by the manifest id, needs\nto be called on a page target. This function returns immediately without\nwaiting for the app to finish loading.\n[openCurrentPageInApp](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-openCurrentPageInApp)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct OpenCurrentPageInAppParams {
+            #[serde(rename = "manifestId")]
+            pub manifest_id: String,
+        }
+        impl OpenCurrentPageInAppParams {
+            pub fn new(manifest_id: impl Into<String>) -> Self {
+                Self {
+                    manifest_id: manifest_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for OpenCurrentPageInAppParams {
+            fn from(url: T) -> Self {
+                OpenCurrentPageInAppParams::new(url)
+            }
+        }
+        impl OpenCurrentPageInAppParams {
+            pub fn builder() -> OpenCurrentPageInAppParamsBuilder {
+                OpenCurrentPageInAppParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct OpenCurrentPageInAppParamsBuilder {
+            manifest_id: Option<String>,
+        }
+        impl OpenCurrentPageInAppParamsBuilder {
+            pub fn manifest_id(mut self, manifest_id: impl Into<String>) -> Self {
+                self.manifest_id = Some(manifest_id.into());
+                self
+            }
+            pub fn build(self) -> Result<OpenCurrentPageInAppParams, String> {
+                Ok(OpenCurrentPageInAppParams {
+                    manifest_id: self.manifest_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(manifest_id))
+                    })?,
+                })
+            }
+        }
+        impl OpenCurrentPageInAppParams {
+            pub const IDENTIFIER: &'static str = "PWA.openCurrentPageInApp";
+        }
+        impl chromiumoxide_types::Method for OpenCurrentPageInAppParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for OpenCurrentPageInAppParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Opens the current page in its web app identified by the manifest id, needs\nto be called on a page target. This function returns immediately without\nwaiting for the app to finish loading.\n[openCurrentPageInApp](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-openCurrentPageInApp)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct OpenCurrentPageInAppReturns {}
+        impl chromiumoxide_types::Command for OpenCurrentPageInAppParams {
+            type Response = OpenCurrentPageInAppReturns;
+        }
+        #[doc = "Changes user settings of the web app identified by its manifestId. If the\napp was not installed, this command returns an error. Unset parameters will\nbe ignored; unrecognized values will cause an error.\n\nUnlike the ones defined in the manifest files of the web apps, these\nsettings are provided by the browser and controlled by the users, they\nimpact the way the browser handling the web apps.\n\nSee the comment of each parameter.\n[changeAppUserSettings](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-changeAppUserSettings)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ChangeAppUserSettingsParams {
+            #[serde(rename = "manifestId")]
+            pub manifest_id: String,
+            #[doc = "If user allows the links clicked on by the user in the app's scope, or\nextended scope if the manifest has scope extensions and the flags\n`DesktopPWAsLinkCapturingWithScopeExtensions` and\n`WebAppEnableScopeExtensions` are enabled.\n\nNote, the API does not support resetting the linkCapturing to the\ninitial value, uninstalling and installing the web app again will reset\nit.\n\nTODO(crbug.com/339453269): Setting this value on ChromeOS is not\nsupported yet."]
+            #[serde(rename = "linkCapturing")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub link_capturing: Option<bool>,
+            #[serde(rename = "displayMode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub display_mode: Option<DisplayMode>,
+        }
+        impl ChangeAppUserSettingsParams {
+            pub fn new(manifest_id: impl Into<String>) -> Self {
+                Self {
+                    manifest_id: manifest_id.into(),
+                    link_capturing: None,
+                    display_mode: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for ChangeAppUserSettingsParams {
+            fn from(url: T) -> Self {
+                ChangeAppUserSettingsParams::new(url)
+            }
+        }
+        impl ChangeAppUserSettingsParams {
+            pub fn builder() -> ChangeAppUserSettingsParamsBuilder {
+                ChangeAppUserSettingsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ChangeAppUserSettingsParamsBuilder {
+            manifest_id: Option<String>,
+            link_capturing: Option<bool>,
+            display_mode: Option<DisplayMode>,
+        }
+        impl ChangeAppUserSettingsParamsBuilder {
+            pub fn manifest_id(mut self, manifest_id: impl Into<String>) -> Self {
+                self.manifest_id = Some(manifest_id.into());
+                self
+            }
+            pub fn link_capturing(mut self, link_capturing: impl Into<bool>) -> Self {
+                self.link_capturing = Some(link_capturing.into());
+                self
+            }
+            pub fn display_mode(mut self, display_mode: impl Into<DisplayMode>) -> Self {
+                self.display_mode = Some(display_mode.into());
+                self
+            }
+            pub fn build(self) -> Result<ChangeAppUserSettingsParams, String> {
+                Ok(ChangeAppUserSettingsParams {
+                    manifest_id: self.manifest_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(manifest_id))
+                    })?,
+                    link_capturing: self.link_capturing,
+                    display_mode: self.display_mode,
+                })
+            }
+        }
+        impl ChangeAppUserSettingsParams {
+            pub const IDENTIFIER: &'static str = "PWA.changeAppUserSettings";
+        }
+        impl chromiumoxide_types::Method for ChangeAppUserSettingsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ChangeAppUserSettingsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Changes user settings of the web app identified by its manifestId. If the\napp was not installed, this command returns an error. Unset parameters will\nbe ignored; unrecognized values will cause an error.\n\nUnlike the ones defined in the manifest files of the web apps, these\nsettings are provided by the browser and controlled by the users, they\nimpact the way the browser handling the web apps.\n\nSee the comment of each parameter.\n[changeAppUserSettings](https://chromedevtools.github.io/devtools-protocol/tot/PWA/#method-changeAppUserSettings)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ChangeAppUserSettingsReturns {}
+        impl chromiumoxide_types::Command for ChangeAppUserSettingsParams {
+            type Response = ChangeAppUserSettingsReturns;
+        }
+    }
+    #[doc = "Actions and events related to the inspected page belong to the page domain."]
+    pub mod page {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Unique frame identifier.\n[FrameId](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-FrameId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct FrameId(String);
+        impl FrameId {
+            pub fn new(val: impl Into<String>) -> Self {
+                FrameId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for FrameId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<FrameId> for String {
+            fn from(el: FrameId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for FrameId {
+            fn from(expr: String) -> Self {
+                FrameId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for FrameId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl FrameId {
+            pub const IDENTIFIER: &'static str = "Page.FrameId";
+        }
+        #[doc = "Indicates whether a frame has been identified as an ad."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AdFrameType {
+            #[serde(rename = "none")]
+            None,
+            #[doc = "This frame is a subframe of an ad frame."]
+            #[serde(rename = "child")]
+            Child,
+            #[doc = "This frame is the root of an ad frame."]
+            #[serde(rename = "root")]
+            Root,
+        }
+        impl AsRef<str> for AdFrameType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AdFrameType::None => "none",
+                    AdFrameType::Child => "child",
+                    AdFrameType::Root => "root",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AdFrameType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "none" | "None" => Ok(AdFrameType::None),
+                    "child" | "Child" => Ok(AdFrameType::Child),
+                    "root" | "Root" => Ok(AdFrameType::Root),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AdFrameExplanation {
+            #[serde(rename = "ParentIsAd")]
+            ParentIsAd,
+            #[serde(rename = "CreatedByAdScript")]
+            CreatedByAdScript,
+            #[serde(rename = "MatchedBlockingRule")]
+            MatchedBlockingRule,
+        }
+        impl AsRef<str> for AdFrameExplanation {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AdFrameExplanation::ParentIsAd => "ParentIsAd",
+                    AdFrameExplanation::CreatedByAdScript => "CreatedByAdScript",
+                    AdFrameExplanation::MatchedBlockingRule => "MatchedBlockingRule",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AdFrameExplanation {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "ParentIsAd" | "parentisad" => Ok(AdFrameExplanation::ParentIsAd),
+                    "CreatedByAdScript" | "createdbyadscript" => {
+                        Ok(AdFrameExplanation::CreatedByAdScript)
+                    }
+                    "MatchedBlockingRule" | "matchedblockingrule" => {
+                        Ok(AdFrameExplanation::MatchedBlockingRule)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Indicates whether a frame has been identified as an ad and why.\n[AdFrameStatus](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-AdFrameStatus)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AdFrameStatus {
+            #[serde(rename = "adFrameType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub ad_frame_type: AdFrameType,
+            #[serde(rename = "explanations")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub explanations: Option<Vec<AdFrameExplanation>>,
+        }
+        impl AdFrameStatus {
+            pub fn new(ad_frame_type: impl Into<AdFrameType>) -> Self {
+                Self {
+                    ad_frame_type: ad_frame_type.into(),
+                    explanations: None,
+                }
+            }
+        }
+        impl AdFrameStatus {
+            pub fn builder() -> AdFrameStatusBuilder {
+                AdFrameStatusBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AdFrameStatusBuilder {
+            ad_frame_type: Option<AdFrameType>,
+            explanations: Option<Vec<AdFrameExplanation>>,
+        }
+        impl AdFrameStatusBuilder {
+            pub fn ad_frame_type(mut self, ad_frame_type: impl Into<AdFrameType>) -> Self {
+                self.ad_frame_type = Some(ad_frame_type.into());
+                self
+            }
+            pub fn explanation(mut self, explanation: impl Into<AdFrameExplanation>) -> Self {
+                let v = self.explanations.get_or_insert(Vec::new());
+                v.push(explanation.into());
+                self
+            }
+            pub fn explanations<I, S>(mut self, explanations: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AdFrameExplanation>,
+            {
+                let v = self.explanations.get_or_insert(Vec::new());
+                for val in explanations {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<AdFrameStatus, String> {
+                Ok(AdFrameStatus {
+                    ad_frame_type: self.ad_frame_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ad_frame_type))
+                    })?,
+                    explanations: self.explanations,
+                })
+            }
+        }
+        impl AdFrameStatus {
+            pub const IDENTIFIER: &'static str = "Page.AdFrameStatus";
+        }
+        #[doc = "Identifies the script which caused a script or frame to be labelled as an\nad.\n[AdScriptId](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-AdScriptId)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AdScriptId {
+            #[doc = "Script Id of the script which caused a script or frame to be labelled as\nan ad."]
+            #[serde(rename = "scriptId")]
+            pub script_id: super::super::js_protocol::runtime::ScriptId,
+            #[doc = "Id of scriptId's debugger."]
+            #[serde(rename = "debuggerId")]
+            pub debugger_id: super::super::js_protocol::runtime::UniqueDebuggerId,
+        }
+        impl AdScriptId {
+            pub fn new(
+                script_id: impl Into<super::super::js_protocol::runtime::ScriptId>,
+                debugger_id: impl Into<super::super::js_protocol::runtime::UniqueDebuggerId>,
+            ) -> Self {
+                Self {
+                    script_id: script_id.into(),
+                    debugger_id: debugger_id.into(),
+                }
+            }
+        }
+        impl AdScriptId {
+            pub fn builder() -> AdScriptIdBuilder {
+                AdScriptIdBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AdScriptIdBuilder {
+            script_id: Option<super::super::js_protocol::runtime::ScriptId>,
+            debugger_id: Option<super::super::js_protocol::runtime::UniqueDebuggerId>,
+        }
+        impl AdScriptIdBuilder {
+            pub fn script_id(
+                mut self,
+                script_id: impl Into<super::super::js_protocol::runtime::ScriptId>,
+            ) -> Self {
+                self.script_id = Some(script_id.into());
+                self
+            }
+            pub fn debugger_id(
+                mut self,
+                debugger_id: impl Into<super::super::js_protocol::runtime::UniqueDebuggerId>,
+            ) -> Self {
+                self.debugger_id = Some(debugger_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AdScriptId, String> {
+                Ok(AdScriptId {
+                    script_id: self.script_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_id))
+                    })?,
+                    debugger_id: self.debugger_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(debugger_id))
+                    })?,
+                })
+            }
+        }
+        impl AdScriptId {
+            pub const IDENTIFIER: &'static str = "Page.AdScriptId";
+        }
+        #[doc = "Encapsulates the script ancestry and the root script filterlist rule that\ncaused the frame to be labelled as an ad. Only created when `ancestryChain`\nis not empty.\n[AdScriptAncestry](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-AdScriptAncestry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AdScriptAncestry {
+            #[doc = "A chain of `AdScriptId`s representing the ancestry of an ad script that\nled to the creation of a frame. The chain is ordered from the script\nitself (lower level) up to its root ancestor that was flagged by\nfilterlist."]
+            #[serde(rename = "ancestryChain")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub ancestry_chain: Vec<AdScriptId>,
+            #[doc = "The filterlist rule that caused the root (last) script in\n`ancestryChain` to be ad-tagged. Only populated if the rule is\navailable."]
+            #[serde(rename = "rootScriptFilterlistRule")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub root_script_filterlist_rule: Option<String>,
+        }
+        impl AdScriptAncestry {
+            pub fn new(ancestry_chain: Vec<AdScriptId>) -> Self {
+                Self {
+                    ancestry_chain,
+                    root_script_filterlist_rule: None,
+                }
+            }
+        }
+        impl AdScriptAncestry {
+            pub fn builder() -> AdScriptAncestryBuilder {
+                AdScriptAncestryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AdScriptAncestryBuilder {
+            ancestry_chain: Option<Vec<AdScriptId>>,
+            root_script_filterlist_rule: Option<String>,
+        }
+        impl AdScriptAncestryBuilder {
+            pub fn ancestry_chain(mut self, ancestry_chain: impl Into<AdScriptId>) -> Self {
+                let v = self.ancestry_chain.get_or_insert(Vec::new());
+                v.push(ancestry_chain.into());
+                self
+            }
+            pub fn ancestry_chains<I, S>(mut self, ancestry_chains: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AdScriptId>,
+            {
+                let v = self.ancestry_chain.get_or_insert(Vec::new());
+                for val in ancestry_chains {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn root_script_filterlist_rule(
+                mut self,
+                root_script_filterlist_rule: impl Into<String>,
+            ) -> Self {
+                self.root_script_filterlist_rule = Some(root_script_filterlist_rule.into());
+                self
+            }
+            pub fn build(self) -> Result<AdScriptAncestry, String> {
+                Ok(AdScriptAncestry {
+                    ancestry_chain: self.ancestry_chain.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ancestry_chain))
+                    })?,
+                    root_script_filterlist_rule: self.root_script_filterlist_rule,
+                })
+            }
+        }
+        impl AdScriptAncestry {
+            pub const IDENTIFIER: &'static str = "Page.AdScriptAncestry";
+        }
+        #[doc = "Indicates whether the frame is a secure context and why it is the case."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SecureContextType {
+            #[doc = "The origin is a secure context."]
+            #[serde(rename = "Secure")]
+            Secure,
+            #[doc = "The host is localhost and hence is considered secure."]
+            #[serde(rename = "SecureLocalhost")]
+            SecureLocalhost,
+            #[doc = "The origin has an insecure scheme and is not localhost."]
+            #[serde(rename = "InsecureScheme")]
+            InsecureScheme,
+            #[doc = "One of the ancestor frames is not a secure context."]
+            #[serde(rename = "InsecureAncestor")]
+            InsecureAncestor,
+        }
+        impl AsRef<str> for SecureContextType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SecureContextType::Secure => "Secure",
+                    SecureContextType::SecureLocalhost => "SecureLocalhost",
+                    SecureContextType::InsecureScheme => "InsecureScheme",
+                    SecureContextType::InsecureAncestor => "InsecureAncestor",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SecureContextType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Secure" | "secure" => Ok(SecureContextType::Secure),
+                    "SecureLocalhost" | "securelocalhost" => Ok(SecureContextType::SecureLocalhost),
+                    "InsecureScheme" | "insecurescheme" => Ok(SecureContextType::InsecureScheme),
+                    "InsecureAncestor" | "insecureancestor" => {
+                        Ok(SecureContextType::InsecureAncestor)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Indicates whether the frame is cross-origin isolated and why it is the case."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CrossOriginIsolatedContextType {
+            #[doc = "The origin is cross-origin isolated."]
+            #[serde(rename = "Isolated")]
+            Isolated,
+            #[doc = "The origin is not cross-origin isolated."]
+            #[serde(rename = "NotIsolated")]
+            NotIsolated,
+            #[doc = "The cross-origin isolation feature is disabled."]
+            #[serde(rename = "NotIsolatedFeatureDisabled")]
+            NotIsolatedFeatureDisabled,
+        }
+        impl AsRef<str> for CrossOriginIsolatedContextType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CrossOriginIsolatedContextType::Isolated => "Isolated",
+                    CrossOriginIsolatedContextType::NotIsolated => "NotIsolated",
+                    CrossOriginIsolatedContextType::NotIsolatedFeatureDisabled => {
+                        "NotIsolatedFeatureDisabled"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for CrossOriginIsolatedContextType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Isolated" | "isolated" => Ok(CrossOriginIsolatedContextType::Isolated),
+                    "NotIsolated" | "notisolated" => {
+                        Ok(CrossOriginIsolatedContextType::NotIsolated)
+                    }
+                    "NotIsolatedFeatureDisabled" | "notisolatedfeaturedisabled" => {
+                        Ok(CrossOriginIsolatedContextType::NotIsolatedFeatureDisabled)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum GatedApiFeatures {
+            #[serde(rename = "SharedArrayBuffers")]
+            SharedArrayBuffers,
+            #[serde(rename = "SharedArrayBuffersTransferAllowed")]
+            SharedArrayBuffersTransferAllowed,
+            #[serde(rename = "PerformanceMeasureMemory")]
+            PerformanceMeasureMemory,
+            #[serde(rename = "PerformanceProfile")]
+            PerformanceProfile,
+        }
+        impl AsRef<str> for GatedApiFeatures {
+            fn as_ref(&self) -> &str {
+                match self {
+                    GatedApiFeatures::SharedArrayBuffers => "SharedArrayBuffers",
+                    GatedApiFeatures::SharedArrayBuffersTransferAllowed => {
+                        "SharedArrayBuffersTransferAllowed"
+                    }
+                    GatedApiFeatures::PerformanceMeasureMemory => "PerformanceMeasureMemory",
+                    GatedApiFeatures::PerformanceProfile => "PerformanceProfile",
+                }
+            }
+        }
+        impl ::std::str::FromStr for GatedApiFeatures {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "SharedArrayBuffers" | "sharedarraybuffers" => {
+                        Ok(GatedApiFeatures::SharedArrayBuffers)
+                    }
+                    "SharedArrayBuffersTransferAllowed" | "sharedarraybufferstransferallowed" => {
+                        Ok(GatedApiFeatures::SharedArrayBuffersTransferAllowed)
+                    }
+                    "PerformanceMeasureMemory" | "performancemeasurememory" => {
+                        Ok(GatedApiFeatures::PerformanceMeasureMemory)
+                    }
+                    "PerformanceProfile" | "performanceprofile" => {
+                        Ok(GatedApiFeatures::PerformanceProfile)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "All Permissions Policy features. This enum should match the one defined\nin services/network/public/cpp/permissions_policy/permissions_policy_features.json5.\nLINT.IfChange(PermissionsPolicyFeature)"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PermissionsPolicyFeature {
+            #[serde(rename = "accelerometer")]
+            Accelerometer,
+            #[serde(rename = "all-screens-capture")]
+            AllScreensCapture,
+            #[serde(rename = "ambient-light-sensor")]
+            AmbientLightSensor,
+            #[serde(rename = "aria-notify")]
+            AriaNotify,
+            #[serde(rename = "attribution-reporting")]
+            AttributionReporting,
+            #[serde(rename = "autofill")]
+            Autofill,
+            #[serde(rename = "autoplay")]
+            Autoplay,
+            #[serde(rename = "bluetooth")]
+            Bluetooth,
+            #[serde(rename = "browsing-topics")]
+            BrowsingTopics,
+            #[serde(rename = "camera")]
+            Camera,
+            #[serde(rename = "captured-surface-control")]
+            CapturedSurfaceControl,
+            #[serde(rename = "ch-dpr")]
+            ChDpr,
+            #[serde(rename = "ch-device-memory")]
+            ChDeviceMemory,
+            #[serde(rename = "ch-downlink")]
+            ChDownlink,
+            #[serde(rename = "ch-ect")]
+            ChEct,
+            #[serde(rename = "ch-prefers-color-scheme")]
+            ChPrefersColorScheme,
+            #[serde(rename = "ch-prefers-reduced-motion")]
+            ChPrefersReducedMotion,
+            #[serde(rename = "ch-prefers-reduced-transparency")]
+            ChPrefersReducedTransparency,
+            #[serde(rename = "ch-rtt")]
+            ChRtt,
+            #[serde(rename = "ch-save-data")]
+            ChSaveData,
+            #[serde(rename = "ch-ua")]
+            ChUa,
+            #[serde(rename = "ch-ua-arch")]
+            ChUaArch,
+            #[serde(rename = "ch-ua-bitness")]
+            ChUaBitness,
+            #[serde(rename = "ch-ua-high-entropy-values")]
+            ChUaHighEntropyValues,
+            #[serde(rename = "ch-ua-platform")]
+            ChUaPlatform,
+            #[serde(rename = "ch-ua-model")]
+            ChUaModel,
+            #[serde(rename = "ch-ua-mobile")]
+            ChUaMobile,
+            #[serde(rename = "ch-ua-form-factors")]
+            ChUaFormFactors,
+            #[serde(rename = "ch-ua-full-version")]
+            ChUaFullVersion,
+            #[serde(rename = "ch-ua-full-version-list")]
+            ChUaFullVersionList,
+            #[serde(rename = "ch-ua-platform-version")]
+            ChUaPlatformVersion,
+            #[serde(rename = "ch-ua-wow64")]
+            ChUaWow64,
+            #[serde(rename = "ch-viewport-height")]
+            ChViewportHeight,
+            #[serde(rename = "ch-viewport-width")]
+            ChViewportWidth,
+            #[serde(rename = "ch-width")]
+            ChWidth,
+            #[serde(rename = "clipboard-read")]
+            ClipboardRead,
+            #[serde(rename = "clipboard-write")]
+            ClipboardWrite,
+            #[serde(rename = "compute-pressure")]
+            ComputePressure,
+            #[serde(rename = "controlled-frame")]
+            ControlledFrame,
+            #[serde(rename = "cross-origin-isolated")]
+            CrossOriginIsolated,
+            #[serde(rename = "deferred-fetch")]
+            DeferredFetch,
+            #[serde(rename = "deferred-fetch-minimal")]
+            DeferredFetchMinimal,
+            #[serde(rename = "device-attributes")]
+            DeviceAttributes,
+            #[serde(rename = "digital-credentials-create")]
+            DigitalCredentialsCreate,
+            #[serde(rename = "digital-credentials-get")]
+            DigitalCredentialsGet,
+            #[serde(rename = "direct-sockets")]
+            DirectSockets,
+            #[serde(rename = "direct-sockets-multicast")]
+            DirectSocketsMulticast,
+            #[serde(rename = "direct-sockets-private")]
+            DirectSocketsPrivate,
+            #[serde(rename = "display-capture")]
+            DisplayCapture,
+            #[serde(rename = "document-domain")]
+            DocumentDomain,
+            #[serde(rename = "encrypted-media")]
+            EncryptedMedia,
+            #[serde(rename = "execution-while-out-of-viewport")]
+            ExecutionWhileOutOfViewport,
+            #[serde(rename = "execution-while-not-rendered")]
+            ExecutionWhileNotRendered,
+            #[serde(rename = "fenced-unpartitioned-storage-read")]
+            FencedUnpartitionedStorageRead,
+            #[serde(rename = "focus-without-user-activation")]
+            FocusWithoutUserActivation,
+            #[serde(rename = "fullscreen")]
+            Fullscreen,
+            #[serde(rename = "frobulate")]
+            Frobulate,
+            #[serde(rename = "gamepad")]
+            Gamepad,
+            #[serde(rename = "geolocation")]
+            Geolocation,
+            #[serde(rename = "gyroscope")]
+            Gyroscope,
+            #[serde(rename = "hid")]
+            Hid,
+            #[serde(rename = "identity-credentials-get")]
+            IdentityCredentialsGet,
+            #[serde(rename = "idle-detection")]
+            IdleDetection,
+            #[serde(rename = "interest-cohort")]
+            InterestCohort,
+            #[serde(rename = "join-ad-interest-group")]
+            JoinAdInterestGroup,
+            #[serde(rename = "keyboard-map")]
+            KeyboardMap,
+            #[serde(rename = "language-detector")]
+            LanguageDetector,
+            #[serde(rename = "language-model")]
+            LanguageModel,
+            #[serde(rename = "local-fonts")]
+            LocalFonts,
+            #[serde(rename = "local-network")]
+            LocalNetwork,
+            #[serde(rename = "local-network-access")]
+            LocalNetworkAccess,
+            #[serde(rename = "loopback-network")]
+            LoopbackNetwork,
+            #[serde(rename = "magnetometer")]
+            Magnetometer,
+            #[serde(rename = "manual-text")]
+            ManualText,
+            #[serde(rename = "media-playback-while-not-visible")]
+            MediaPlaybackWhileNotVisible,
+            #[serde(rename = "microphone")]
+            Microphone,
+            #[serde(rename = "midi")]
+            Midi,
+            #[serde(rename = "on-device-speech-recognition")]
+            OnDeviceSpeechRecognition,
+            #[serde(rename = "otp-credentials")]
+            OtpCredentials,
+            #[serde(rename = "payment")]
+            Payment,
+            #[serde(rename = "picture-in-picture")]
+            PictureInPicture,
+            #[serde(rename = "private-aggregation")]
+            PrivateAggregation,
+            #[serde(rename = "private-state-token-issuance")]
+            PrivateStateTokenIssuance,
+            #[serde(rename = "private-state-token-redemption")]
+            PrivateStateTokenRedemption,
+            #[serde(rename = "publickey-credentials-create")]
+            PublickeyCredentialsCreate,
+            #[serde(rename = "publickey-credentials-get")]
+            PublickeyCredentialsGet,
+            #[serde(rename = "record-ad-auction-events")]
+            RecordAdAuctionEvents,
+            #[serde(rename = "rewriter")]
+            Rewriter,
+            #[serde(rename = "run-ad-auction")]
+            RunAdAuction,
+            #[serde(rename = "screen-wake-lock")]
+            ScreenWakeLock,
+            #[serde(rename = "serial")]
+            Serial,
+            #[serde(rename = "shared-storage")]
+            SharedStorage,
+            #[serde(rename = "shared-storage-select-url")]
+            SharedStorageSelectUrl,
+            #[serde(rename = "smart-card")]
+            SmartCard,
+            #[serde(rename = "speaker-selection")]
+            SpeakerSelection,
+            #[serde(rename = "storage-access")]
+            StorageAccess,
+            #[serde(rename = "sub-apps")]
+            SubApps,
+            #[serde(rename = "summarizer")]
+            Summarizer,
+            #[serde(rename = "sync-xhr")]
+            SyncXhr,
+            #[serde(rename = "translator")]
+            Translator,
+            #[serde(rename = "unload")]
+            Unload,
+            #[serde(rename = "usb")]
+            Usb,
+            #[serde(rename = "usb-unrestricted")]
+            UsbUnrestricted,
+            #[serde(rename = "vertical-scroll")]
+            VerticalScroll,
+            #[serde(rename = "web-app-installation")]
+            WebAppInstallation,
+            #[serde(rename = "web-printing")]
+            WebPrinting,
+            #[serde(rename = "web-share")]
+            WebShare,
+            #[serde(rename = "window-management")]
+            WindowManagement,
+            #[serde(rename = "writer")]
+            Writer,
+            #[serde(rename = "xr-spatial-tracking")]
+            XrSpatialTracking,
+        }
+        impl AsRef<str> for PermissionsPolicyFeature {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PermissionsPolicyFeature::Accelerometer => "accelerometer",
+                    PermissionsPolicyFeature::AllScreensCapture => "all-screens-capture",
+                    PermissionsPolicyFeature::AmbientLightSensor => "ambient-light-sensor",
+                    PermissionsPolicyFeature::AriaNotify => "aria-notify",
+                    PermissionsPolicyFeature::AttributionReporting => "attribution-reporting",
+                    PermissionsPolicyFeature::Autofill => "autofill",
+                    PermissionsPolicyFeature::Autoplay => "autoplay",
+                    PermissionsPolicyFeature::Bluetooth => "bluetooth",
+                    PermissionsPolicyFeature::BrowsingTopics => "browsing-topics",
+                    PermissionsPolicyFeature::Camera => "camera",
+                    PermissionsPolicyFeature::CapturedSurfaceControl => "captured-surface-control",
+                    PermissionsPolicyFeature::ChDpr => "ch-dpr",
+                    PermissionsPolicyFeature::ChDeviceMemory => "ch-device-memory",
+                    PermissionsPolicyFeature::ChDownlink => "ch-downlink",
+                    PermissionsPolicyFeature::ChEct => "ch-ect",
+                    PermissionsPolicyFeature::ChPrefersColorScheme => "ch-prefers-color-scheme",
+                    PermissionsPolicyFeature::ChPrefersReducedMotion => "ch-prefers-reduced-motion",
+                    PermissionsPolicyFeature::ChPrefersReducedTransparency => {
+                        "ch-prefers-reduced-transparency"
+                    }
+                    PermissionsPolicyFeature::ChRtt => "ch-rtt",
+                    PermissionsPolicyFeature::ChSaveData => "ch-save-data",
+                    PermissionsPolicyFeature::ChUa => "ch-ua",
+                    PermissionsPolicyFeature::ChUaArch => "ch-ua-arch",
+                    PermissionsPolicyFeature::ChUaBitness => "ch-ua-bitness",
+                    PermissionsPolicyFeature::ChUaHighEntropyValues => "ch-ua-high-entropy-values",
+                    PermissionsPolicyFeature::ChUaPlatform => "ch-ua-platform",
+                    PermissionsPolicyFeature::ChUaModel => "ch-ua-model",
+                    PermissionsPolicyFeature::ChUaMobile => "ch-ua-mobile",
+                    PermissionsPolicyFeature::ChUaFormFactors => "ch-ua-form-factors",
+                    PermissionsPolicyFeature::ChUaFullVersion => "ch-ua-full-version",
+                    PermissionsPolicyFeature::ChUaFullVersionList => "ch-ua-full-version-list",
+                    PermissionsPolicyFeature::ChUaPlatformVersion => "ch-ua-platform-version",
+                    PermissionsPolicyFeature::ChUaWow64 => "ch-ua-wow64",
+                    PermissionsPolicyFeature::ChViewportHeight => "ch-viewport-height",
+                    PermissionsPolicyFeature::ChViewportWidth => "ch-viewport-width",
+                    PermissionsPolicyFeature::ChWidth => "ch-width",
+                    PermissionsPolicyFeature::ClipboardRead => "clipboard-read",
+                    PermissionsPolicyFeature::ClipboardWrite => "clipboard-write",
+                    PermissionsPolicyFeature::ComputePressure => "compute-pressure",
+                    PermissionsPolicyFeature::ControlledFrame => "controlled-frame",
+                    PermissionsPolicyFeature::CrossOriginIsolated => "cross-origin-isolated",
+                    PermissionsPolicyFeature::DeferredFetch => "deferred-fetch",
+                    PermissionsPolicyFeature::DeferredFetchMinimal => "deferred-fetch-minimal",
+                    PermissionsPolicyFeature::DeviceAttributes => "device-attributes",
+                    PermissionsPolicyFeature::DigitalCredentialsCreate => {
+                        "digital-credentials-create"
+                    }
+                    PermissionsPolicyFeature::DigitalCredentialsGet => "digital-credentials-get",
+                    PermissionsPolicyFeature::DirectSockets => "direct-sockets",
+                    PermissionsPolicyFeature::DirectSocketsMulticast => "direct-sockets-multicast",
+                    PermissionsPolicyFeature::DirectSocketsPrivate => "direct-sockets-private",
+                    PermissionsPolicyFeature::DisplayCapture => "display-capture",
+                    PermissionsPolicyFeature::DocumentDomain => "document-domain",
+                    PermissionsPolicyFeature::EncryptedMedia => "encrypted-media",
+                    PermissionsPolicyFeature::ExecutionWhileOutOfViewport => {
+                        "execution-while-out-of-viewport"
+                    }
+                    PermissionsPolicyFeature::ExecutionWhileNotRendered => {
+                        "execution-while-not-rendered"
+                    }
+                    PermissionsPolicyFeature::FencedUnpartitionedStorageRead => {
+                        "fenced-unpartitioned-storage-read"
+                    }
+                    PermissionsPolicyFeature::FocusWithoutUserActivation => {
+                        "focus-without-user-activation"
+                    }
+                    PermissionsPolicyFeature::Fullscreen => "fullscreen",
+                    PermissionsPolicyFeature::Frobulate => "frobulate",
+                    PermissionsPolicyFeature::Gamepad => "gamepad",
+                    PermissionsPolicyFeature::Geolocation => "geolocation",
+                    PermissionsPolicyFeature::Gyroscope => "gyroscope",
+                    PermissionsPolicyFeature::Hid => "hid",
+                    PermissionsPolicyFeature::IdentityCredentialsGet => "identity-credentials-get",
+                    PermissionsPolicyFeature::IdleDetection => "idle-detection",
+                    PermissionsPolicyFeature::InterestCohort => "interest-cohort",
+                    PermissionsPolicyFeature::JoinAdInterestGroup => "join-ad-interest-group",
+                    PermissionsPolicyFeature::KeyboardMap => "keyboard-map",
+                    PermissionsPolicyFeature::LanguageDetector => "language-detector",
+                    PermissionsPolicyFeature::LanguageModel => "language-model",
+                    PermissionsPolicyFeature::LocalFonts => "local-fonts",
+                    PermissionsPolicyFeature::LocalNetwork => "local-network",
+                    PermissionsPolicyFeature::LocalNetworkAccess => "local-network-access",
+                    PermissionsPolicyFeature::LoopbackNetwork => "loopback-network",
+                    PermissionsPolicyFeature::Magnetometer => "magnetometer",
+                    PermissionsPolicyFeature::ManualText => "manual-text",
+                    PermissionsPolicyFeature::MediaPlaybackWhileNotVisible => {
+                        "media-playback-while-not-visible"
+                    }
+                    PermissionsPolicyFeature::Microphone => "microphone",
+                    PermissionsPolicyFeature::Midi => "midi",
+                    PermissionsPolicyFeature::OnDeviceSpeechRecognition => {
+                        "on-device-speech-recognition"
+                    }
+                    PermissionsPolicyFeature::OtpCredentials => "otp-credentials",
+                    PermissionsPolicyFeature::Payment => "payment",
+                    PermissionsPolicyFeature::PictureInPicture => "picture-in-picture",
+                    PermissionsPolicyFeature::PrivateAggregation => "private-aggregation",
+                    PermissionsPolicyFeature::PrivateStateTokenIssuance => {
+                        "private-state-token-issuance"
+                    }
+                    PermissionsPolicyFeature::PrivateStateTokenRedemption => {
+                        "private-state-token-redemption"
+                    }
+                    PermissionsPolicyFeature::PublickeyCredentialsCreate => {
+                        "publickey-credentials-create"
+                    }
+                    PermissionsPolicyFeature::PublickeyCredentialsGet => {
+                        "publickey-credentials-get"
+                    }
+                    PermissionsPolicyFeature::RecordAdAuctionEvents => "record-ad-auction-events",
+                    PermissionsPolicyFeature::Rewriter => "rewriter",
+                    PermissionsPolicyFeature::RunAdAuction => "run-ad-auction",
+                    PermissionsPolicyFeature::ScreenWakeLock => "screen-wake-lock",
+                    PermissionsPolicyFeature::Serial => "serial",
+                    PermissionsPolicyFeature::SharedStorage => "shared-storage",
+                    PermissionsPolicyFeature::SharedStorageSelectUrl => "shared-storage-select-url",
+                    PermissionsPolicyFeature::SmartCard => "smart-card",
+                    PermissionsPolicyFeature::SpeakerSelection => "speaker-selection",
+                    PermissionsPolicyFeature::StorageAccess => "storage-access",
+                    PermissionsPolicyFeature::SubApps => "sub-apps",
+                    PermissionsPolicyFeature::Summarizer => "summarizer",
+                    PermissionsPolicyFeature::SyncXhr => "sync-xhr",
+                    PermissionsPolicyFeature::Translator => "translator",
+                    PermissionsPolicyFeature::Unload => "unload",
+                    PermissionsPolicyFeature::Usb => "usb",
+                    PermissionsPolicyFeature::UsbUnrestricted => "usb-unrestricted",
+                    PermissionsPolicyFeature::VerticalScroll => "vertical-scroll",
+                    PermissionsPolicyFeature::WebAppInstallation => "web-app-installation",
+                    PermissionsPolicyFeature::WebPrinting => "web-printing",
+                    PermissionsPolicyFeature::WebShare => "web-share",
+                    PermissionsPolicyFeature::WindowManagement => "window-management",
+                    PermissionsPolicyFeature::Writer => "writer",
+                    PermissionsPolicyFeature::XrSpatialTracking => "xr-spatial-tracking",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PermissionsPolicyFeature {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "accelerometer" | "Accelerometer" => {
+                        Ok(PermissionsPolicyFeature::Accelerometer)
+                    }
+                    "all-screens-capture" | "AllScreensCapture" => {
+                        Ok(PermissionsPolicyFeature::AllScreensCapture)
+                    }
+                    "ambient-light-sensor" | "AmbientLightSensor" => {
+                        Ok(PermissionsPolicyFeature::AmbientLightSensor)
+                    }
+                    "aria-notify" | "AriaNotify" => Ok(PermissionsPolicyFeature::AriaNotify),
+                    "attribution-reporting" | "AttributionReporting" => {
+                        Ok(PermissionsPolicyFeature::AttributionReporting)
+                    }
+                    "autofill" | "Autofill" => Ok(PermissionsPolicyFeature::Autofill),
+                    "autoplay" | "Autoplay" => Ok(PermissionsPolicyFeature::Autoplay),
+                    "bluetooth" | "Bluetooth" => Ok(PermissionsPolicyFeature::Bluetooth),
+                    "browsing-topics" | "BrowsingTopics" => {
+                        Ok(PermissionsPolicyFeature::BrowsingTopics)
+                    }
+                    "camera" | "Camera" => Ok(PermissionsPolicyFeature::Camera),
+                    "captured-surface-control" | "CapturedSurfaceControl" => {
+                        Ok(PermissionsPolicyFeature::CapturedSurfaceControl)
+                    }
+                    "ch-dpr" | "ChDpr" => Ok(PermissionsPolicyFeature::ChDpr),
+                    "ch-device-memory" | "ChDeviceMemory" => {
+                        Ok(PermissionsPolicyFeature::ChDeviceMemory)
+                    }
+                    "ch-downlink" | "ChDownlink" => Ok(PermissionsPolicyFeature::ChDownlink),
+                    "ch-ect" | "ChEct" => Ok(PermissionsPolicyFeature::ChEct),
+                    "ch-prefers-color-scheme" | "ChPrefersColorScheme" => {
+                        Ok(PermissionsPolicyFeature::ChPrefersColorScheme)
+                    }
+                    "ch-prefers-reduced-motion" | "ChPrefersReducedMotion" => {
+                        Ok(PermissionsPolicyFeature::ChPrefersReducedMotion)
+                    }
+                    "ch-prefers-reduced-transparency" | "ChPrefersReducedTransparency" => {
+                        Ok(PermissionsPolicyFeature::ChPrefersReducedTransparency)
+                    }
+                    "ch-rtt" | "ChRtt" => Ok(PermissionsPolicyFeature::ChRtt),
+                    "ch-save-data" | "ChSaveData" => Ok(PermissionsPolicyFeature::ChSaveData),
+                    "ch-ua" | "ChUa" => Ok(PermissionsPolicyFeature::ChUa),
+                    "ch-ua-arch" | "ChUaArch" => Ok(PermissionsPolicyFeature::ChUaArch),
+                    "ch-ua-bitness" | "ChUaBitness" => Ok(PermissionsPolicyFeature::ChUaBitness),
+                    "ch-ua-high-entropy-values" | "ChUaHighEntropyValues" => {
+                        Ok(PermissionsPolicyFeature::ChUaHighEntropyValues)
+                    }
+                    "ch-ua-platform" | "ChUaPlatform" => Ok(PermissionsPolicyFeature::ChUaPlatform),
+                    "ch-ua-model" | "ChUaModel" => Ok(PermissionsPolicyFeature::ChUaModel),
+                    "ch-ua-mobile" | "ChUaMobile" => Ok(PermissionsPolicyFeature::ChUaMobile),
+                    "ch-ua-form-factors" | "ChUaFormFactors" => {
+                        Ok(PermissionsPolicyFeature::ChUaFormFactors)
+                    }
+                    "ch-ua-full-version" | "ChUaFullVersion" => {
+                        Ok(PermissionsPolicyFeature::ChUaFullVersion)
+                    }
+                    "ch-ua-full-version-list" | "ChUaFullVersionList" => {
+                        Ok(PermissionsPolicyFeature::ChUaFullVersionList)
+                    }
+                    "ch-ua-platform-version" | "ChUaPlatformVersion" => {
+                        Ok(PermissionsPolicyFeature::ChUaPlatformVersion)
+                    }
+                    "ch-ua-wow64" | "ChUaWow64" => Ok(PermissionsPolicyFeature::ChUaWow64),
+                    "ch-viewport-height" | "ChViewportHeight" => {
+                        Ok(PermissionsPolicyFeature::ChViewportHeight)
+                    }
+                    "ch-viewport-width" | "ChViewportWidth" => {
+                        Ok(PermissionsPolicyFeature::ChViewportWidth)
+                    }
+                    "ch-width" | "ChWidth" => Ok(PermissionsPolicyFeature::ChWidth),
+                    "clipboard-read" | "ClipboardRead" => {
+                        Ok(PermissionsPolicyFeature::ClipboardRead)
+                    }
+                    "clipboard-write" | "ClipboardWrite" => {
+                        Ok(PermissionsPolicyFeature::ClipboardWrite)
+                    }
+                    "compute-pressure" | "ComputePressure" => {
+                        Ok(PermissionsPolicyFeature::ComputePressure)
+                    }
+                    "controlled-frame" | "ControlledFrame" => {
+                        Ok(PermissionsPolicyFeature::ControlledFrame)
+                    }
+                    "cross-origin-isolated" | "CrossOriginIsolated" => {
+                        Ok(PermissionsPolicyFeature::CrossOriginIsolated)
+                    }
+                    "deferred-fetch" | "DeferredFetch" => {
+                        Ok(PermissionsPolicyFeature::DeferredFetch)
+                    }
+                    "deferred-fetch-minimal" | "DeferredFetchMinimal" => {
+                        Ok(PermissionsPolicyFeature::DeferredFetchMinimal)
+                    }
+                    "device-attributes" | "DeviceAttributes" => {
+                        Ok(PermissionsPolicyFeature::DeviceAttributes)
+                    }
+                    "digital-credentials-create" | "DigitalCredentialsCreate" => {
+                        Ok(PermissionsPolicyFeature::DigitalCredentialsCreate)
+                    }
+                    "digital-credentials-get" | "DigitalCredentialsGet" => {
+                        Ok(PermissionsPolicyFeature::DigitalCredentialsGet)
+                    }
+                    "direct-sockets" | "DirectSockets" => {
+                        Ok(PermissionsPolicyFeature::DirectSockets)
+                    }
+                    "direct-sockets-multicast" | "DirectSocketsMulticast" => {
+                        Ok(PermissionsPolicyFeature::DirectSocketsMulticast)
+                    }
+                    "direct-sockets-private" | "DirectSocketsPrivate" => {
+                        Ok(PermissionsPolicyFeature::DirectSocketsPrivate)
+                    }
+                    "display-capture" | "DisplayCapture" => {
+                        Ok(PermissionsPolicyFeature::DisplayCapture)
+                    }
+                    "document-domain" | "DocumentDomain" => {
+                        Ok(PermissionsPolicyFeature::DocumentDomain)
+                    }
+                    "encrypted-media" | "EncryptedMedia" => {
+                        Ok(PermissionsPolicyFeature::EncryptedMedia)
+                    }
+                    "execution-while-out-of-viewport" | "ExecutionWhileOutOfViewport" => {
+                        Ok(PermissionsPolicyFeature::ExecutionWhileOutOfViewport)
+                    }
+                    "execution-while-not-rendered" | "ExecutionWhileNotRendered" => {
+                        Ok(PermissionsPolicyFeature::ExecutionWhileNotRendered)
+                    }
+                    "fenced-unpartitioned-storage-read" | "FencedUnpartitionedStorageRead" => {
+                        Ok(PermissionsPolicyFeature::FencedUnpartitionedStorageRead)
+                    }
+                    "focus-without-user-activation" | "FocusWithoutUserActivation" => {
+                        Ok(PermissionsPolicyFeature::FocusWithoutUserActivation)
+                    }
+                    "fullscreen" | "Fullscreen" => Ok(PermissionsPolicyFeature::Fullscreen),
+                    "frobulate" | "Frobulate" => Ok(PermissionsPolicyFeature::Frobulate),
+                    "gamepad" | "Gamepad" => Ok(PermissionsPolicyFeature::Gamepad),
+                    "geolocation" | "Geolocation" => Ok(PermissionsPolicyFeature::Geolocation),
+                    "gyroscope" | "Gyroscope" => Ok(PermissionsPolicyFeature::Gyroscope),
+                    "hid" | "Hid" => Ok(PermissionsPolicyFeature::Hid),
+                    "identity-credentials-get" | "IdentityCredentialsGet" => {
+                        Ok(PermissionsPolicyFeature::IdentityCredentialsGet)
+                    }
+                    "idle-detection" | "IdleDetection" => {
+                        Ok(PermissionsPolicyFeature::IdleDetection)
+                    }
+                    "interest-cohort" | "InterestCohort" => {
+                        Ok(PermissionsPolicyFeature::InterestCohort)
+                    }
+                    "join-ad-interest-group" | "JoinAdInterestGroup" => {
+                        Ok(PermissionsPolicyFeature::JoinAdInterestGroup)
+                    }
+                    "keyboard-map" | "KeyboardMap" => Ok(PermissionsPolicyFeature::KeyboardMap),
+                    "language-detector" | "LanguageDetector" => {
+                        Ok(PermissionsPolicyFeature::LanguageDetector)
+                    }
+                    "language-model" | "LanguageModel" => {
+                        Ok(PermissionsPolicyFeature::LanguageModel)
+                    }
+                    "local-fonts" | "LocalFonts" => Ok(PermissionsPolicyFeature::LocalFonts),
+                    "local-network" | "LocalNetwork" => Ok(PermissionsPolicyFeature::LocalNetwork),
+                    "local-network-access" | "LocalNetworkAccess" => {
+                        Ok(PermissionsPolicyFeature::LocalNetworkAccess)
+                    }
+                    "loopback-network" | "LoopbackNetwork" => {
+                        Ok(PermissionsPolicyFeature::LoopbackNetwork)
+                    }
+                    "magnetometer" | "Magnetometer" => Ok(PermissionsPolicyFeature::Magnetometer),
+                    "manual-text" | "ManualText" => Ok(PermissionsPolicyFeature::ManualText),
+                    "media-playback-while-not-visible" | "MediaPlaybackWhileNotVisible" => {
+                        Ok(PermissionsPolicyFeature::MediaPlaybackWhileNotVisible)
+                    }
+                    "microphone" | "Microphone" => Ok(PermissionsPolicyFeature::Microphone),
+                    "midi" | "Midi" => Ok(PermissionsPolicyFeature::Midi),
+                    "on-device-speech-recognition" | "OnDeviceSpeechRecognition" => {
+                        Ok(PermissionsPolicyFeature::OnDeviceSpeechRecognition)
+                    }
+                    "otp-credentials" | "OtpCredentials" => {
+                        Ok(PermissionsPolicyFeature::OtpCredentials)
+                    }
+                    "payment" | "Payment" => Ok(PermissionsPolicyFeature::Payment),
+                    "picture-in-picture" | "PictureInPicture" => {
+                        Ok(PermissionsPolicyFeature::PictureInPicture)
+                    }
+                    "private-aggregation" | "PrivateAggregation" => {
+                        Ok(PermissionsPolicyFeature::PrivateAggregation)
+                    }
+                    "private-state-token-issuance" | "PrivateStateTokenIssuance" => {
+                        Ok(PermissionsPolicyFeature::PrivateStateTokenIssuance)
+                    }
+                    "private-state-token-redemption" | "PrivateStateTokenRedemption" => {
+                        Ok(PermissionsPolicyFeature::PrivateStateTokenRedemption)
+                    }
+                    "publickey-credentials-create" | "PublickeyCredentialsCreate" => {
+                        Ok(PermissionsPolicyFeature::PublickeyCredentialsCreate)
+                    }
+                    "publickey-credentials-get" | "PublickeyCredentialsGet" => {
+                        Ok(PermissionsPolicyFeature::PublickeyCredentialsGet)
+                    }
+                    "record-ad-auction-events" | "RecordAdAuctionEvents" => {
+                        Ok(PermissionsPolicyFeature::RecordAdAuctionEvents)
+                    }
+                    "rewriter" | "Rewriter" => Ok(PermissionsPolicyFeature::Rewriter),
+                    "run-ad-auction" | "RunAdAuction" => Ok(PermissionsPolicyFeature::RunAdAuction),
+                    "screen-wake-lock" | "ScreenWakeLock" => {
+                        Ok(PermissionsPolicyFeature::ScreenWakeLock)
+                    }
+                    "serial" | "Serial" => Ok(PermissionsPolicyFeature::Serial),
+                    "shared-storage" | "SharedStorage" => {
+                        Ok(PermissionsPolicyFeature::SharedStorage)
+                    }
+                    "shared-storage-select-url" | "SharedStorageSelectUrl" => {
+                        Ok(PermissionsPolicyFeature::SharedStorageSelectUrl)
+                    }
+                    "smart-card" | "SmartCard" => Ok(PermissionsPolicyFeature::SmartCard),
+                    "speaker-selection" | "SpeakerSelection" => {
+                        Ok(PermissionsPolicyFeature::SpeakerSelection)
+                    }
+                    "storage-access" | "StorageAccess" => {
+                        Ok(PermissionsPolicyFeature::StorageAccess)
+                    }
+                    "sub-apps" | "SubApps" => Ok(PermissionsPolicyFeature::SubApps),
+                    "summarizer" | "Summarizer" => Ok(PermissionsPolicyFeature::Summarizer),
+                    "sync-xhr" | "SyncXhr" => Ok(PermissionsPolicyFeature::SyncXhr),
+                    "translator" | "Translator" => Ok(PermissionsPolicyFeature::Translator),
+                    "unload" | "Unload" => Ok(PermissionsPolicyFeature::Unload),
+                    "usb" | "Usb" => Ok(PermissionsPolicyFeature::Usb),
+                    "usb-unrestricted" | "UsbUnrestricted" => {
+                        Ok(PermissionsPolicyFeature::UsbUnrestricted)
+                    }
+                    "vertical-scroll" | "VerticalScroll" => {
+                        Ok(PermissionsPolicyFeature::VerticalScroll)
+                    }
+                    "web-app-installation" | "WebAppInstallation" => {
+                        Ok(PermissionsPolicyFeature::WebAppInstallation)
+                    }
+                    "web-printing" | "WebPrinting" => Ok(PermissionsPolicyFeature::WebPrinting),
+                    "web-share" | "WebShare" => Ok(PermissionsPolicyFeature::WebShare),
+                    "window-management" | "WindowManagement" => {
+                        Ok(PermissionsPolicyFeature::WindowManagement)
+                    }
+                    "writer" | "Writer" => Ok(PermissionsPolicyFeature::Writer),
+                    "xr-spatial-tracking" | "XrSpatialTracking" => {
+                        Ok(PermissionsPolicyFeature::XrSpatialTracking)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "LINT.ThenChange(//services/network/public/cpp/permissions_policy/permissions_policy_features.json5:PermissionsPolicy)\nReason for a permissions policy feature to be disabled."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PermissionsPolicyBlockReason {
+            #[doc = "Declaration in HTTP header."]
+            #[serde(rename = "Header")]
+            Header,
+            #[doc = "Declaration in iframe attribute."]
+            #[serde(rename = "IframeAttribute")]
+            IframeAttribute,
+            #[doc = "Inside fenced frame."]
+            #[serde(rename = "InFencedFrameTree")]
+            InFencedFrameTree,
+            #[doc = "Inside an Isolated Application."]
+            #[serde(rename = "InIsolatedApp")]
+            InIsolatedApp,
+        }
+        impl AsRef<str> for PermissionsPolicyBlockReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PermissionsPolicyBlockReason::Header => "Header",
+                    PermissionsPolicyBlockReason::IframeAttribute => "IframeAttribute",
+                    PermissionsPolicyBlockReason::InFencedFrameTree => "InFencedFrameTree",
+                    PermissionsPolicyBlockReason::InIsolatedApp => "InIsolatedApp",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PermissionsPolicyBlockReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Header" | "header" => Ok(PermissionsPolicyBlockReason::Header),
+                    "IframeAttribute" | "iframeattribute" => {
+                        Ok(PermissionsPolicyBlockReason::IframeAttribute)
+                    }
+                    "InFencedFrameTree" | "infencedframetree" => {
+                        Ok(PermissionsPolicyBlockReason::InFencedFrameTree)
+                    }
+                    "InIsolatedApp" | "inisolatedapp" => {
+                        Ok(PermissionsPolicyBlockReason::InIsolatedApp)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PermissionsPolicyBlockLocator {
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[serde(rename = "blockReason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub block_reason: PermissionsPolicyBlockReason,
+        }
+        impl PermissionsPolicyBlockLocator {
+            pub fn new(
+                frame_id: impl Into<FrameId>,
+                block_reason: impl Into<PermissionsPolicyBlockReason>,
+            ) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                    block_reason: block_reason.into(),
+                }
+            }
+        }
+        impl PermissionsPolicyBlockLocator {
+            pub fn builder() -> PermissionsPolicyBlockLocatorBuilder {
+                PermissionsPolicyBlockLocatorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PermissionsPolicyBlockLocatorBuilder {
+            frame_id: Option<FrameId>,
+            block_reason: Option<PermissionsPolicyBlockReason>,
+        }
+        impl PermissionsPolicyBlockLocatorBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn block_reason(
+                mut self,
+                block_reason: impl Into<PermissionsPolicyBlockReason>,
+            ) -> Self {
+                self.block_reason = Some(block_reason.into());
+                self
+            }
+            pub fn build(self) -> Result<PermissionsPolicyBlockLocator, String> {
+                Ok(PermissionsPolicyBlockLocator {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    block_reason: self.block_reason.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(block_reason))
+                    })?,
+                })
+            }
+        }
+        impl PermissionsPolicyBlockLocator {
+            pub const IDENTIFIER: &'static str = "Page.PermissionsPolicyBlockLocator";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PermissionsPolicyFeatureState {
+            #[serde(rename = "feature")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub feature: PermissionsPolicyFeature,
+            #[serde(rename = "allowed")]
+            pub allowed: bool,
+            #[serde(rename = "locator")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub locator: Option<PermissionsPolicyBlockLocator>,
+        }
+        impl PermissionsPolicyFeatureState {
+            pub fn new(
+                feature: impl Into<PermissionsPolicyFeature>,
+                allowed: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    feature: feature.into(),
+                    allowed: allowed.into(),
+                    locator: None,
+                }
+            }
+        }
+        impl PermissionsPolicyFeatureState {
+            pub fn builder() -> PermissionsPolicyFeatureStateBuilder {
+                PermissionsPolicyFeatureStateBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PermissionsPolicyFeatureStateBuilder {
+            feature: Option<PermissionsPolicyFeature>,
+            allowed: Option<bool>,
+            locator: Option<PermissionsPolicyBlockLocator>,
+        }
+        impl PermissionsPolicyFeatureStateBuilder {
+            pub fn feature(mut self, feature: impl Into<PermissionsPolicyFeature>) -> Self {
+                self.feature = Some(feature.into());
+                self
+            }
+            pub fn allowed(mut self, allowed: impl Into<bool>) -> Self {
+                self.allowed = Some(allowed.into());
+                self
+            }
+            pub fn locator(mut self, locator: impl Into<PermissionsPolicyBlockLocator>) -> Self {
+                self.locator = Some(locator.into());
+                self
+            }
+            pub fn build(self) -> Result<PermissionsPolicyFeatureState, String> {
+                Ok(PermissionsPolicyFeatureState {
+                    feature: self.feature.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(feature))
+                    })?,
+                    allowed: self.allowed.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(allowed))
+                    })?,
+                    locator: self.locator,
+                })
+            }
+        }
+        impl PermissionsPolicyFeatureState {
+            pub const IDENTIFIER: &'static str = "Page.PermissionsPolicyFeatureState";
+        }
+        #[doc = "Origin Trial(https://www.chromium.org/blink/origin-trials) support.\nStatus for an Origin Trial token."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum OriginTrialTokenStatus {
+            #[serde(rename = "Success")]
+            Success,
+            #[serde(rename = "NotSupported")]
+            NotSupported,
+            #[serde(rename = "Insecure")]
+            Insecure,
+            #[serde(rename = "Expired")]
+            Expired,
+            #[serde(rename = "WrongOrigin")]
+            WrongOrigin,
+            #[serde(rename = "InvalidSignature")]
+            InvalidSignature,
+            #[serde(rename = "Malformed")]
+            Malformed,
+            #[serde(rename = "WrongVersion")]
+            WrongVersion,
+            #[serde(rename = "FeatureDisabled")]
+            FeatureDisabled,
+            #[serde(rename = "TokenDisabled")]
+            TokenDisabled,
+            #[serde(rename = "FeatureDisabledForUser")]
+            FeatureDisabledForUser,
+            #[serde(rename = "UnknownTrial")]
+            UnknownTrial,
+        }
+        impl AsRef<str> for OriginTrialTokenStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    OriginTrialTokenStatus::Success => "Success",
+                    OriginTrialTokenStatus::NotSupported => "NotSupported",
+                    OriginTrialTokenStatus::Insecure => "Insecure",
+                    OriginTrialTokenStatus::Expired => "Expired",
+                    OriginTrialTokenStatus::WrongOrigin => "WrongOrigin",
+                    OriginTrialTokenStatus::InvalidSignature => "InvalidSignature",
+                    OriginTrialTokenStatus::Malformed => "Malformed",
+                    OriginTrialTokenStatus::WrongVersion => "WrongVersion",
+                    OriginTrialTokenStatus::FeatureDisabled => "FeatureDisabled",
+                    OriginTrialTokenStatus::TokenDisabled => "TokenDisabled",
+                    OriginTrialTokenStatus::FeatureDisabledForUser => "FeatureDisabledForUser",
+                    OriginTrialTokenStatus::UnknownTrial => "UnknownTrial",
+                }
+            }
+        }
+        impl ::std::str::FromStr for OriginTrialTokenStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Success" | "success" => Ok(OriginTrialTokenStatus::Success),
+                    "NotSupported" | "notsupported" => Ok(OriginTrialTokenStatus::NotSupported),
+                    "Insecure" | "insecure" => Ok(OriginTrialTokenStatus::Insecure),
+                    "Expired" | "expired" => Ok(OriginTrialTokenStatus::Expired),
+                    "WrongOrigin" | "wrongorigin" => Ok(OriginTrialTokenStatus::WrongOrigin),
+                    "InvalidSignature" | "invalidsignature" => {
+                        Ok(OriginTrialTokenStatus::InvalidSignature)
+                    }
+                    "Malformed" | "malformed" => Ok(OriginTrialTokenStatus::Malformed),
+                    "WrongVersion" | "wrongversion" => Ok(OriginTrialTokenStatus::WrongVersion),
+                    "FeatureDisabled" | "featuredisabled" => {
+                        Ok(OriginTrialTokenStatus::FeatureDisabled)
+                    }
+                    "TokenDisabled" | "tokendisabled" => Ok(OriginTrialTokenStatus::TokenDisabled),
+                    "FeatureDisabledForUser" | "featuredisabledforuser" => {
+                        Ok(OriginTrialTokenStatus::FeatureDisabledForUser)
+                    }
+                    "UnknownTrial" | "unknowntrial" => Ok(OriginTrialTokenStatus::UnknownTrial),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Status for an Origin Trial."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum OriginTrialStatus {
+            #[serde(rename = "Enabled")]
+            Enabled,
+            #[serde(rename = "ValidTokenNotProvided")]
+            ValidTokenNotProvided,
+            #[serde(rename = "OSNotSupported")]
+            OsNotSupported,
+            #[serde(rename = "TrialNotAllowed")]
+            TrialNotAllowed,
+        }
+        impl AsRef<str> for OriginTrialStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    OriginTrialStatus::Enabled => "Enabled",
+                    OriginTrialStatus::ValidTokenNotProvided => "ValidTokenNotProvided",
+                    OriginTrialStatus::OsNotSupported => "OSNotSupported",
+                    OriginTrialStatus::TrialNotAllowed => "TrialNotAllowed",
+                }
+            }
+        }
+        impl ::std::str::FromStr for OriginTrialStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Enabled" | "enabled" => Ok(OriginTrialStatus::Enabled),
+                    "ValidTokenNotProvided" | "validtokennotprovided" => {
+                        Ok(OriginTrialStatus::ValidTokenNotProvided)
+                    }
+                    "OSNotSupported" | "OsNotSupported" | "osnotsupported" => {
+                        Ok(OriginTrialStatus::OsNotSupported)
+                    }
+                    "TrialNotAllowed" | "trialnotallowed" => Ok(OriginTrialStatus::TrialNotAllowed),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum OriginTrialUsageRestriction {
+            #[serde(rename = "None")]
+            None,
+            #[serde(rename = "Subset")]
+            Subset,
+        }
+        impl AsRef<str> for OriginTrialUsageRestriction {
+            fn as_ref(&self) -> &str {
+                match self {
+                    OriginTrialUsageRestriction::None => "None",
+                    OriginTrialUsageRestriction::Subset => "Subset",
+                }
+            }
+        }
+        impl ::std::str::FromStr for OriginTrialUsageRestriction {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "None" | "none" => Ok(OriginTrialUsageRestriction::None),
+                    "Subset" | "subset" => Ok(OriginTrialUsageRestriction::Subset),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct OriginTrialToken {
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[serde(rename = "matchSubDomains")]
+            pub match_sub_domains: bool,
+            #[serde(rename = "trialName")]
+            pub trial_name: String,
+            #[serde(rename = "expiryTime")]
+            pub expiry_time: super::network::TimeSinceEpoch,
+            #[serde(rename = "isThirdParty")]
+            pub is_third_party: bool,
+            #[serde(rename = "usageRestriction")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub usage_restriction: OriginTrialUsageRestriction,
+        }
+        impl OriginTrialToken {
+            pub fn builder() -> OriginTrialTokenBuilder {
+                OriginTrialTokenBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct OriginTrialTokenBuilder {
+            origin: Option<String>,
+            match_sub_domains: Option<bool>,
+            trial_name: Option<String>,
+            expiry_time: Option<super::network::TimeSinceEpoch>,
+            is_third_party: Option<bool>,
+            usage_restriction: Option<OriginTrialUsageRestriction>,
+        }
+        impl OriginTrialTokenBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn match_sub_domains(mut self, match_sub_domains: impl Into<bool>) -> Self {
+                self.match_sub_domains = Some(match_sub_domains.into());
+                self
+            }
+            pub fn trial_name(mut self, trial_name: impl Into<String>) -> Self {
+                self.trial_name = Some(trial_name.into());
+                self
+            }
+            pub fn expiry_time(
+                mut self,
+                expiry_time: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.expiry_time = Some(expiry_time.into());
+                self
+            }
+            pub fn is_third_party(mut self, is_third_party: impl Into<bool>) -> Self {
+                self.is_third_party = Some(is_third_party.into());
+                self
+            }
+            pub fn usage_restriction(
+                mut self,
+                usage_restriction: impl Into<OriginTrialUsageRestriction>,
+            ) -> Self {
+                self.usage_restriction = Some(usage_restriction.into());
+                self
+            }
+            pub fn build(self) -> Result<OriginTrialToken, String> {
+                Ok(OriginTrialToken {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    match_sub_domains: self.match_sub_domains.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(match_sub_domains)
+                        )
+                    })?,
+                    trial_name: self.trial_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(trial_name))
+                    })?,
+                    expiry_time: self.expiry_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expiry_time))
+                    })?,
+                    is_third_party: self.is_third_party.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_third_party))
+                    })?,
+                    usage_restriction: self.usage_restriction.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(usage_restriction)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl OriginTrialToken {
+            pub const IDENTIFIER: &'static str = "Page.OriginTrialToken";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct OriginTrialTokenWithStatus {
+            #[serde(rename = "rawTokenText")]
+            pub raw_token_text: String,
+            #[doc = "`parsedToken` is present only when the token is extractable and\nparsable."]
+            #[serde(rename = "parsedToken")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parsed_token: Option<OriginTrialToken>,
+            #[serde(rename = "status")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub status: OriginTrialTokenStatus,
+        }
+        impl OriginTrialTokenWithStatus {
+            pub fn new(
+                raw_token_text: impl Into<String>,
+                status: impl Into<OriginTrialTokenStatus>,
+            ) -> Self {
+                Self {
+                    raw_token_text: raw_token_text.into(),
+                    status: status.into(),
+                    parsed_token: None,
+                }
+            }
+        }
+        impl OriginTrialTokenWithStatus {
+            pub fn builder() -> OriginTrialTokenWithStatusBuilder {
+                OriginTrialTokenWithStatusBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct OriginTrialTokenWithStatusBuilder {
+            raw_token_text: Option<String>,
+            parsed_token: Option<OriginTrialToken>,
+            status: Option<OriginTrialTokenStatus>,
+        }
+        impl OriginTrialTokenWithStatusBuilder {
+            pub fn raw_token_text(mut self, raw_token_text: impl Into<String>) -> Self {
+                self.raw_token_text = Some(raw_token_text.into());
+                self
+            }
+            pub fn parsed_token(mut self, parsed_token: impl Into<OriginTrialToken>) -> Self {
+                self.parsed_token = Some(parsed_token.into());
+                self
+            }
+            pub fn status(mut self, status: impl Into<OriginTrialTokenStatus>) -> Self {
+                self.status = Some(status.into());
+                self
+            }
+            pub fn build(self) -> Result<OriginTrialTokenWithStatus, String> {
+                Ok(OriginTrialTokenWithStatus {
+                    raw_token_text: self.raw_token_text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(raw_token_text))
+                    })?,
+                    parsed_token: self.parsed_token,
+                    status: self.status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status))
+                    })?,
+                })
+            }
+        }
+        impl OriginTrialTokenWithStatus {
+            pub const IDENTIFIER: &'static str = "Page.OriginTrialTokenWithStatus";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct OriginTrial {
+            #[serde(rename = "trialName")]
+            pub trial_name: String,
+            #[serde(rename = "status")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub status: OriginTrialStatus,
+            #[serde(rename = "tokensWithStatus")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub tokens_with_status: Vec<OriginTrialTokenWithStatus>,
+        }
+        impl OriginTrial {
+            pub fn new(
+                trial_name: impl Into<String>,
+                status: impl Into<OriginTrialStatus>,
+                tokens_with_status: Vec<OriginTrialTokenWithStatus>,
+            ) -> Self {
+                Self {
+                    trial_name: trial_name.into(),
+                    status: status.into(),
+                    tokens_with_status,
+                }
+            }
+        }
+        impl OriginTrial {
+            pub fn builder() -> OriginTrialBuilder {
+                OriginTrialBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct OriginTrialBuilder {
+            trial_name: Option<String>,
+            status: Option<OriginTrialStatus>,
+            tokens_with_status: Option<Vec<OriginTrialTokenWithStatus>>,
+        }
+        impl OriginTrialBuilder {
+            pub fn trial_name(mut self, trial_name: impl Into<String>) -> Self {
+                self.trial_name = Some(trial_name.into());
+                self
+            }
+            pub fn status(mut self, status: impl Into<OriginTrialStatus>) -> Self {
+                self.status = Some(status.into());
+                self
+            }
+            pub fn tokens_with_statu(
+                mut self,
+                tokens_with_statu: impl Into<OriginTrialTokenWithStatus>,
+            ) -> Self {
+                let v = self.tokens_with_status.get_or_insert(Vec::new());
+                v.push(tokens_with_statu.into());
+                self
+            }
+            pub fn tokens_with_status<I, S>(mut self, tokens_with_status: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<OriginTrialTokenWithStatus>,
+            {
+                let v = self.tokens_with_status.get_or_insert(Vec::new());
+                for val in tokens_with_status {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<OriginTrial, String> {
+                Ok(OriginTrial {
+                    trial_name: self.trial_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(trial_name))
+                    })?,
+                    status: self.status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status))
+                    })?,
+                    tokens_with_status: self.tokens_with_status.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(tokens_with_status)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl OriginTrial {
+            pub const IDENTIFIER: &'static str = "Page.OriginTrial";
+        }
+        #[doc = "Additional information about the frame document's security origin.\n[SecurityOriginDetails](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-SecurityOriginDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SecurityOriginDetails {
+            #[doc = "Indicates whether the frame document's security origin is one\nof the local hostnames (e.g. \"localhost\") or IP addresses (IPv4\n127.0.0.0/8 or IPv6 ::1)."]
+            #[serde(rename = "isLocalhost")]
+            pub is_localhost: bool,
+        }
+        impl SecurityOriginDetails {
+            pub fn new(is_localhost: impl Into<bool>) -> Self {
+                Self {
+                    is_localhost: is_localhost.into(),
+                }
+            }
+        }
+        impl SecurityOriginDetails {
+            pub fn builder() -> SecurityOriginDetailsBuilder {
+                SecurityOriginDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SecurityOriginDetailsBuilder {
+            is_localhost: Option<bool>,
+        }
+        impl SecurityOriginDetailsBuilder {
+            pub fn is_localhost(mut self, is_localhost: impl Into<bool>) -> Self {
+                self.is_localhost = Some(is_localhost.into());
+                self
+            }
+            pub fn build(self) -> Result<SecurityOriginDetails, String> {
+                Ok(SecurityOriginDetails {
+                    is_localhost: self.is_localhost.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_localhost))
+                    })?,
+                })
+            }
+        }
+        impl SecurityOriginDetails {
+            pub const IDENTIFIER: &'static str = "Page.SecurityOriginDetails";
+        }
+        #[doc = "Information about the Frame on the page.\n[Frame](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-Frame)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Frame {
+            #[doc = "Frame unique identifier."]
+            #[serde(rename = "id")]
+            pub id: FrameId,
+            #[doc = "Parent frame identifier."]
+            #[serde(rename = "parentId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent_id: Option<FrameId>,
+            #[doc = "Identifier of the loader associated with this frame."]
+            #[serde(rename = "loaderId")]
+            pub loader_id: super::network::LoaderId,
+            #[doc = "Frame's name as specified in the tag."]
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[doc = "Frame document's URL without fragment."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Frame document's URL fragment including the '#'."]
+            #[serde(rename = "urlFragment")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url_fragment: Option<String>,
+            #[doc = "Frame document's registered domain, taking the public suffixes list into account.\nExtracted from the Frame's url.\nExample URLs: http://www.google.com/file.html -> \"google.com\"\nhttp://a.b.co.uk/file.html      -> \"b.co.uk\""]
+            #[serde(rename = "domainAndRegistry")]
+            pub domain_and_registry: String,
+            #[doc = "Frame document's security origin."]
+            #[serde(rename = "securityOrigin")]
+            pub security_origin: String,
+            #[doc = "Additional details about the frame document's security origin."]
+            #[serde(rename = "securityOriginDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub security_origin_details: Option<SecurityOriginDetails>,
+            #[doc = "Frame document's mimeType as determined by the browser."]
+            #[serde(rename = "mimeType")]
+            pub mime_type: String,
+            #[doc = "If the frame failed to load, this contains the URL that could not be loaded. Note that unlike url above, this URL may contain a fragment."]
+            #[serde(rename = "unreachableUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub unreachable_url: Option<String>,
+            #[doc = "Indicates whether this frame was tagged as an ad and why."]
+            #[serde(rename = "adFrameStatus")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub ad_frame_status: Option<AdFrameStatus>,
+            #[doc = "Indicates whether the main document is a secure context and explains why that is the case."]
+            #[serde(rename = "secureContextType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub secure_context_type: SecureContextType,
+            #[doc = "Indicates whether this is a cross origin isolated context."]
+            #[serde(rename = "crossOriginIsolatedContextType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub cross_origin_isolated_context_type: CrossOriginIsolatedContextType,
+            #[doc = "Indicated which gated APIs / features are available."]
+            #[serde(rename = "gatedAPIFeatures")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub gated_api_features: Vec<GatedApiFeatures>,
+        }
+        impl Frame {
+            pub fn builder() -> FrameBuilder {
+                FrameBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FrameBuilder {
+            id: Option<FrameId>,
+            parent_id: Option<FrameId>,
+            loader_id: Option<super::network::LoaderId>,
+            name: Option<String>,
+            url: Option<String>,
+            url_fragment: Option<String>,
+            domain_and_registry: Option<String>,
+            security_origin: Option<String>,
+            security_origin_details: Option<SecurityOriginDetails>,
+            mime_type: Option<String>,
+            unreachable_url: Option<String>,
+            ad_frame_status: Option<AdFrameStatus>,
+            secure_context_type: Option<SecureContextType>,
+            cross_origin_isolated_context_type: Option<CrossOriginIsolatedContextType>,
+            gated_api_features: Option<Vec<GatedApiFeatures>>,
+        }
+        impl FrameBuilder {
+            pub fn id(mut self, id: impl Into<FrameId>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn parent_id(mut self, parent_id: impl Into<FrameId>) -> Self {
+                self.parent_id = Some(parent_id.into());
+                self
+            }
+            pub fn loader_id(mut self, loader_id: impl Into<super::network::LoaderId>) -> Self {
+                self.loader_id = Some(loader_id.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn url_fragment(mut self, url_fragment: impl Into<String>) -> Self {
+                self.url_fragment = Some(url_fragment.into());
+                self
+            }
+            pub fn domain_and_registry(mut self, domain_and_registry: impl Into<String>) -> Self {
+                self.domain_and_registry = Some(domain_and_registry.into());
+                self
+            }
+            pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
+                self.security_origin = Some(security_origin.into());
+                self
+            }
+            pub fn security_origin_details(
+                mut self,
+                security_origin_details: impl Into<SecurityOriginDetails>,
+            ) -> Self {
+                self.security_origin_details = Some(security_origin_details.into());
+                self
+            }
+            pub fn mime_type(mut self, mime_type: impl Into<String>) -> Self {
+                self.mime_type = Some(mime_type.into());
+                self
+            }
+            pub fn unreachable_url(mut self, unreachable_url: impl Into<String>) -> Self {
+                self.unreachable_url = Some(unreachable_url.into());
+                self
+            }
+            pub fn ad_frame_status(mut self, ad_frame_status: impl Into<AdFrameStatus>) -> Self {
+                self.ad_frame_status = Some(ad_frame_status.into());
+                self
+            }
+            pub fn secure_context_type(
+                mut self,
+                secure_context_type: impl Into<SecureContextType>,
+            ) -> Self {
+                self.secure_context_type = Some(secure_context_type.into());
+                self
+            }
+            pub fn cross_origin_isolated_context_type(
+                mut self,
+                cross_origin_isolated_context_type: impl Into<CrossOriginIsolatedContextType>,
+            ) -> Self {
+                self.cross_origin_isolated_context_type =
+                    Some(cross_origin_isolated_context_type.into());
+                self
+            }
+            pub fn gated_api_feature(
+                mut self,
+                gated_api_feature: impl Into<GatedApiFeatures>,
+            ) -> Self {
+                let v = self.gated_api_features.get_or_insert(Vec::new());
+                v.push(gated_api_feature.into());
+                self
+            }
+            pub fn gated_api_features<I, S>(mut self, gated_api_features: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<GatedApiFeatures>,
+            {
+                let v = self.gated_api_features.get_or_insert(Vec::new());
+                for val in gated_api_features {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<Frame, String> {
+                Ok(Frame {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    parent_id: self.parent_id,
+                    loader_id: self.loader_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(loader_id))
+                    })?,
+                    name: self.name,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    url_fragment: self.url_fragment,
+                    domain_and_registry: self.domain_and_registry.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(domain_and_registry)
+                        )
+                    })?,
+                    security_origin: self.security_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(security_origin))
+                    })?,
+                    security_origin_details: self.security_origin_details,
+                    mime_type: self.mime_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mime_type))
+                    })?,
+                    unreachable_url: self.unreachable_url,
+                    ad_frame_status: self.ad_frame_status,
+                    secure_context_type: self.secure_context_type.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(secure_context_type)
+                        )
+                    })?,
+                    cross_origin_isolated_context_type: self
+                        .cross_origin_isolated_context_type
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(cross_origin_isolated_context_type)
+                            )
+                        })?,
+                    gated_api_features: self.gated_api_features.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(gated_api_features)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl Frame {
+            pub const IDENTIFIER: &'static str = "Page.Frame";
+        }
+        #[doc = "Information about the Resource on the page.\n[FrameResource](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-FrameResource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FrameResource {
+            #[doc = "Resource URL."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Type of this resource."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: super::network::ResourceType,
+            #[doc = "Resource mimeType as determined by the browser."]
+            #[serde(rename = "mimeType")]
+            pub mime_type: String,
+            #[doc = "last-modified timestamp as reported by server."]
+            #[serde(rename = "lastModified")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub last_modified: Option<super::network::TimeSinceEpoch>,
+            #[doc = "Resource content size."]
+            #[serde(rename = "contentSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub content_size: Option<f64>,
+            #[doc = "True if the resource failed to load."]
+            #[serde(rename = "failed")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub failed: Option<bool>,
+            #[doc = "True if the resource was canceled during loading."]
+            #[serde(rename = "canceled")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub canceled: Option<bool>,
+        }
+        impl FrameResource {
+            pub fn new(
+                url: impl Into<String>,
+                r#type: impl Into<super::network::ResourceType>,
+                mime_type: impl Into<String>,
+            ) -> Self {
+                Self {
+                    url: url.into(),
+                    r#type: r#type.into(),
+                    mime_type: mime_type.into(),
+                    last_modified: None,
+                    content_size: None,
+                    failed: None,
+                    canceled: None,
+                }
+            }
+        }
+        impl FrameResource {
+            pub fn builder() -> FrameResourceBuilder {
+                FrameResourceBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FrameResourceBuilder {
+            url: Option<String>,
+            r#type: Option<super::network::ResourceType>,
+            mime_type: Option<String>,
+            last_modified: Option<super::network::TimeSinceEpoch>,
+            content_size: Option<f64>,
+            failed: Option<bool>,
+            canceled: Option<bool>,
+        }
+        impl FrameResourceBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<super::network::ResourceType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn mime_type(mut self, mime_type: impl Into<String>) -> Self {
+                self.mime_type = Some(mime_type.into());
+                self
+            }
+            pub fn last_modified(
+                mut self,
+                last_modified: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.last_modified = Some(last_modified.into());
+                self
+            }
+            pub fn content_size(mut self, content_size: impl Into<f64>) -> Self {
+                self.content_size = Some(content_size.into());
+                self
+            }
+            pub fn failed(mut self, failed: impl Into<bool>) -> Self {
+                self.failed = Some(failed.into());
+                self
+            }
+            pub fn canceled(mut self, canceled: impl Into<bool>) -> Self {
+                self.canceled = Some(canceled.into());
+                self
+            }
+            pub fn build(self) -> Result<FrameResource, String> {
+                Ok(FrameResource {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    mime_type: self.mime_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mime_type))
+                    })?,
+                    last_modified: self.last_modified,
+                    content_size: self.content_size,
+                    failed: self.failed,
+                    canceled: self.canceled,
+                })
+            }
+        }
+        impl FrameResource {
+            pub const IDENTIFIER: &'static str = "Page.FrameResource";
+        }
+        #[doc = "Information about the Frame hierarchy along with their cached resources.\n[FrameResourceTree](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-FrameResourceTree)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FrameResourceTree {
+            #[doc = "Frame information for this tree item."]
+            #[serde(rename = "frame")]
+            pub frame: Frame,
+            #[doc = "Child frames."]
+            #[serde(rename = "childFrames")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub child_frames: Option<Vec<FrameResourceTree>>,
+            #[doc = "Information about frame resources."]
+            #[serde(rename = "resources")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub resources: Vec<FrameResource>,
+        }
+        impl FrameResourceTree {
+            pub fn new(frame: impl Into<Frame>, resources: Vec<FrameResource>) -> Self {
+                Self {
+                    frame: frame.into(),
+                    resources,
+                    child_frames: None,
+                }
+            }
+        }
+        impl FrameResourceTree {
+            pub fn builder() -> FrameResourceTreeBuilder {
+                FrameResourceTreeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FrameResourceTreeBuilder {
+            frame: Option<Frame>,
+            child_frames: Option<Vec<FrameResourceTree>>,
+            resources: Option<Vec<FrameResource>>,
+        }
+        impl FrameResourceTreeBuilder {
+            pub fn frame(mut self, frame: impl Into<Frame>) -> Self {
+                self.frame = Some(frame.into());
+                self
+            }
+            pub fn child_frame(mut self, child_frame: impl Into<FrameResourceTree>) -> Self {
+                let v = self.child_frames.get_or_insert(Vec::new());
+                v.push(child_frame.into());
+                self
+            }
+            pub fn child_frames<I, S>(mut self, child_frames: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FrameResourceTree>,
+            {
+                let v = self.child_frames.get_or_insert(Vec::new());
+                for val in child_frames {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn resource(mut self, resource: impl Into<FrameResource>) -> Self {
+                let v = self.resources.get_or_insert(Vec::new());
+                v.push(resource.into());
+                self
+            }
+            pub fn resources<I, S>(mut self, resources: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FrameResource>,
+            {
+                let v = self.resources.get_or_insert(Vec::new());
+                for val in resources {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<FrameResourceTree, String> {
+                Ok(FrameResourceTree {
+                    frame: self.frame.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame))
+                    })?,
+                    child_frames: self.child_frames,
+                    resources: self.resources.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(resources))
+                    })?,
+                })
+            }
+        }
+        impl FrameResourceTree {
+            pub const IDENTIFIER: &'static str = "Page.FrameResourceTree";
+        }
+        #[doc = "Information about the Frame hierarchy.\n[FrameTree](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-FrameTree)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FrameTree {
+            #[doc = "Frame information for this tree item."]
+            #[serde(rename = "frame")]
+            pub frame: Frame,
+            #[doc = "Child frames."]
+            #[serde(rename = "childFrames")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub child_frames: Option<Vec<FrameTree>>,
+        }
+        impl FrameTree {
+            pub fn new(frame: impl Into<Frame>) -> Self {
+                Self {
+                    frame: frame.into(),
+                    child_frames: None,
+                }
+            }
+        }
+        impl FrameTree {
+            pub fn builder() -> FrameTreeBuilder {
+                FrameTreeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FrameTreeBuilder {
+            frame: Option<Frame>,
+            child_frames: Option<Vec<FrameTree>>,
+        }
+        impl FrameTreeBuilder {
+            pub fn frame(mut self, frame: impl Into<Frame>) -> Self {
+                self.frame = Some(frame.into());
+                self
+            }
+            pub fn child_frame(mut self, child_frame: impl Into<FrameTree>) -> Self {
+                let v = self.child_frames.get_or_insert(Vec::new());
+                v.push(child_frame.into());
+                self
+            }
+            pub fn child_frames<I, S>(mut self, child_frames: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FrameTree>,
+            {
+                let v = self.child_frames.get_or_insert(Vec::new());
+                for val in child_frames {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<FrameTree, String> {
+                Ok(FrameTree {
+                    frame: self.frame.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame))
+                    })?,
+                    child_frames: self.child_frames,
+                })
+            }
+        }
+        impl FrameTree {
+            pub const IDENTIFIER: &'static str = "Page.FrameTree";
+        }
+        #[doc = "Unique script identifier.\n[ScriptIdentifier](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-ScriptIdentifier)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct ScriptIdentifier(String);
+        impl ScriptIdentifier {
+            pub fn new(val: impl Into<String>) -> Self {
+                ScriptIdentifier(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for ScriptIdentifier {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<ScriptIdentifier> for String {
+            fn from(el: ScriptIdentifier) -> String {
+                el.0
+            }
+        }
+        impl From<String> for ScriptIdentifier {
+            fn from(expr: String) -> Self {
+                ScriptIdentifier(expr)
+            }
+        }
+        impl ScriptIdentifier {
+            pub const IDENTIFIER: &'static str = "Page.ScriptIdentifier";
+        }
+        #[doc = "Transition type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum TransitionType {
+            #[serde(rename = "link")]
+            Link,
+            #[serde(rename = "typed")]
+            Typed,
+            #[serde(rename = "address_bar")]
+            AddressBar,
+            #[serde(rename = "auto_bookmark")]
+            AutoBookmark,
+            #[serde(rename = "auto_subframe")]
+            AutoSubframe,
+            #[serde(rename = "manual_subframe")]
+            ManualSubframe,
+            #[serde(rename = "generated")]
+            Generated,
+            #[serde(rename = "auto_toplevel")]
+            AutoToplevel,
+            #[serde(rename = "form_submit")]
+            FormSubmit,
+            #[serde(rename = "reload")]
+            Reload,
+            #[serde(rename = "keyword")]
+            Keyword,
+            #[serde(rename = "keyword_generated")]
+            KeywordGenerated,
+            #[serde(rename = "other")]
+            Other,
+        }
+        impl AsRef<str> for TransitionType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    TransitionType::Link => "link",
+                    TransitionType::Typed => "typed",
+                    TransitionType::AddressBar => "address_bar",
+                    TransitionType::AutoBookmark => "auto_bookmark",
+                    TransitionType::AutoSubframe => "auto_subframe",
+                    TransitionType::ManualSubframe => "manual_subframe",
+                    TransitionType::Generated => "generated",
+                    TransitionType::AutoToplevel => "auto_toplevel",
+                    TransitionType::FormSubmit => "form_submit",
+                    TransitionType::Reload => "reload",
+                    TransitionType::Keyword => "keyword",
+                    TransitionType::KeywordGenerated => "keyword_generated",
+                    TransitionType::Other => "other",
+                }
+            }
+        }
+        impl ::std::str::FromStr for TransitionType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "link" | "Link" => Ok(TransitionType::Link),
+                    "typed" | "Typed" => Ok(TransitionType::Typed),
+                    "address_bar" | "AddressBar" => Ok(TransitionType::AddressBar),
+                    "auto_bookmark" | "AutoBookmark" => Ok(TransitionType::AutoBookmark),
+                    "auto_subframe" | "AutoSubframe" => Ok(TransitionType::AutoSubframe),
+                    "manual_subframe" | "ManualSubframe" => Ok(TransitionType::ManualSubframe),
+                    "generated" | "Generated" => Ok(TransitionType::Generated),
+                    "auto_toplevel" | "AutoToplevel" => Ok(TransitionType::AutoToplevel),
+                    "form_submit" | "FormSubmit" => Ok(TransitionType::FormSubmit),
+                    "reload" | "Reload" => Ok(TransitionType::Reload),
+                    "keyword" | "Keyword" => Ok(TransitionType::Keyword),
+                    "keyword_generated" | "KeywordGenerated" => {
+                        Ok(TransitionType::KeywordGenerated)
+                    }
+                    "other" | "Other" => Ok(TransitionType::Other),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Navigation history entry.\n[NavigationEntry](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-NavigationEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct NavigationEntry {
+            #[doc = "Unique id of the navigation history entry."]
+            #[serde(rename = "id")]
+            pub id: i64,
+            #[doc = "URL of the navigation history entry."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "URL that the user typed in the url bar."]
+            #[serde(rename = "userTypedURL")]
+            pub user_typed_url: String,
+            #[doc = "Title of the navigation history entry."]
+            #[serde(rename = "title")]
+            pub title: String,
+            #[doc = "Transition type."]
+            #[serde(rename = "transitionType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub transition_type: TransitionType,
+        }
+        impl NavigationEntry {
+            pub fn builder() -> NavigationEntryBuilder {
+                NavigationEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct NavigationEntryBuilder {
+            id: Option<i64>,
+            url: Option<String>,
+            user_typed_url: Option<String>,
+            title: Option<String>,
+            transition_type: Option<TransitionType>,
+        }
+        impl NavigationEntryBuilder {
+            pub fn id(mut self, id: impl Into<i64>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn user_typed_url(mut self, user_typed_url: impl Into<String>) -> Self {
+                self.user_typed_url = Some(user_typed_url.into());
+                self
+            }
+            pub fn title(mut self, title: impl Into<String>) -> Self {
+                self.title = Some(title.into());
+                self
+            }
+            pub fn transition_type(mut self, transition_type: impl Into<TransitionType>) -> Self {
+                self.transition_type = Some(transition_type.into());
+                self
+            }
+            pub fn build(self) -> Result<NavigationEntry, String> {
+                Ok(NavigationEntry {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    user_typed_url: self.user_typed_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(user_typed_url))
+                    })?,
+                    title: self.title.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(title))
+                    })?,
+                    transition_type: self.transition_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(transition_type))
+                    })?,
+                })
+            }
+        }
+        impl NavigationEntry {
+            pub const IDENTIFIER: &'static str = "Page.NavigationEntry";
+        }
+        #[doc = "Screencast frame metadata.\n[ScreencastFrameMetadata](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-ScreencastFrameMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScreencastFrameMetadata {
+            #[doc = "Top offset in DIP."]
+            #[serde(rename = "offsetTop")]
+            pub offset_top: f64,
+            #[doc = "Page scale factor."]
+            #[serde(rename = "pageScaleFactor")]
+            pub page_scale_factor: f64,
+            #[doc = "Device screen width in DIP."]
+            #[serde(rename = "deviceWidth")]
+            pub device_width: f64,
+            #[doc = "Device screen height in DIP."]
+            #[serde(rename = "deviceHeight")]
+            pub device_height: f64,
+            #[doc = "Position of horizontal scroll in CSS pixels."]
+            #[serde(rename = "scrollOffsetX")]
+            pub scroll_offset_x: f64,
+            #[doc = "Position of vertical scroll in CSS pixels."]
+            #[serde(rename = "scrollOffsetY")]
+            pub scroll_offset_y: f64,
+            #[doc = "Frame swap timestamp."]
+            #[serde(rename = "timestamp")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub timestamp: Option<super::network::TimeSinceEpoch>,
+        }
+        impl ScreencastFrameMetadata {
+            pub fn builder() -> ScreencastFrameMetadataBuilder {
+                ScreencastFrameMetadataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScreencastFrameMetadataBuilder {
+            offset_top: Option<f64>,
+            page_scale_factor: Option<f64>,
+            device_width: Option<f64>,
+            device_height: Option<f64>,
+            scroll_offset_x: Option<f64>,
+            scroll_offset_y: Option<f64>,
+            timestamp: Option<super::network::TimeSinceEpoch>,
+        }
+        impl ScreencastFrameMetadataBuilder {
+            pub fn offset_top(mut self, offset_top: impl Into<f64>) -> Self {
+                self.offset_top = Some(offset_top.into());
+                self
+            }
+            pub fn page_scale_factor(mut self, page_scale_factor: impl Into<f64>) -> Self {
+                self.page_scale_factor = Some(page_scale_factor.into());
+                self
+            }
+            pub fn device_width(mut self, device_width: impl Into<f64>) -> Self {
+                self.device_width = Some(device_width.into());
+                self
+            }
+            pub fn device_height(mut self, device_height: impl Into<f64>) -> Self {
+                self.device_height = Some(device_height.into());
+                self
+            }
+            pub fn scroll_offset_x(mut self, scroll_offset_x: impl Into<f64>) -> Self {
+                self.scroll_offset_x = Some(scroll_offset_x.into());
+                self
+            }
+            pub fn scroll_offset_y(mut self, scroll_offset_y: impl Into<f64>) -> Self {
+                self.scroll_offset_y = Some(scroll_offset_y.into());
+                self
+            }
+            pub fn timestamp(
+                mut self,
+                timestamp: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.timestamp = Some(timestamp.into());
+                self
+            }
+            pub fn build(self) -> Result<ScreencastFrameMetadata, String> {
+                Ok(ScreencastFrameMetadata {
+                    offset_top: self.offset_top.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(offset_top))
+                    })?,
+                    page_scale_factor: self.page_scale_factor.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(page_scale_factor)
+                        )
+                    })?,
+                    device_width: self.device_width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(device_width))
+                    })?,
+                    device_height: self.device_height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(device_height))
+                    })?,
+                    scroll_offset_x: self.scroll_offset_x.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scroll_offset_x))
+                    })?,
+                    scroll_offset_y: self.scroll_offset_y.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scroll_offset_y))
+                    })?,
+                    timestamp: self.timestamp,
+                })
+            }
+        }
+        impl ScreencastFrameMetadata {
+            pub const IDENTIFIER: &'static str = "Page.ScreencastFrameMetadata";
+        }
+        #[doc = "Javascript dialog type."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum DialogType {
+            #[serde(rename = "alert")]
+            Alert,
+            #[serde(rename = "confirm")]
+            Confirm,
+            #[serde(rename = "prompt")]
+            Prompt,
+            #[serde(rename = "beforeunload")]
+            Beforeunload,
+        }
+        impl AsRef<str> for DialogType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    DialogType::Alert => "alert",
+                    DialogType::Confirm => "confirm",
+                    DialogType::Prompt => "prompt",
+                    DialogType::Beforeunload => "beforeunload",
+                }
+            }
+        }
+        impl ::std::str::FromStr for DialogType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "alert" | "Alert" => Ok(DialogType::Alert),
+                    "confirm" | "Confirm" => Ok(DialogType::Confirm),
+                    "prompt" | "Prompt" => Ok(DialogType::Prompt),
+                    "beforeunload" | "Beforeunload" => Ok(DialogType::Beforeunload),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Error while paring app manifest.\n[AppManifestError](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-AppManifestError)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AppManifestError {
+            #[doc = "Error message."]
+            #[serde(rename = "message")]
+            pub message: String,
+            #[doc = "If critical, this is a non-recoverable parse error."]
+            #[serde(rename = "critical")]
+            pub critical: i64,
+            #[doc = "Error line."]
+            #[serde(rename = "line")]
+            pub line: i64,
+            #[doc = "Error column."]
+            #[serde(rename = "column")]
+            pub column: i64,
+        }
+        impl AppManifestError {
+            pub fn new(
+                message: impl Into<String>,
+                critical: impl Into<i64>,
+                line: impl Into<i64>,
+                column: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    message: message.into(),
+                    critical: critical.into(),
+                    line: line.into(),
+                    column: column.into(),
+                }
+            }
+        }
+        impl AppManifestError {
+            pub fn builder() -> AppManifestErrorBuilder {
+                AppManifestErrorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AppManifestErrorBuilder {
+            message: Option<String>,
+            critical: Option<i64>,
+            line: Option<i64>,
+            column: Option<i64>,
+        }
+        impl AppManifestErrorBuilder {
+            pub fn message(mut self, message: impl Into<String>) -> Self {
+                self.message = Some(message.into());
+                self
+            }
+            pub fn critical(mut self, critical: impl Into<i64>) -> Self {
+                self.critical = Some(critical.into());
+                self
+            }
+            pub fn line(mut self, line: impl Into<i64>) -> Self {
+                self.line = Some(line.into());
+                self
+            }
+            pub fn column(mut self, column: impl Into<i64>) -> Self {
+                self.column = Some(column.into());
+                self
+            }
+            pub fn build(self) -> Result<AppManifestError, String> {
+                Ok(AppManifestError {
+                    message: self.message.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(message))
+                    })?,
+                    critical: self.critical.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(critical))
+                    })?,
+                    line: self.line.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line))
+                    })?,
+                    column: self.column.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(column))
+                    })?,
+                })
+            }
+        }
+        impl AppManifestError {
+            pub const IDENTIFIER: &'static str = "Page.AppManifestError";
+        }
+        #[doc = "Parsed app manifest properties.\n[AppManifestParsedProperties](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-AppManifestParsedProperties)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AppManifestParsedProperties {
+            #[doc = "Computed scope value"]
+            #[serde(rename = "scope")]
+            pub scope: String,
+        }
+        impl AppManifestParsedProperties {
+            pub fn new(scope: impl Into<String>) -> Self {
+                Self {
+                    scope: scope.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for AppManifestParsedProperties {
+            fn from(url: T) -> Self {
+                AppManifestParsedProperties::new(url)
+            }
+        }
+        impl AppManifestParsedProperties {
+            pub fn builder() -> AppManifestParsedPropertiesBuilder {
+                AppManifestParsedPropertiesBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AppManifestParsedPropertiesBuilder {
+            scope: Option<String>,
+        }
+        impl AppManifestParsedPropertiesBuilder {
+            pub fn scope(mut self, scope: impl Into<String>) -> Self {
+                self.scope = Some(scope.into());
+                self
+            }
+            pub fn build(self) -> Result<AppManifestParsedProperties, String> {
+                Ok(AppManifestParsedProperties {
+                    scope: self.scope.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scope))
+                    })?,
+                })
+            }
+        }
+        impl AppManifestParsedProperties {
+            pub const IDENTIFIER: &'static str = "Page.AppManifestParsedProperties";
+        }
+        #[doc = "Layout viewport position and dimensions.\n[LayoutViewport](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-LayoutViewport)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LayoutViewport {
+            #[doc = "Horizontal offset relative to the document (CSS pixels)."]
+            #[serde(rename = "pageX")]
+            pub page_x: i64,
+            #[doc = "Vertical offset relative to the document (CSS pixels)."]
+            #[serde(rename = "pageY")]
+            pub page_y: i64,
+            #[doc = "Width (CSS pixels), excludes scrollbar if present."]
+            #[serde(rename = "clientWidth")]
+            pub client_width: i64,
+            #[doc = "Height (CSS pixels), excludes scrollbar if present."]
+            #[serde(rename = "clientHeight")]
+            pub client_height: i64,
+        }
+        impl LayoutViewport {
+            pub fn new(
+                page_x: impl Into<i64>,
+                page_y: impl Into<i64>,
+                client_width: impl Into<i64>,
+                client_height: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    page_x: page_x.into(),
+                    page_y: page_y.into(),
+                    client_width: client_width.into(),
+                    client_height: client_height.into(),
+                }
+            }
+        }
+        impl LayoutViewport {
+            pub fn builder() -> LayoutViewportBuilder {
+                LayoutViewportBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LayoutViewportBuilder {
+            page_x: Option<i64>,
+            page_y: Option<i64>,
+            client_width: Option<i64>,
+            client_height: Option<i64>,
+        }
+        impl LayoutViewportBuilder {
+            pub fn page_x(mut self, page_x: impl Into<i64>) -> Self {
+                self.page_x = Some(page_x.into());
+                self
+            }
+            pub fn page_y(mut self, page_y: impl Into<i64>) -> Self {
+                self.page_y = Some(page_y.into());
+                self
+            }
+            pub fn client_width(mut self, client_width: impl Into<i64>) -> Self {
+                self.client_width = Some(client_width.into());
+                self
+            }
+            pub fn client_height(mut self, client_height: impl Into<i64>) -> Self {
+                self.client_height = Some(client_height.into());
+                self
+            }
+            pub fn build(self) -> Result<LayoutViewport, String> {
+                Ok(LayoutViewport {
+                    page_x: self.page_x.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(page_x))
+                    })?,
+                    page_y: self.page_y.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(page_y))
+                    })?,
+                    client_width: self.client_width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(client_width))
+                    })?,
+                    client_height: self.client_height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(client_height))
+                    })?,
+                })
+            }
+        }
+        impl LayoutViewport {
+            pub const IDENTIFIER: &'static str = "Page.LayoutViewport";
+        }
+        #[doc = "Visual viewport position, dimensions, and scale.\n[VisualViewport](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-VisualViewport)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct VisualViewport {
+            #[doc = "Horizontal offset relative to the layout viewport (CSS pixels)."]
+            #[serde(rename = "offsetX")]
+            pub offset_x: f64,
+            #[doc = "Vertical offset relative to the layout viewport (CSS pixels)."]
+            #[serde(rename = "offsetY")]
+            pub offset_y: f64,
+            #[doc = "Horizontal offset relative to the document (CSS pixels)."]
+            #[serde(rename = "pageX")]
+            pub page_x: f64,
+            #[doc = "Vertical offset relative to the document (CSS pixels)."]
+            #[serde(rename = "pageY")]
+            pub page_y: f64,
+            #[doc = "Width (CSS pixels), excludes scrollbar if present."]
+            #[serde(rename = "clientWidth")]
+            pub client_width: f64,
+            #[doc = "Height (CSS pixels), excludes scrollbar if present."]
+            #[serde(rename = "clientHeight")]
+            pub client_height: f64,
+            #[doc = "Scale relative to the ideal viewport (size at width=device-width)."]
+            #[serde(rename = "scale")]
+            pub scale: f64,
+            #[doc = "Page zoom factor (CSS to device independent pixels ratio)."]
+            #[serde(rename = "zoom")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub zoom: Option<f64>,
+        }
+        impl VisualViewport {
+            pub fn builder() -> VisualViewportBuilder {
+                VisualViewportBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct VisualViewportBuilder {
+            offset_x: Option<f64>,
+            offset_y: Option<f64>,
+            page_x: Option<f64>,
+            page_y: Option<f64>,
+            client_width: Option<f64>,
+            client_height: Option<f64>,
+            scale: Option<f64>,
+            zoom: Option<f64>,
+        }
+        impl VisualViewportBuilder {
+            pub fn offset_x(mut self, offset_x: impl Into<f64>) -> Self {
+                self.offset_x = Some(offset_x.into());
+                self
+            }
+            pub fn offset_y(mut self, offset_y: impl Into<f64>) -> Self {
+                self.offset_y = Some(offset_y.into());
+                self
+            }
+            pub fn page_x(mut self, page_x: impl Into<f64>) -> Self {
+                self.page_x = Some(page_x.into());
+                self
+            }
+            pub fn page_y(mut self, page_y: impl Into<f64>) -> Self {
+                self.page_y = Some(page_y.into());
+                self
+            }
+            pub fn client_width(mut self, client_width: impl Into<f64>) -> Self {
+                self.client_width = Some(client_width.into());
+                self
+            }
+            pub fn client_height(mut self, client_height: impl Into<f64>) -> Self {
+                self.client_height = Some(client_height.into());
+                self
+            }
+            pub fn scale(mut self, scale: impl Into<f64>) -> Self {
+                self.scale = Some(scale.into());
+                self
+            }
+            pub fn zoom(mut self, zoom: impl Into<f64>) -> Self {
+                self.zoom = Some(zoom.into());
+                self
+            }
+            pub fn build(self) -> Result<VisualViewport, String> {
+                Ok(VisualViewport {
+                    offset_x: self.offset_x.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(offset_x))
+                    })?,
+                    offset_y: self.offset_y.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(offset_y))
+                    })?,
+                    page_x: self.page_x.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(page_x))
+                    })?,
+                    page_y: self.page_y.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(page_y))
+                    })?,
+                    client_width: self.client_width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(client_width))
+                    })?,
+                    client_height: self.client_height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(client_height))
+                    })?,
+                    scale: self.scale.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scale))
+                    })?,
+                    zoom: self.zoom,
+                })
+            }
+        }
+        impl VisualViewport {
+            pub const IDENTIFIER: &'static str = "Page.VisualViewport";
+        }
+        #[doc = "Viewport for capturing screenshot.\n[Viewport](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-Viewport)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Viewport {
+            #[doc = "X offset in device independent pixels (dip)."]
+            #[serde(rename = "x")]
+            pub x: f64,
+            #[doc = "Y offset in device independent pixels (dip)."]
+            #[serde(rename = "y")]
+            pub y: f64,
+            #[doc = "Rectangle width in device independent pixels (dip)."]
+            #[serde(rename = "width")]
+            pub width: f64,
+            #[doc = "Rectangle height in device independent pixels (dip)."]
+            #[serde(rename = "height")]
+            pub height: f64,
+            #[doc = "Page scale factor."]
+            #[serde(rename = "scale")]
+            pub scale: f64,
+        }
+        impl Viewport {
+            pub fn builder() -> ViewportBuilder {
+                ViewportBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ViewportBuilder {
+            x: Option<f64>,
+            y: Option<f64>,
+            width: Option<f64>,
+            height: Option<f64>,
+            scale: Option<f64>,
+        }
+        impl ViewportBuilder {
+            pub fn x(mut self, x: impl Into<f64>) -> Self {
+                self.x = Some(x.into());
+                self
+            }
+            pub fn y(mut self, y: impl Into<f64>) -> Self {
+                self.y = Some(y.into());
+                self
+            }
+            pub fn width(mut self, width: impl Into<f64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<f64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn scale(mut self, scale: impl Into<f64>) -> Self {
+                self.scale = Some(scale.into());
+                self
+            }
+            pub fn build(self) -> Result<Viewport, String> {
+                Ok(Viewport {
+                    x: self
+                        .x
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(x)))?,
+                    y: self
+                        .y
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(y)))?,
+                    width: self.width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(width))
+                    })?,
+                    height: self.height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(height))
+                    })?,
+                    scale: self.scale.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scale))
+                    })?,
+                })
+            }
+        }
+        impl Viewport {
+            pub const IDENTIFIER: &'static str = "Page.Viewport";
+        }
+        #[doc = "Generic font families collection.\n[FontFamilies](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-FontFamilies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct FontFamilies {
+            #[doc = "The standard font-family."]
+            #[serde(rename = "standard")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub standard: Option<String>,
+            #[doc = "The fixed font-family."]
+            #[serde(rename = "fixed")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub fixed: Option<String>,
+            #[doc = "The serif font-family."]
+            #[serde(rename = "serif")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub serif: Option<String>,
+            #[doc = "The sansSerif font-family."]
+            #[serde(rename = "sansSerif")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub sans_serif: Option<String>,
+            #[doc = "The cursive font-family."]
+            #[serde(rename = "cursive")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cursive: Option<String>,
+            #[doc = "The fantasy font-family."]
+            #[serde(rename = "fantasy")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub fantasy: Option<String>,
+            #[doc = "The math font-family."]
+            #[serde(rename = "math")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub math: Option<String>,
+        }
+        impl FontFamilies {
+            pub fn builder() -> FontFamiliesBuilder {
+                FontFamiliesBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FontFamiliesBuilder {
+            standard: Option<String>,
+            fixed: Option<String>,
+            serif: Option<String>,
+            sans_serif: Option<String>,
+            cursive: Option<String>,
+            fantasy: Option<String>,
+            math: Option<String>,
+        }
+        impl FontFamiliesBuilder {
+            pub fn standard(mut self, standard: impl Into<String>) -> Self {
+                self.standard = Some(standard.into());
+                self
+            }
+            pub fn fixed(mut self, fixed: impl Into<String>) -> Self {
+                self.fixed = Some(fixed.into());
+                self
+            }
+            pub fn serif(mut self, serif: impl Into<String>) -> Self {
+                self.serif = Some(serif.into());
+                self
+            }
+            pub fn sans_serif(mut self, sans_serif: impl Into<String>) -> Self {
+                self.sans_serif = Some(sans_serif.into());
+                self
+            }
+            pub fn cursive(mut self, cursive: impl Into<String>) -> Self {
+                self.cursive = Some(cursive.into());
+                self
+            }
+            pub fn fantasy(mut self, fantasy: impl Into<String>) -> Self {
+                self.fantasy = Some(fantasy.into());
+                self
+            }
+            pub fn math(mut self, math: impl Into<String>) -> Self {
+                self.math = Some(math.into());
+                self
+            }
+            pub fn build(self) -> FontFamilies {
+                FontFamilies {
+                    standard: self.standard,
+                    fixed: self.fixed,
+                    serif: self.serif,
+                    sans_serif: self.sans_serif,
+                    cursive: self.cursive,
+                    fantasy: self.fantasy,
+                    math: self.math,
+                }
+            }
+        }
+        impl FontFamilies {
+            pub const IDENTIFIER: &'static str = "Page.FontFamilies";
+        }
+        #[doc = "Font families collection for a script.\n[ScriptFontFamilies](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-ScriptFontFamilies)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScriptFontFamilies {
+            #[doc = "Name of the script which these font families are defined for."]
+            #[serde(rename = "script")]
+            pub script: String,
+            #[doc = "Generic font families collection for the script."]
+            #[serde(rename = "fontFamilies")]
+            pub font_families: FontFamilies,
+        }
+        impl ScriptFontFamilies {
+            pub fn new(script: impl Into<String>, font_families: impl Into<FontFamilies>) -> Self {
+                Self {
+                    script: script.into(),
+                    font_families: font_families.into(),
+                }
+            }
+        }
+        impl ScriptFontFamilies {
+            pub fn builder() -> ScriptFontFamiliesBuilder {
+                ScriptFontFamiliesBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScriptFontFamiliesBuilder {
+            script: Option<String>,
+            font_families: Option<FontFamilies>,
+        }
+        impl ScriptFontFamiliesBuilder {
+            pub fn script(mut self, script: impl Into<String>) -> Self {
+                self.script = Some(script.into());
+                self
+            }
+            pub fn font_families(mut self, font_families: impl Into<FontFamilies>) -> Self {
+                self.font_families = Some(font_families.into());
+                self
+            }
+            pub fn build(self) -> Result<ScriptFontFamilies, String> {
+                Ok(ScriptFontFamilies {
+                    script: self.script.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script))
+                    })?,
+                    font_families: self.font_families.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_families))
+                    })?,
+                })
+            }
+        }
+        impl ScriptFontFamilies {
+            pub const IDENTIFIER: &'static str = "Page.ScriptFontFamilies";
+        }
+        #[doc = "Default font sizes.\n[FontSizes](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-FontSizes)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct FontSizes {
+            #[doc = "Default standard font size."]
+            #[serde(rename = "standard")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub standard: Option<i64>,
+            #[doc = "Default fixed font size."]
+            #[serde(rename = "fixed")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub fixed: Option<i64>,
+        }
+        impl FontSizes {
+            pub fn builder() -> FontSizesBuilder {
+                FontSizesBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FontSizesBuilder {
+            standard: Option<i64>,
+            fixed: Option<i64>,
+        }
+        impl FontSizesBuilder {
+            pub fn standard(mut self, standard: impl Into<i64>) -> Self {
+                self.standard = Some(standard.into());
+                self
+            }
+            pub fn fixed(mut self, fixed: impl Into<i64>) -> Self {
+                self.fixed = Some(fixed.into());
+                self
+            }
+            pub fn build(self) -> FontSizes {
+                FontSizes {
+                    standard: self.standard,
+                    fixed: self.fixed,
+                }
+            }
+        }
+        impl FontSizes {
+            pub const IDENTIFIER: &'static str = "Page.FontSizes";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ClientNavigationReason {
+            #[serde(rename = "anchorClick")]
+            AnchorClick,
+            #[serde(rename = "formSubmissionGet")]
+            FormSubmissionGet,
+            #[serde(rename = "formSubmissionPost")]
+            FormSubmissionPost,
+            #[serde(rename = "httpHeaderRefresh")]
+            HttpHeaderRefresh,
+            #[serde(rename = "initialFrameNavigation")]
+            InitialFrameNavigation,
+            #[serde(rename = "metaTagRefresh")]
+            MetaTagRefresh,
+            #[serde(rename = "other")]
+            Other,
+            #[serde(rename = "pageBlockInterstitial")]
+            PageBlockInterstitial,
+            #[serde(rename = "reload")]
+            Reload,
+            #[serde(rename = "scriptInitiated")]
+            ScriptInitiated,
+        }
+        impl AsRef<str> for ClientNavigationReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ClientNavigationReason::AnchorClick => "anchorClick",
+                    ClientNavigationReason::FormSubmissionGet => "formSubmissionGet",
+                    ClientNavigationReason::FormSubmissionPost => "formSubmissionPost",
+                    ClientNavigationReason::HttpHeaderRefresh => "httpHeaderRefresh",
+                    ClientNavigationReason::InitialFrameNavigation => "initialFrameNavigation",
+                    ClientNavigationReason::MetaTagRefresh => "metaTagRefresh",
+                    ClientNavigationReason::Other => "other",
+                    ClientNavigationReason::PageBlockInterstitial => "pageBlockInterstitial",
+                    ClientNavigationReason::Reload => "reload",
+                    ClientNavigationReason::ScriptInitiated => "scriptInitiated",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ClientNavigationReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "anchorClick" | "AnchorClick" | "anchorclick" => {
+                        Ok(ClientNavigationReason::AnchorClick)
+                    }
+                    "formSubmissionGet" | "FormSubmissionGet" | "formsubmissionget" => {
+                        Ok(ClientNavigationReason::FormSubmissionGet)
+                    }
+                    "formSubmissionPost" | "FormSubmissionPost" | "formsubmissionpost" => {
+                        Ok(ClientNavigationReason::FormSubmissionPost)
+                    }
+                    "httpHeaderRefresh" | "HttpHeaderRefresh" | "httpheaderrefresh" => {
+                        Ok(ClientNavigationReason::HttpHeaderRefresh)
+                    }
+                    "initialFrameNavigation"
+                    | "InitialFrameNavigation"
+                    | "initialframenavigation" => {
+                        Ok(ClientNavigationReason::InitialFrameNavigation)
+                    }
+                    "metaTagRefresh" | "MetaTagRefresh" | "metatagrefresh" => {
+                        Ok(ClientNavigationReason::MetaTagRefresh)
+                    }
+                    "other" | "Other" => Ok(ClientNavigationReason::Other),
+                    "pageBlockInterstitial" | "PageBlockInterstitial" | "pageblockinterstitial" => {
+                        Ok(ClientNavigationReason::PageBlockInterstitial)
+                    }
+                    "reload" | "Reload" => Ok(ClientNavigationReason::Reload),
+                    "scriptInitiated" | "ScriptInitiated" | "scriptinitiated" => {
+                        Ok(ClientNavigationReason::ScriptInitiated)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ClientNavigationDisposition {
+            #[serde(rename = "currentTab")]
+            CurrentTab,
+            #[serde(rename = "newTab")]
+            NewTab,
+            #[serde(rename = "newWindow")]
+            NewWindow,
+            #[serde(rename = "download")]
+            Download,
+        }
+        impl AsRef<str> for ClientNavigationDisposition {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ClientNavigationDisposition::CurrentTab => "currentTab",
+                    ClientNavigationDisposition::NewTab => "newTab",
+                    ClientNavigationDisposition::NewWindow => "newWindow",
+                    ClientNavigationDisposition::Download => "download",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ClientNavigationDisposition {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "currentTab" | "CurrentTab" | "currenttab" => {
+                        Ok(ClientNavigationDisposition::CurrentTab)
+                    }
+                    "newTab" | "NewTab" | "newtab" => Ok(ClientNavigationDisposition::NewTab),
+                    "newWindow" | "NewWindow" | "newwindow" => {
+                        Ok(ClientNavigationDisposition::NewWindow)
+                    }
+                    "download" | "Download" => Ok(ClientNavigationDisposition::Download),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct InstallabilityErrorArgument {
+            #[doc = "Argument name (e.g. name:'minimum-icon-size-in-pixels')."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Argument value (e.g. value:'64')."]
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl InstallabilityErrorArgument {
+            pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl InstallabilityErrorArgument {
+            pub fn builder() -> InstallabilityErrorArgumentBuilder {
+                InstallabilityErrorArgumentBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InstallabilityErrorArgumentBuilder {
+            name: Option<String>,
+            value: Option<String>,
+        }
+        impl InstallabilityErrorArgumentBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<InstallabilityErrorArgument, String> {
+                Ok(InstallabilityErrorArgument {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl InstallabilityErrorArgument {
+            pub const IDENTIFIER: &'static str = "Page.InstallabilityErrorArgument";
+        }
+        #[doc = "The installability error\n[InstallabilityError](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-InstallabilityError)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct InstallabilityError {
+            #[doc = "The error id (e.g. 'manifest-missing-suitable-icon')."]
+            #[serde(rename = "errorId")]
+            pub error_id: String,
+            #[doc = "The list of error arguments (e.g. {name:'minimum-icon-size-in-pixels', value:'64'})."]
+            #[serde(rename = "errorArguments")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub error_arguments: Vec<InstallabilityErrorArgument>,
+        }
+        impl InstallabilityError {
+            pub fn new(
+                error_id: impl Into<String>,
+                error_arguments: Vec<InstallabilityErrorArgument>,
+            ) -> Self {
+                Self {
+                    error_id: error_id.into(),
+                    error_arguments,
+                }
+            }
+        }
+        impl InstallabilityError {
+            pub fn builder() -> InstallabilityErrorBuilder {
+                InstallabilityErrorBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct InstallabilityErrorBuilder {
+            error_id: Option<String>,
+            error_arguments: Option<Vec<InstallabilityErrorArgument>>,
+        }
+        impl InstallabilityErrorBuilder {
+            pub fn error_id(mut self, error_id: impl Into<String>) -> Self {
+                self.error_id = Some(error_id.into());
+                self
+            }
+            pub fn error_argument(
+                mut self,
+                error_argument: impl Into<InstallabilityErrorArgument>,
+            ) -> Self {
+                let v = self.error_arguments.get_or_insert(Vec::new());
+                v.push(error_argument.into());
+                self
+            }
+            pub fn error_arguments<I, S>(mut self, error_arguments: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<InstallabilityErrorArgument>,
+            {
+                let v = self.error_arguments.get_or_insert(Vec::new());
+                for val in error_arguments {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<InstallabilityError, String> {
+                Ok(InstallabilityError {
+                    error_id: self.error_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(error_id))
+                    })?,
+                    error_arguments: self.error_arguments.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(error_arguments))
+                    })?,
+                })
+            }
+        }
+        impl InstallabilityError {
+            pub const IDENTIFIER: &'static str = "Page.InstallabilityError";
+        }
+        #[doc = "The referring-policy used for the navigation."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ReferrerPolicy {
+            #[serde(rename = "noReferrer")]
+            NoReferrer,
+            #[serde(rename = "noReferrerWhenDowngrade")]
+            NoReferrerWhenDowngrade,
+            #[serde(rename = "origin")]
+            Origin,
+            #[serde(rename = "originWhenCrossOrigin")]
+            OriginWhenCrossOrigin,
+            #[serde(rename = "sameOrigin")]
+            SameOrigin,
+            #[serde(rename = "strictOrigin")]
+            StrictOrigin,
+            #[serde(rename = "strictOriginWhenCrossOrigin")]
+            StrictOriginWhenCrossOrigin,
+            #[serde(rename = "unsafeUrl")]
+            UnsafeUrl,
+        }
+        impl AsRef<str> for ReferrerPolicy {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ReferrerPolicy::NoReferrer => "noReferrer",
+                    ReferrerPolicy::NoReferrerWhenDowngrade => "noReferrerWhenDowngrade",
+                    ReferrerPolicy::Origin => "origin",
+                    ReferrerPolicy::OriginWhenCrossOrigin => "originWhenCrossOrigin",
+                    ReferrerPolicy::SameOrigin => "sameOrigin",
+                    ReferrerPolicy::StrictOrigin => "strictOrigin",
+                    ReferrerPolicy::StrictOriginWhenCrossOrigin => "strictOriginWhenCrossOrigin",
+                    ReferrerPolicy::UnsafeUrl => "unsafeUrl",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ReferrerPolicy {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "noReferrer" | "NoReferrer" | "noreferrer" => Ok(ReferrerPolicy::NoReferrer),
+                    "noReferrerWhenDowngrade"
+                    | "NoReferrerWhenDowngrade"
+                    | "noreferrerwhendowngrade" => Ok(ReferrerPolicy::NoReferrerWhenDowngrade),
+                    "origin" | "Origin" => Ok(ReferrerPolicy::Origin),
+                    "originWhenCrossOrigin" | "OriginWhenCrossOrigin" | "originwhencrossorigin" => {
+                        Ok(ReferrerPolicy::OriginWhenCrossOrigin)
+                    }
+                    "sameOrigin" | "SameOrigin" | "sameorigin" => Ok(ReferrerPolicy::SameOrigin),
+                    "strictOrigin" | "StrictOrigin" | "strictorigin" => {
+                        Ok(ReferrerPolicy::StrictOrigin)
+                    }
+                    "strictOriginWhenCrossOrigin"
+                    | "StrictOriginWhenCrossOrigin"
+                    | "strictoriginwhencrossorigin" => {
+                        Ok(ReferrerPolicy::StrictOriginWhenCrossOrigin)
+                    }
+                    "unsafeUrl" | "UnsafeUrl" | "unsafeurl" => Ok(ReferrerPolicy::UnsafeUrl),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Per-script compilation cache parameters for `Page.produceCompilationCache`\n[CompilationCacheParams](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-CompilationCacheParams)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CompilationCacheParams {
+            #[doc = "The URL of the script to produce a compilation cache entry for."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "A hint to the backend whether eager compilation is recommended.\n(the actual compilation mode used is upon backend discretion)."]
+            #[serde(rename = "eager")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub eager: Option<bool>,
+        }
+        impl CompilationCacheParams {
+            pub fn new(url: impl Into<String>) -> Self {
+                Self {
+                    url: url.into(),
+                    eager: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for CompilationCacheParams {
+            fn from(url: T) -> Self {
+                CompilationCacheParams::new(url)
+            }
+        }
+        impl CompilationCacheParams {
+            pub fn builder() -> CompilationCacheParamsBuilder {
+                CompilationCacheParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CompilationCacheParamsBuilder {
+            url: Option<String>,
+            eager: Option<bool>,
+        }
+        impl CompilationCacheParamsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn eager(mut self, eager: impl Into<bool>) -> Self {
+                self.eager = Some(eager.into());
+                self
+            }
+            pub fn build(self) -> Result<CompilationCacheParams, String> {
+                Ok(CompilationCacheParams {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    eager: self.eager,
+                })
+            }
+        }
+        impl CompilationCacheParams {
+            pub const IDENTIFIER: &'static str = "Page.CompilationCacheParams";
+        }
+        #[doc = "The manifest of a webapp, see\nhttps://www.w3.org/TR/appmanifest/#dfn-manifest.\nSome fields do not appear in the standard since the API is designed to\nexpose more browser internal states.\n[FileFilter](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-FileFilter)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct FileFilter {
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[serde(rename = "accepts")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub accepts: Option<Vec<String>>,
+        }
+        impl FileFilter {
+            pub fn builder() -> FileFilterBuilder {
+                FileFilterBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FileFilterBuilder {
+            name: Option<String>,
+            accepts: Option<Vec<String>>,
+        }
+        impl FileFilterBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn accept(mut self, accept: impl Into<String>) -> Self {
+                let v = self.accepts.get_or_insert(Vec::new());
+                v.push(accept.into());
+                self
+            }
+            pub fn accepts<I, S>(mut self, accepts: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.accepts.get_or_insert(Vec::new());
+                for val in accepts {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> FileFilter {
+                FileFilter {
+                    name: self.name,
+                    accepts: self.accepts,
+                }
+            }
+        }
+        impl FileFilter {
+            pub const IDENTIFIER: &'static str = "Page.FileFilter";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct FileHandler {
+            #[serde(rename = "action")]
+            pub action: String,
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "icons")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub icons: Option<Vec<ImageResource>>,
+            #[doc = "Mimic a map, name is the key, accepts is the value."]
+            #[serde(rename = "accepts")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub accepts: Option<Vec<FileFilter>>,
+            #[doc = "Won't repeat the enums, using string for easy comparison. Same as the\nother enums below."]
+            #[serde(rename = "launchType")]
+            pub launch_type: String,
+        }
+        impl FileHandler {
+            pub fn new(
+                action: impl Into<String>,
+                name: impl Into<String>,
+                launch_type: impl Into<String>,
+            ) -> Self {
+                Self {
+                    action: action.into(),
+                    name: name.into(),
+                    launch_type: launch_type.into(),
+                    icons: None,
+                    accepts: None,
+                }
+            }
+        }
+        impl FileHandler {
+            pub fn builder() -> FileHandlerBuilder {
+                FileHandlerBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FileHandlerBuilder {
+            action: Option<String>,
+            name: Option<String>,
+            icons: Option<Vec<ImageResource>>,
+            accepts: Option<Vec<FileFilter>>,
+            launch_type: Option<String>,
+        }
+        impl FileHandlerBuilder {
+            pub fn action(mut self, action: impl Into<String>) -> Self {
+                self.action = Some(action.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn icon(mut self, icon: impl Into<ImageResource>) -> Self {
+                let v = self.icons.get_or_insert(Vec::new());
+                v.push(icon.into());
+                self
+            }
+            pub fn icons<I, S>(mut self, icons: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ImageResource>,
+            {
+                let v = self.icons.get_or_insert(Vec::new());
+                for val in icons {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn accept(mut self, accept: impl Into<FileFilter>) -> Self {
+                let v = self.accepts.get_or_insert(Vec::new());
+                v.push(accept.into());
+                self
+            }
+            pub fn accepts<I, S>(mut self, accepts: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FileFilter>,
+            {
+                let v = self.accepts.get_or_insert(Vec::new());
+                for val in accepts {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn launch_type(mut self, launch_type: impl Into<String>) -> Self {
+                self.launch_type = Some(launch_type.into());
+                self
+            }
+            pub fn build(self) -> Result<FileHandler, String> {
+                Ok(FileHandler {
+                    action: self.action.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(action))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    icons: self.icons,
+                    accepts: self.accepts,
+                    launch_type: self.launch_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(launch_type))
+                    })?,
+                })
+            }
+        }
+        impl FileHandler {
+            pub const IDENTIFIER: &'static str = "Page.FileHandler";
+        }
+        #[doc = "The image definition used in both icon and screenshot.\n[ImageResource](https://chromedevtools.github.io/devtools-protocol/tot/Page/#type-ImageResource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ImageResource {
+            #[doc = "The src field in the definition, but changing to url in favor of\nconsistency."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[serde(rename = "sizes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub sizes: Option<String>,
+            #[serde(rename = "type")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub r#type: Option<String>,
+        }
+        impl ImageResource {
+            pub fn new(url: impl Into<String>) -> Self {
+                Self {
+                    url: url.into(),
+                    sizes: None,
+                    r#type: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for ImageResource {
+            fn from(url: T) -> Self {
+                ImageResource::new(url)
+            }
+        }
+        impl ImageResource {
+            pub fn builder() -> ImageResourceBuilder {
+                ImageResourceBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ImageResourceBuilder {
+            url: Option<String>,
+            sizes: Option<String>,
+            r#type: Option<String>,
+        }
+        impl ImageResourceBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn sizes(mut self, sizes: impl Into<String>) -> Self {
+                self.sizes = Some(sizes.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> Result<ImageResource, String> {
+                Ok(ImageResource {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    sizes: self.sizes,
+                    r#type: self.r#type,
+                })
+            }
+        }
+        impl ImageResource {
+            pub const IDENTIFIER: &'static str = "Page.ImageResource";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LaunchHandler {
+            #[serde(rename = "clientMode")]
+            pub client_mode: String,
+        }
+        impl LaunchHandler {
+            pub fn new(client_mode: impl Into<String>) -> Self {
+                Self {
+                    client_mode: client_mode.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for LaunchHandler {
+            fn from(url: T) -> Self {
+                LaunchHandler::new(url)
+            }
+        }
+        impl LaunchHandler {
+            pub fn builder() -> LaunchHandlerBuilder {
+                LaunchHandlerBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LaunchHandlerBuilder {
+            client_mode: Option<String>,
+        }
+        impl LaunchHandlerBuilder {
+            pub fn client_mode(mut self, client_mode: impl Into<String>) -> Self {
+                self.client_mode = Some(client_mode.into());
+                self
+            }
+            pub fn build(self) -> Result<LaunchHandler, String> {
+                Ok(LaunchHandler {
+                    client_mode: self.client_mode.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(client_mode))
+                    })?,
+                })
+            }
+        }
+        impl LaunchHandler {
+            pub const IDENTIFIER: &'static str = "Page.LaunchHandler";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ProtocolHandler {
+            #[serde(rename = "protocol")]
+            pub protocol: String,
+            #[serde(rename = "url")]
+            pub url: String,
+        }
+        impl ProtocolHandler {
+            pub fn new(protocol: impl Into<String>, url: impl Into<String>) -> Self {
+                Self {
+                    protocol: protocol.into(),
+                    url: url.into(),
+                }
+            }
+        }
+        impl ProtocolHandler {
+            pub fn builder() -> ProtocolHandlerBuilder {
+                ProtocolHandlerBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ProtocolHandlerBuilder {
+            protocol: Option<String>,
+            url: Option<String>,
+        }
+        impl ProtocolHandlerBuilder {
+            pub fn protocol(mut self, protocol: impl Into<String>) -> Self {
+                self.protocol = Some(protocol.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn build(self) -> Result<ProtocolHandler, String> {
+                Ok(ProtocolHandler {
+                    protocol: self.protocol.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(protocol))
+                    })?,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                })
+            }
+        }
+        impl ProtocolHandler {
+            pub const IDENTIFIER: &'static str = "Page.ProtocolHandler";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RelatedApplication {
+            #[serde(rename = "id")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub id: Option<String>,
+            #[serde(rename = "url")]
+            pub url: String,
+        }
+        impl RelatedApplication {
+            pub fn new(url: impl Into<String>) -> Self {
+                Self {
+                    url: url.into(),
+                    id: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for RelatedApplication {
+            fn from(url: T) -> Self {
+                RelatedApplication::new(url)
+            }
+        }
+        impl RelatedApplication {
+            pub fn builder() -> RelatedApplicationBuilder {
+                RelatedApplicationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RelatedApplicationBuilder {
+            id: Option<String>,
+            url: Option<String>,
+        }
+        impl RelatedApplicationBuilder {
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn build(self) -> Result<RelatedApplication, String> {
+                Ok(RelatedApplication {
+                    id: self.id,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                })
+            }
+        }
+        impl RelatedApplication {
+            pub const IDENTIFIER: &'static str = "Page.RelatedApplication";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScopeExtension {
+            #[doc = "Instead of using tuple, this field always returns the serialized string\nfor easy understanding and comparison."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[serde(rename = "hasOriginWildcard")]
+            pub has_origin_wildcard: bool,
+        }
+        impl ScopeExtension {
+            pub fn new(origin: impl Into<String>, has_origin_wildcard: impl Into<bool>) -> Self {
+                Self {
+                    origin: origin.into(),
+                    has_origin_wildcard: has_origin_wildcard.into(),
+                }
+            }
+        }
+        impl ScopeExtension {
+            pub fn builder() -> ScopeExtensionBuilder {
+                ScopeExtensionBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScopeExtensionBuilder {
+            origin: Option<String>,
+            has_origin_wildcard: Option<bool>,
+        }
+        impl ScopeExtensionBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn has_origin_wildcard(mut self, has_origin_wildcard: impl Into<bool>) -> Self {
+                self.has_origin_wildcard = Some(has_origin_wildcard.into());
+                self
+            }
+            pub fn build(self) -> Result<ScopeExtension, String> {
+                Ok(ScopeExtension {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    has_origin_wildcard: self.has_origin_wildcard.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(has_origin_wildcard)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl ScopeExtension {
+            pub const IDENTIFIER: &'static str = "Page.ScopeExtension";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Screenshot {
+            #[serde(rename = "image")]
+            pub image: ImageResource,
+            #[serde(rename = "formFactor")]
+            pub form_factor: String,
+            #[serde(rename = "label")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub label: Option<String>,
+        }
+        impl Screenshot {
+            pub fn new(image: impl Into<ImageResource>, form_factor: impl Into<String>) -> Self {
+                Self {
+                    image: image.into(),
+                    form_factor: form_factor.into(),
+                    label: None,
+                }
+            }
+        }
+        impl Screenshot {
+            pub fn builder() -> ScreenshotBuilder {
+                ScreenshotBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScreenshotBuilder {
+            image: Option<ImageResource>,
+            form_factor: Option<String>,
+            label: Option<String>,
+        }
+        impl ScreenshotBuilder {
+            pub fn image(mut self, image: impl Into<ImageResource>) -> Self {
+                self.image = Some(image.into());
+                self
+            }
+            pub fn form_factor(mut self, form_factor: impl Into<String>) -> Self {
+                self.form_factor = Some(form_factor.into());
+                self
+            }
+            pub fn label(mut self, label: impl Into<String>) -> Self {
+                self.label = Some(label.into());
+                self
+            }
+            pub fn build(self) -> Result<Screenshot, String> {
+                Ok(Screenshot {
+                    image: self.image.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(image))
+                    })?,
+                    form_factor: self.form_factor.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(form_factor))
+                    })?,
+                    label: self.label,
+                })
+            }
+        }
+        impl Screenshot {
+            pub const IDENTIFIER: &'static str = "Page.Screenshot";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ShareTarget {
+            #[serde(rename = "action")]
+            pub action: String,
+            #[serde(rename = "method")]
+            pub method: String,
+            #[serde(rename = "enctype")]
+            pub enctype: String,
+            #[doc = "Embed the ShareTargetParams"]
+            #[serde(rename = "title")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub title: Option<String>,
+            #[serde(rename = "text")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub text: Option<String>,
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[serde(rename = "files")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub files: Option<Vec<FileFilter>>,
+        }
+        impl ShareTarget {
+            pub fn new(
+                action: impl Into<String>,
+                method: impl Into<String>,
+                enctype: impl Into<String>,
+            ) -> Self {
+                Self {
+                    action: action.into(),
+                    method: method.into(),
+                    enctype: enctype.into(),
+                    title: None,
+                    text: None,
+                    url: None,
+                    files: None,
+                }
+            }
+        }
+        impl ShareTarget {
+            pub fn builder() -> ShareTargetBuilder {
+                ShareTargetBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ShareTargetBuilder {
+            action: Option<String>,
+            method: Option<String>,
+            enctype: Option<String>,
+            title: Option<String>,
+            text: Option<String>,
+            url: Option<String>,
+            files: Option<Vec<FileFilter>>,
+        }
+        impl ShareTargetBuilder {
+            pub fn action(mut self, action: impl Into<String>) -> Self {
+                self.action = Some(action.into());
+                self
+            }
+            pub fn method(mut self, method: impl Into<String>) -> Self {
+                self.method = Some(method.into());
+                self
+            }
+            pub fn enctype(mut self, enctype: impl Into<String>) -> Self {
+                self.enctype = Some(enctype.into());
+                self
+            }
+            pub fn title(mut self, title: impl Into<String>) -> Self {
+                self.title = Some(title.into());
+                self
+            }
+            pub fn text(mut self, text: impl Into<String>) -> Self {
+                self.text = Some(text.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn file(mut self, file: impl Into<FileFilter>) -> Self {
+                let v = self.files.get_or_insert(Vec::new());
+                v.push(file.into());
+                self
+            }
+            pub fn files<I, S>(mut self, files: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FileFilter>,
+            {
+                let v = self.files.get_or_insert(Vec::new());
+                for val in files {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ShareTarget, String> {
+                Ok(ShareTarget {
+                    action: self.action.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(action))
+                    })?,
+                    method: self.method.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(method))
+                    })?,
+                    enctype: self.enctype.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enctype))
+                    })?,
+                    title: self.title,
+                    text: self.text,
+                    url: self.url,
+                    files: self.files,
+                })
+            }
+        }
+        impl ShareTarget {
+            pub const IDENTIFIER: &'static str = "Page.ShareTarget";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Shortcut {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "url")]
+            pub url: String,
+        }
+        impl Shortcut {
+            pub fn new(name: impl Into<String>, url: impl Into<String>) -> Self {
+                Self {
+                    name: name.into(),
+                    url: url.into(),
+                }
+            }
+        }
+        impl Shortcut {
+            pub fn builder() -> ShortcutBuilder {
+                ShortcutBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ShortcutBuilder {
+            name: Option<String>,
+            url: Option<String>,
+        }
+        impl ShortcutBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn build(self) -> Result<Shortcut, String> {
+                Ok(Shortcut {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                })
+            }
+        }
+        impl Shortcut {
+            pub const IDENTIFIER: &'static str = "Page.Shortcut";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct WebAppManifest {
+            #[serde(rename = "backgroundColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub background_color: Option<String>,
+            #[doc = "The extra description provided by the manifest."]
+            #[serde(rename = "description")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub description: Option<String>,
+            #[serde(rename = "dir")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub dir: Option<String>,
+            #[serde(rename = "display")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub display: Option<String>,
+            #[doc = "The overrided display mode controlled by the user."]
+            #[serde(rename = "displayOverrides")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub display_overrides: Option<Vec<String>>,
+            #[doc = "The handlers to open files."]
+            #[serde(rename = "fileHandlers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub file_handlers: Option<Vec<FileHandler>>,
+            #[serde(rename = "icons")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub icons: Option<Vec<ImageResource>>,
+            #[serde(rename = "id")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub id: Option<String>,
+            #[serde(rename = "lang")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub lang: Option<String>,
+            #[doc = "TODO(crbug.com/1231886): This field is non-standard and part of a Chrome\nexperiment. See:\nhttps://github.com/WICG/web-app-launch/blob/main/launch_handler.md"]
+            #[serde(rename = "launchHandler")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub launch_handler: Option<LaunchHandler>,
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[serde(rename = "orientation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub orientation: Option<String>,
+            #[serde(rename = "preferRelatedApplications")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub prefer_related_applications: Option<bool>,
+            #[doc = "The handlers to open protocols."]
+            #[serde(rename = "protocolHandlers")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub protocol_handlers: Option<Vec<ProtocolHandler>>,
+            #[serde(rename = "relatedApplications")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub related_applications: Option<Vec<RelatedApplication>>,
+            #[serde(rename = "scope")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scope: Option<String>,
+            #[doc = "Non-standard, see\nhttps://github.com/WICG/manifest-incubations/blob/gh-pages/scope_extensions-explainer.md"]
+            #[serde(rename = "scopeExtensions")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scope_extensions: Option<Vec<ScopeExtension>>,
+            #[doc = "The screenshots used by chromium."]
+            #[serde(rename = "screenshots")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub screenshots: Option<Vec<Screenshot>>,
+            #[serde(rename = "shareTarget")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub share_target: Option<ShareTarget>,
+            #[serde(rename = "shortName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub short_name: Option<String>,
+            #[serde(rename = "shortcuts")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub shortcuts: Option<Vec<Shortcut>>,
+            #[serde(rename = "startUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub start_url: Option<String>,
+            #[serde(rename = "themeColor")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub theme_color: Option<String>,
+        }
+        impl WebAppManifest {
+            pub fn builder() -> WebAppManifestBuilder {
+                WebAppManifestBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct WebAppManifestBuilder {
+            background_color: Option<String>,
+            description: Option<String>,
+            dir: Option<String>,
+            display: Option<String>,
+            display_overrides: Option<Vec<String>>,
+            file_handlers: Option<Vec<FileHandler>>,
+            icons: Option<Vec<ImageResource>>,
+            id: Option<String>,
+            lang: Option<String>,
+            launch_handler: Option<LaunchHandler>,
+            name: Option<String>,
+            orientation: Option<String>,
+            prefer_related_applications: Option<bool>,
+            protocol_handlers: Option<Vec<ProtocolHandler>>,
+            related_applications: Option<Vec<RelatedApplication>>,
+            scope: Option<String>,
+            scope_extensions: Option<Vec<ScopeExtension>>,
+            screenshots: Option<Vec<Screenshot>>,
+            share_target: Option<ShareTarget>,
+            short_name: Option<String>,
+            shortcuts: Option<Vec<Shortcut>>,
+            start_url: Option<String>,
+            theme_color: Option<String>,
+        }
+        impl WebAppManifestBuilder {
+            pub fn background_color(mut self, background_color: impl Into<String>) -> Self {
+                self.background_color = Some(background_color.into());
+                self
+            }
+            pub fn description(mut self, description: impl Into<String>) -> Self {
+                self.description = Some(description.into());
+                self
+            }
+            pub fn dir(mut self, dir: impl Into<String>) -> Self {
+                self.dir = Some(dir.into());
+                self
+            }
+            pub fn display(mut self, display: impl Into<String>) -> Self {
+                self.display = Some(display.into());
+                self
+            }
+            pub fn display_override(mut self, display_override: impl Into<String>) -> Self {
+                let v = self.display_overrides.get_or_insert(Vec::new());
+                v.push(display_override.into());
+                self
+            }
+            pub fn display_overrides<I, S>(mut self, display_overrides: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.display_overrides.get_or_insert(Vec::new());
+                for val in display_overrides {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn file_handler(mut self, file_handler: impl Into<FileHandler>) -> Self {
+                let v = self.file_handlers.get_or_insert(Vec::new());
+                v.push(file_handler.into());
+                self
+            }
+            pub fn file_handlers<I, S>(mut self, file_handlers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<FileHandler>,
+            {
+                let v = self.file_handlers.get_or_insert(Vec::new());
+                for val in file_handlers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn icon(mut self, icon: impl Into<ImageResource>) -> Self {
+                let v = self.icons.get_or_insert(Vec::new());
+                v.push(icon.into());
+                self
+            }
+            pub fn icons<I, S>(mut self, icons: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ImageResource>,
+            {
+                let v = self.icons.get_or_insert(Vec::new());
+                for val in icons {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn lang(mut self, lang: impl Into<String>) -> Self {
+                self.lang = Some(lang.into());
+                self
+            }
+            pub fn launch_handler(mut self, launch_handler: impl Into<LaunchHandler>) -> Self {
+                self.launch_handler = Some(launch_handler.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn orientation(mut self, orientation: impl Into<String>) -> Self {
+                self.orientation = Some(orientation.into());
+                self
+            }
+            pub fn prefer_related_applications(
+                mut self,
+                prefer_related_applications: impl Into<bool>,
+            ) -> Self {
+                self.prefer_related_applications = Some(prefer_related_applications.into());
+                self
+            }
+            pub fn protocol_handler(
+                mut self,
+                protocol_handler: impl Into<ProtocolHandler>,
+            ) -> Self {
+                let v = self.protocol_handlers.get_or_insert(Vec::new());
+                v.push(protocol_handler.into());
+                self
+            }
+            pub fn protocol_handlers<I, S>(mut self, protocol_handlers: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ProtocolHandler>,
+            {
+                let v = self.protocol_handlers.get_or_insert(Vec::new());
+                for val in protocol_handlers {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn related_application(
+                mut self,
+                related_application: impl Into<RelatedApplication>,
+            ) -> Self {
+                let v = self.related_applications.get_or_insert(Vec::new());
+                v.push(related_application.into());
+                self
+            }
+            pub fn related_applications<I, S>(mut self, related_applications: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<RelatedApplication>,
+            {
+                let v = self.related_applications.get_or_insert(Vec::new());
+                for val in related_applications {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn scope(mut self, scope: impl Into<String>) -> Self {
+                self.scope = Some(scope.into());
+                self
+            }
+            pub fn scope_extension(mut self, scope_extension: impl Into<ScopeExtension>) -> Self {
+                let v = self.scope_extensions.get_or_insert(Vec::new());
+                v.push(scope_extension.into());
+                self
+            }
+            pub fn scope_extensions<I, S>(mut self, scope_extensions: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ScopeExtension>,
+            {
+                let v = self.scope_extensions.get_or_insert(Vec::new());
+                for val in scope_extensions {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn screenshot(mut self, screenshot: impl Into<Screenshot>) -> Self {
+                let v = self.screenshots.get_or_insert(Vec::new());
+                v.push(screenshot.into());
+                self
+            }
+            pub fn screenshots<I, S>(mut self, screenshots: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Screenshot>,
+            {
+                let v = self.screenshots.get_or_insert(Vec::new());
+                for val in screenshots {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn share_target(mut self, share_target: impl Into<ShareTarget>) -> Self {
+                self.share_target = Some(share_target.into());
+                self
+            }
+            pub fn short_name(mut self, short_name: impl Into<String>) -> Self {
+                self.short_name = Some(short_name.into());
+                self
+            }
+            pub fn shortcut(mut self, shortcut: impl Into<Shortcut>) -> Self {
+                let v = self.shortcuts.get_or_insert(Vec::new());
+                v.push(shortcut.into());
+                self
+            }
+            pub fn shortcuts<I, S>(mut self, shortcuts: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Shortcut>,
+            {
+                let v = self.shortcuts.get_or_insert(Vec::new());
+                for val in shortcuts {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn start_url(mut self, start_url: impl Into<String>) -> Self {
+                self.start_url = Some(start_url.into());
+                self
+            }
+            pub fn theme_color(mut self, theme_color: impl Into<String>) -> Self {
+                self.theme_color = Some(theme_color.into());
+                self
+            }
+            pub fn build(self) -> WebAppManifest {
+                WebAppManifest {
+                    background_color: self.background_color,
+                    description: self.description,
+                    dir: self.dir,
+                    display: self.display,
+                    display_overrides: self.display_overrides,
+                    file_handlers: self.file_handlers,
+                    icons: self.icons,
+                    id: self.id,
+                    lang: self.lang,
+                    launch_handler: self.launch_handler,
+                    name: self.name,
+                    orientation: self.orientation,
+                    prefer_related_applications: self.prefer_related_applications,
+                    protocol_handlers: self.protocol_handlers,
+                    related_applications: self.related_applications,
+                    scope: self.scope,
+                    scope_extensions: self.scope_extensions,
+                    screenshots: self.screenshots,
+                    share_target: self.share_target,
+                    short_name: self.short_name,
+                    shortcuts: self.shortcuts,
+                    start_url: self.start_url,
+                    theme_color: self.theme_color,
+                }
+            }
+        }
+        impl WebAppManifest {
+            pub const IDENTIFIER: &'static str = "Page.WebAppManifest";
+        }
+        #[doc = "The type of a frameNavigated event."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum NavigationType {
+            #[serde(rename = "Navigation")]
+            Navigation,
+            #[serde(rename = "BackForwardCacheRestore")]
+            BackForwardCacheRestore,
+        }
+        impl AsRef<str> for NavigationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    NavigationType::Navigation => "Navigation",
+                    NavigationType::BackForwardCacheRestore => "BackForwardCacheRestore",
+                }
+            }
+        }
+        impl ::std::str::FromStr for NavigationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Navigation" | "navigation" => Ok(NavigationType::Navigation),
+                    "BackForwardCacheRestore" | "backforwardcacherestore" => {
+                        Ok(NavigationType::BackForwardCacheRestore)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "List of not restored reasons for back-forward cache."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum BackForwardCacheNotRestoredReason {
+            #[serde(rename = "NotPrimaryMainFrame")]
+            NotPrimaryMainFrame,
+            #[serde(rename = "BackForwardCacheDisabled")]
+            BackForwardCacheDisabled,
+            #[serde(rename = "RelatedActiveContentsExist")]
+            RelatedActiveContentsExist,
+            #[serde(rename = "HTTPStatusNotOK")]
+            HttpStatusNotOk,
+            #[serde(rename = "SchemeNotHTTPOrHTTPS")]
+            SchemeNotHttpOrHttps,
+            #[serde(rename = "Loading")]
+            Loading,
+            #[serde(rename = "WasGrantedMediaAccess")]
+            WasGrantedMediaAccess,
+            #[serde(rename = "DisableForRenderFrameHostCalled")]
+            DisableForRenderFrameHostCalled,
+            #[serde(rename = "DomainNotAllowed")]
+            DomainNotAllowed,
+            #[serde(rename = "HTTPMethodNotGET")]
+            HttpMethodNotGet,
+            #[serde(rename = "SubframeIsNavigating")]
+            SubframeIsNavigating,
+            #[serde(rename = "Timeout")]
+            Timeout,
+            #[serde(rename = "CacheLimit")]
+            CacheLimit,
+            #[serde(rename = "JavaScriptExecution")]
+            JavaScriptExecution,
+            #[serde(rename = "RendererProcessKilled")]
+            RendererProcessKilled,
+            #[serde(rename = "RendererProcessCrashed")]
+            RendererProcessCrashed,
+            #[serde(rename = "SchedulerTrackedFeatureUsed")]
+            SchedulerTrackedFeatureUsed,
+            #[serde(rename = "ConflictingBrowsingInstance")]
+            ConflictingBrowsingInstance,
+            #[serde(rename = "CacheFlushed")]
+            CacheFlushed,
+            #[serde(rename = "ServiceWorkerVersionActivation")]
+            ServiceWorkerVersionActivation,
+            #[serde(rename = "SessionRestored")]
+            SessionRestored,
+            #[serde(rename = "ServiceWorkerPostMessage")]
+            ServiceWorkerPostMessage,
+            #[serde(rename = "EnteredBackForwardCacheBeforeServiceWorkerHostAdded")]
+            EnteredBackForwardCacheBeforeServiceWorkerHostAdded,
+            #[serde(rename = "RenderFrameHostReused_SameSite")]
+            RenderFrameHostReusedSameSite,
+            #[serde(rename = "RenderFrameHostReused_CrossSite")]
+            RenderFrameHostReusedCrossSite,
+            #[serde(rename = "ServiceWorkerClaim")]
+            ServiceWorkerClaim,
+            #[serde(rename = "IgnoreEventAndEvict")]
+            IgnoreEventAndEvict,
+            #[serde(rename = "HaveInnerContents")]
+            HaveInnerContents,
+            #[serde(rename = "TimeoutPuttingInCache")]
+            TimeoutPuttingInCache,
+            #[serde(rename = "BackForwardCacheDisabledByLowMemory")]
+            BackForwardCacheDisabledByLowMemory,
+            #[serde(rename = "BackForwardCacheDisabledByCommandLine")]
+            BackForwardCacheDisabledByCommandLine,
+            #[serde(rename = "NetworkRequestDatapipeDrainedAsBytesConsumer")]
+            NetworkRequestDatapipeDrainedAsBytesConsumer,
+            #[serde(rename = "NetworkRequestRedirected")]
+            NetworkRequestRedirected,
+            #[serde(rename = "NetworkRequestTimeout")]
+            NetworkRequestTimeout,
+            #[serde(rename = "NetworkExceedsBufferLimit")]
+            NetworkExceedsBufferLimit,
+            #[serde(rename = "NavigationCancelledWhileRestoring")]
+            NavigationCancelledWhileRestoring,
+            #[serde(rename = "NotMostRecentNavigationEntry")]
+            NotMostRecentNavigationEntry,
+            #[serde(rename = "BackForwardCacheDisabledForPrerender")]
+            BackForwardCacheDisabledForPrerender,
+            #[serde(rename = "UserAgentOverrideDiffers")]
+            UserAgentOverrideDiffers,
+            #[serde(rename = "ForegroundCacheLimit")]
+            ForegroundCacheLimit,
+            #[serde(rename = "BrowsingInstanceNotSwapped")]
+            BrowsingInstanceNotSwapped,
+            #[serde(rename = "BackForwardCacheDisabledForDelegate")]
+            BackForwardCacheDisabledForDelegate,
+            #[serde(rename = "UnloadHandlerExistsInMainFrame")]
+            UnloadHandlerExistsInMainFrame,
+            #[serde(rename = "UnloadHandlerExistsInSubFrame")]
+            UnloadHandlerExistsInSubFrame,
+            #[serde(rename = "ServiceWorkerUnregistration")]
+            ServiceWorkerUnregistration,
+            #[serde(rename = "CacheControlNoStore")]
+            CacheControlNoStore,
+            #[serde(rename = "CacheControlNoStoreCookieModified")]
+            CacheControlNoStoreCookieModified,
+            #[serde(rename = "CacheControlNoStoreHTTPOnlyCookieModified")]
+            CacheControlNoStoreHttpOnlyCookieModified,
+            #[serde(rename = "NoResponseHead")]
+            NoResponseHead,
+            #[serde(rename = "Unknown")]
+            Unknown,
+            #[serde(rename = "ActivationNavigationsDisallowedForBug1234857")]
+            ActivationNavigationsDisallowedForBug1234857,
+            #[serde(rename = "ErrorDocument")]
+            ErrorDocument,
+            #[serde(rename = "FencedFramesEmbedder")]
+            FencedFramesEmbedder,
+            #[serde(rename = "CookieDisabled")]
+            CookieDisabled,
+            #[serde(rename = "HTTPAuthRequired")]
+            HttpAuthRequired,
+            #[serde(rename = "CookieFlushed")]
+            CookieFlushed,
+            #[serde(rename = "BroadcastChannelOnMessage")]
+            BroadcastChannelOnMessage,
+            #[serde(rename = "WebViewSettingsChanged")]
+            WebViewSettingsChanged,
+            #[serde(rename = "WebViewJavaScriptObjectChanged")]
+            WebViewJavaScriptObjectChanged,
+            #[serde(rename = "WebViewMessageListenerInjected")]
+            WebViewMessageListenerInjected,
+            #[serde(rename = "WebViewSafeBrowsingAllowlistChanged")]
+            WebViewSafeBrowsingAllowlistChanged,
+            #[serde(rename = "WebViewDocumentStartJavascriptChanged")]
+            WebViewDocumentStartJavascriptChanged,
+            #[doc = "Blocklisted features"]
+            #[serde(rename = "WebSocket")]
+            WebSocket,
+            #[serde(rename = "WebTransport")]
+            WebTransport,
+            #[serde(rename = "WebRTC")]
+            WebRtc,
+            #[serde(rename = "MainResourceHasCacheControlNoStore")]
+            MainResourceHasCacheControlNoStore,
+            #[serde(rename = "MainResourceHasCacheControlNoCache")]
+            MainResourceHasCacheControlNoCache,
+            #[serde(rename = "SubresourceHasCacheControlNoStore")]
+            SubresourceHasCacheControlNoStore,
+            #[serde(rename = "SubresourceHasCacheControlNoCache")]
+            SubresourceHasCacheControlNoCache,
+            #[serde(rename = "ContainsPlugins")]
+            ContainsPlugins,
+            #[serde(rename = "DocumentLoaded")]
+            DocumentLoaded,
+            #[serde(rename = "OutstandingNetworkRequestOthers")]
+            OutstandingNetworkRequestOthers,
+            #[serde(rename = "RequestedMIDIPermission")]
+            RequestedMidiPermission,
+            #[serde(rename = "RequestedAudioCapturePermission")]
+            RequestedAudioCapturePermission,
+            #[serde(rename = "RequestedVideoCapturePermission")]
+            RequestedVideoCapturePermission,
+            #[serde(rename = "RequestedBackForwardCacheBlockedSensors")]
+            RequestedBackForwardCacheBlockedSensors,
+            #[serde(rename = "RequestedBackgroundWorkPermission")]
+            RequestedBackgroundWorkPermission,
+            #[serde(rename = "BroadcastChannel")]
+            BroadcastChannel,
+            #[serde(rename = "WebXR")]
+            WebXr,
+            #[serde(rename = "SharedWorker")]
+            SharedWorker,
+            #[serde(rename = "SharedWorkerMessage")]
+            SharedWorkerMessage,
+            #[serde(rename = "SharedWorkerWithNoActiveClient")]
+            SharedWorkerWithNoActiveClient,
+            #[serde(rename = "WebLocks")]
+            WebLocks,
+            #[serde(rename = "WebHID")]
+            WebHid,
+            #[serde(rename = "WebBluetooth")]
+            WebBluetooth,
+            #[serde(rename = "WebShare")]
+            WebShare,
+            #[serde(rename = "RequestedStorageAccessGrant")]
+            RequestedStorageAccessGrant,
+            #[serde(rename = "WebNfc")]
+            WebNfc,
+            #[serde(rename = "OutstandingNetworkRequestFetch")]
+            OutstandingNetworkRequestFetch,
+            #[serde(rename = "OutstandingNetworkRequestXHR")]
+            OutstandingNetworkRequestXhr,
+            #[serde(rename = "AppBanner")]
+            AppBanner,
+            #[serde(rename = "Printing")]
+            Printing,
+            #[serde(rename = "WebDatabase")]
+            WebDatabase,
+            #[serde(rename = "PictureInPicture")]
+            PictureInPicture,
+            #[serde(rename = "SpeechRecognizer")]
+            SpeechRecognizer,
+            #[serde(rename = "IdleManager")]
+            IdleManager,
+            #[serde(rename = "PaymentManager")]
+            PaymentManager,
+            #[serde(rename = "SpeechSynthesis")]
+            SpeechSynthesis,
+            #[serde(rename = "KeyboardLock")]
+            KeyboardLock,
+            #[serde(rename = "WebOTPService")]
+            WebOtpService,
+            #[serde(rename = "OutstandingNetworkRequestDirectSocket")]
+            OutstandingNetworkRequestDirectSocket,
+            #[serde(rename = "InjectedJavascript")]
+            InjectedJavascript,
+            #[serde(rename = "InjectedStyleSheet")]
+            InjectedStyleSheet,
+            #[serde(rename = "KeepaliveRequest")]
+            KeepaliveRequest,
+            #[serde(rename = "IndexedDBEvent")]
+            IndexedDbEvent,
+            #[serde(rename = "Dummy")]
+            Dummy,
+            #[serde(rename = "JsNetworkRequestReceivedCacheControlNoStoreResource")]
+            JsNetworkRequestReceivedCacheControlNoStoreResource,
+            #[serde(rename = "WebRTCUsedWithCCNS")]
+            WebRtcUsedWithCcns,
+            #[serde(rename = "WebTransportUsedWithCCNS")]
+            WebTransportUsedWithCcns,
+            #[serde(rename = "WebSocketUsedWithCCNS")]
+            WebSocketUsedWithCcns,
+            #[serde(rename = "SmartCard")]
+            SmartCard,
+            #[serde(rename = "LiveMediaStreamTrack")]
+            LiveMediaStreamTrack,
+            #[serde(rename = "UnloadHandler")]
+            UnloadHandler,
+            #[serde(rename = "ParserAborted")]
+            ParserAborted,
+            #[doc = "Disabled for RenderFrameHost reasons\nSee content/browser/renderer_host/back_forward_cache_disable.h for explanations."]
+            #[serde(rename = "ContentSecurityHandler")]
+            ContentSecurityHandler,
+            #[serde(rename = "ContentWebAuthenticationAPI")]
+            ContentWebAuthenticationApi,
+            #[serde(rename = "ContentFileChooser")]
+            ContentFileChooser,
+            #[serde(rename = "ContentSerial")]
+            ContentSerial,
+            #[serde(rename = "ContentFileSystemAccess")]
+            ContentFileSystemAccess,
+            #[serde(rename = "ContentMediaDevicesDispatcherHost")]
+            ContentMediaDevicesDispatcherHost,
+            #[serde(rename = "ContentWebBluetooth")]
+            ContentWebBluetooth,
+            #[serde(rename = "ContentWebUSB")]
+            ContentWebUsb,
+            #[serde(rename = "ContentMediaSessionService")]
+            ContentMediaSessionService,
+            #[serde(rename = "ContentScreenReader")]
+            ContentScreenReader,
+            #[serde(rename = "ContentDiscarded")]
+            ContentDiscarded,
+            #[doc = "See components/back_forward_cache/back_forward_cache_disable.h for explanations."]
+            #[serde(rename = "EmbedderPopupBlockerTabHelper")]
+            EmbedderPopupBlockerTabHelper,
+            #[serde(rename = "EmbedderSafeBrowsingTriggeredPopupBlocker")]
+            EmbedderSafeBrowsingTriggeredPopupBlocker,
+            #[serde(rename = "EmbedderSafeBrowsingThreatDetails")]
+            EmbedderSafeBrowsingThreatDetails,
+            #[serde(rename = "EmbedderAppBannerManager")]
+            EmbedderAppBannerManager,
+            #[serde(rename = "EmbedderDomDistillerViewerSource")]
+            EmbedderDomDistillerViewerSource,
+            #[serde(rename = "EmbedderDomDistillerSelfDeletingRequestDelegate")]
+            EmbedderDomDistillerSelfDeletingRequestDelegate,
+            #[serde(rename = "EmbedderOomInterventionTabHelper")]
+            EmbedderOomInterventionTabHelper,
+            #[serde(rename = "EmbedderOfflinePage")]
+            EmbedderOfflinePage,
+            #[serde(rename = "EmbedderChromePasswordManagerClientBindCredentialManager")]
+            EmbedderChromePasswordManagerClientBindCredentialManager,
+            #[serde(rename = "EmbedderPermissionRequestManager")]
+            EmbedderPermissionRequestManager,
+            #[serde(rename = "EmbedderModalDialog")]
+            EmbedderModalDialog,
+            #[serde(rename = "EmbedderExtensions")]
+            EmbedderExtensions,
+            #[serde(rename = "EmbedderExtensionMessaging")]
+            EmbedderExtensionMessaging,
+            #[serde(rename = "EmbedderExtensionMessagingForOpenPort")]
+            EmbedderExtensionMessagingForOpenPort,
+            #[serde(rename = "EmbedderExtensionSentMessageToCachedFrame")]
+            EmbedderExtensionSentMessageToCachedFrame,
+            #[serde(rename = "RequestedByWebViewClient")]
+            RequestedByWebViewClient,
+            #[serde(rename = "PostMessageByWebViewClient")]
+            PostMessageByWebViewClient,
+            #[serde(rename = "CacheControlNoStoreDeviceBoundSessionTerminated")]
+            CacheControlNoStoreDeviceBoundSessionTerminated,
+            #[serde(rename = "CacheLimitPrunedOnModerateMemoryPressure")]
+            CacheLimitPrunedOnModerateMemoryPressure,
+            #[serde(rename = "CacheLimitPrunedOnCriticalMemoryPressure")]
+            CacheLimitPrunedOnCriticalMemoryPressure,
+        }
+        impl AsRef<str> for BackForwardCacheNotRestoredReason {
+            fn as_ref(&self) -> &str {
+                match self { BackForwardCacheNotRestoredReason :: NotPrimaryMainFrame => "NotPrimaryMainFrame" , BackForwardCacheNotRestoredReason :: BackForwardCacheDisabled => "BackForwardCacheDisabled" , BackForwardCacheNotRestoredReason :: RelatedActiveContentsExist => "RelatedActiveContentsExist" , BackForwardCacheNotRestoredReason :: HttpStatusNotOk => "HTTPStatusNotOK" , BackForwardCacheNotRestoredReason :: SchemeNotHttpOrHttps => "SchemeNotHTTPOrHTTPS" , BackForwardCacheNotRestoredReason :: Loading => "Loading" , BackForwardCacheNotRestoredReason :: WasGrantedMediaAccess => "WasGrantedMediaAccess" , BackForwardCacheNotRestoredReason :: DisableForRenderFrameHostCalled => "DisableForRenderFrameHostCalled" , BackForwardCacheNotRestoredReason :: DomainNotAllowed => "DomainNotAllowed" , BackForwardCacheNotRestoredReason :: HttpMethodNotGet => "HTTPMethodNotGET" , BackForwardCacheNotRestoredReason :: SubframeIsNavigating => "SubframeIsNavigating" , BackForwardCacheNotRestoredReason :: Timeout => "Timeout" , BackForwardCacheNotRestoredReason :: CacheLimit => "CacheLimit" , BackForwardCacheNotRestoredReason :: JavaScriptExecution => "JavaScriptExecution" , BackForwardCacheNotRestoredReason :: RendererProcessKilled => "RendererProcessKilled" , BackForwardCacheNotRestoredReason :: RendererProcessCrashed => "RendererProcessCrashed" , BackForwardCacheNotRestoredReason :: SchedulerTrackedFeatureUsed => "SchedulerTrackedFeatureUsed" , BackForwardCacheNotRestoredReason :: ConflictingBrowsingInstance => "ConflictingBrowsingInstance" , BackForwardCacheNotRestoredReason :: CacheFlushed => "CacheFlushed" , BackForwardCacheNotRestoredReason :: ServiceWorkerVersionActivation => "ServiceWorkerVersionActivation" , BackForwardCacheNotRestoredReason :: SessionRestored => "SessionRestored" , BackForwardCacheNotRestoredReason :: ServiceWorkerPostMessage => "ServiceWorkerPostMessage" , BackForwardCacheNotRestoredReason :: EnteredBackForwardCacheBeforeServiceWorkerHostAdded => "EnteredBackForwardCacheBeforeServiceWorkerHostAdded" , BackForwardCacheNotRestoredReason :: RenderFrameHostReusedSameSite => "RenderFrameHostReused_SameSite" , BackForwardCacheNotRestoredReason :: RenderFrameHostReusedCrossSite => "RenderFrameHostReused_CrossSite" , BackForwardCacheNotRestoredReason :: ServiceWorkerClaim => "ServiceWorkerClaim" , BackForwardCacheNotRestoredReason :: IgnoreEventAndEvict => "IgnoreEventAndEvict" , BackForwardCacheNotRestoredReason :: HaveInnerContents => "HaveInnerContents" , BackForwardCacheNotRestoredReason :: TimeoutPuttingInCache => "TimeoutPuttingInCache" , BackForwardCacheNotRestoredReason :: BackForwardCacheDisabledByLowMemory => "BackForwardCacheDisabledByLowMemory" , BackForwardCacheNotRestoredReason :: BackForwardCacheDisabledByCommandLine => "BackForwardCacheDisabledByCommandLine" , BackForwardCacheNotRestoredReason :: NetworkRequestDatapipeDrainedAsBytesConsumer => "NetworkRequestDatapipeDrainedAsBytesConsumer" , BackForwardCacheNotRestoredReason :: NetworkRequestRedirected => "NetworkRequestRedirected" , BackForwardCacheNotRestoredReason :: NetworkRequestTimeout => "NetworkRequestTimeout" , BackForwardCacheNotRestoredReason :: NetworkExceedsBufferLimit => "NetworkExceedsBufferLimit" , BackForwardCacheNotRestoredReason :: NavigationCancelledWhileRestoring => "NavigationCancelledWhileRestoring" , BackForwardCacheNotRestoredReason :: NotMostRecentNavigationEntry => "NotMostRecentNavigationEntry" , BackForwardCacheNotRestoredReason :: BackForwardCacheDisabledForPrerender => "BackForwardCacheDisabledForPrerender" , BackForwardCacheNotRestoredReason :: UserAgentOverrideDiffers => "UserAgentOverrideDiffers" , BackForwardCacheNotRestoredReason :: ForegroundCacheLimit => "ForegroundCacheLimit" , BackForwardCacheNotRestoredReason :: BrowsingInstanceNotSwapped => "BrowsingInstanceNotSwapped" , BackForwardCacheNotRestoredReason :: BackForwardCacheDisabledForDelegate => "BackForwardCacheDisabledForDelegate" , BackForwardCacheNotRestoredReason :: UnloadHandlerExistsInMainFrame => "UnloadHandlerExistsInMainFrame" , BackForwardCacheNotRestoredReason :: UnloadHandlerExistsInSubFrame => "UnloadHandlerExistsInSubFrame" , BackForwardCacheNotRestoredReason :: ServiceWorkerUnregistration => "ServiceWorkerUnregistration" , BackForwardCacheNotRestoredReason :: CacheControlNoStore => "CacheControlNoStore" , BackForwardCacheNotRestoredReason :: CacheControlNoStoreCookieModified => "CacheControlNoStoreCookieModified" , BackForwardCacheNotRestoredReason :: CacheControlNoStoreHttpOnlyCookieModified => "CacheControlNoStoreHTTPOnlyCookieModified" , BackForwardCacheNotRestoredReason :: NoResponseHead => "NoResponseHead" , BackForwardCacheNotRestoredReason :: Unknown => "Unknown" , BackForwardCacheNotRestoredReason :: ActivationNavigationsDisallowedForBug1234857 => "ActivationNavigationsDisallowedForBug1234857" , BackForwardCacheNotRestoredReason :: ErrorDocument => "ErrorDocument" , BackForwardCacheNotRestoredReason :: FencedFramesEmbedder => "FencedFramesEmbedder" , BackForwardCacheNotRestoredReason :: CookieDisabled => "CookieDisabled" , BackForwardCacheNotRestoredReason :: HttpAuthRequired => "HTTPAuthRequired" , BackForwardCacheNotRestoredReason :: CookieFlushed => "CookieFlushed" , BackForwardCacheNotRestoredReason :: BroadcastChannelOnMessage => "BroadcastChannelOnMessage" , BackForwardCacheNotRestoredReason :: WebViewSettingsChanged => "WebViewSettingsChanged" , BackForwardCacheNotRestoredReason :: WebViewJavaScriptObjectChanged => "WebViewJavaScriptObjectChanged" , BackForwardCacheNotRestoredReason :: WebViewMessageListenerInjected => "WebViewMessageListenerInjected" , BackForwardCacheNotRestoredReason :: WebViewSafeBrowsingAllowlistChanged => "WebViewSafeBrowsingAllowlistChanged" , BackForwardCacheNotRestoredReason :: WebViewDocumentStartJavascriptChanged => "WebViewDocumentStartJavascriptChanged" , BackForwardCacheNotRestoredReason :: WebSocket => "WebSocket" , BackForwardCacheNotRestoredReason :: WebTransport => "WebTransport" , BackForwardCacheNotRestoredReason :: WebRtc => "WebRTC" , BackForwardCacheNotRestoredReason :: MainResourceHasCacheControlNoStore => "MainResourceHasCacheControlNoStore" , BackForwardCacheNotRestoredReason :: MainResourceHasCacheControlNoCache => "MainResourceHasCacheControlNoCache" , BackForwardCacheNotRestoredReason :: SubresourceHasCacheControlNoStore => "SubresourceHasCacheControlNoStore" , BackForwardCacheNotRestoredReason :: SubresourceHasCacheControlNoCache => "SubresourceHasCacheControlNoCache" , BackForwardCacheNotRestoredReason :: ContainsPlugins => "ContainsPlugins" , BackForwardCacheNotRestoredReason :: DocumentLoaded => "DocumentLoaded" , BackForwardCacheNotRestoredReason :: OutstandingNetworkRequestOthers => "OutstandingNetworkRequestOthers" , BackForwardCacheNotRestoredReason :: RequestedMidiPermission => "RequestedMIDIPermission" , BackForwardCacheNotRestoredReason :: RequestedAudioCapturePermission => "RequestedAudioCapturePermission" , BackForwardCacheNotRestoredReason :: RequestedVideoCapturePermission => "RequestedVideoCapturePermission" , BackForwardCacheNotRestoredReason :: RequestedBackForwardCacheBlockedSensors => "RequestedBackForwardCacheBlockedSensors" , BackForwardCacheNotRestoredReason :: RequestedBackgroundWorkPermission => "RequestedBackgroundWorkPermission" , BackForwardCacheNotRestoredReason :: BroadcastChannel => "BroadcastChannel" , BackForwardCacheNotRestoredReason :: WebXr => "WebXR" , BackForwardCacheNotRestoredReason :: SharedWorker => "SharedWorker" , BackForwardCacheNotRestoredReason :: SharedWorkerMessage => "SharedWorkerMessage" , BackForwardCacheNotRestoredReason :: SharedWorkerWithNoActiveClient => "SharedWorkerWithNoActiveClient" , BackForwardCacheNotRestoredReason :: WebLocks => "WebLocks" , BackForwardCacheNotRestoredReason :: WebHid => "WebHID" , BackForwardCacheNotRestoredReason :: WebBluetooth => "WebBluetooth" , BackForwardCacheNotRestoredReason :: WebShare => "WebShare" , BackForwardCacheNotRestoredReason :: RequestedStorageAccessGrant => "RequestedStorageAccessGrant" , BackForwardCacheNotRestoredReason :: WebNfc => "WebNfc" , BackForwardCacheNotRestoredReason :: OutstandingNetworkRequestFetch => "OutstandingNetworkRequestFetch" , BackForwardCacheNotRestoredReason :: OutstandingNetworkRequestXhr => "OutstandingNetworkRequestXHR" , BackForwardCacheNotRestoredReason :: AppBanner => "AppBanner" , BackForwardCacheNotRestoredReason :: Printing => "Printing" , BackForwardCacheNotRestoredReason :: WebDatabase => "WebDatabase" , BackForwardCacheNotRestoredReason :: PictureInPicture => "PictureInPicture" , BackForwardCacheNotRestoredReason :: SpeechRecognizer => "SpeechRecognizer" , BackForwardCacheNotRestoredReason :: IdleManager => "IdleManager" , BackForwardCacheNotRestoredReason :: PaymentManager => "PaymentManager" , BackForwardCacheNotRestoredReason :: SpeechSynthesis => "SpeechSynthesis" , BackForwardCacheNotRestoredReason :: KeyboardLock => "KeyboardLock" , BackForwardCacheNotRestoredReason :: WebOtpService => "WebOTPService" , BackForwardCacheNotRestoredReason :: OutstandingNetworkRequestDirectSocket => "OutstandingNetworkRequestDirectSocket" , BackForwardCacheNotRestoredReason :: InjectedJavascript => "InjectedJavascript" , BackForwardCacheNotRestoredReason :: InjectedStyleSheet => "InjectedStyleSheet" , BackForwardCacheNotRestoredReason :: KeepaliveRequest => "KeepaliveRequest" , BackForwardCacheNotRestoredReason :: IndexedDbEvent => "IndexedDBEvent" , BackForwardCacheNotRestoredReason :: Dummy => "Dummy" , BackForwardCacheNotRestoredReason :: JsNetworkRequestReceivedCacheControlNoStoreResource => "JsNetworkRequestReceivedCacheControlNoStoreResource" , BackForwardCacheNotRestoredReason :: WebRtcUsedWithCcns => "WebRTCUsedWithCCNS" , BackForwardCacheNotRestoredReason :: WebTransportUsedWithCcns => "WebTransportUsedWithCCNS" , BackForwardCacheNotRestoredReason :: WebSocketUsedWithCcns => "WebSocketUsedWithCCNS" , BackForwardCacheNotRestoredReason :: SmartCard => "SmartCard" , BackForwardCacheNotRestoredReason :: LiveMediaStreamTrack => "LiveMediaStreamTrack" , BackForwardCacheNotRestoredReason :: UnloadHandler => "UnloadHandler" , BackForwardCacheNotRestoredReason :: ParserAborted => "ParserAborted" , BackForwardCacheNotRestoredReason :: ContentSecurityHandler => "ContentSecurityHandler" , BackForwardCacheNotRestoredReason :: ContentWebAuthenticationApi => "ContentWebAuthenticationAPI" , BackForwardCacheNotRestoredReason :: ContentFileChooser => "ContentFileChooser" , BackForwardCacheNotRestoredReason :: ContentSerial => "ContentSerial" , BackForwardCacheNotRestoredReason :: ContentFileSystemAccess => "ContentFileSystemAccess" , BackForwardCacheNotRestoredReason :: ContentMediaDevicesDispatcherHost => "ContentMediaDevicesDispatcherHost" , BackForwardCacheNotRestoredReason :: ContentWebBluetooth => "ContentWebBluetooth" , BackForwardCacheNotRestoredReason :: ContentWebUsb => "ContentWebUSB" , BackForwardCacheNotRestoredReason :: ContentMediaSessionService => "ContentMediaSessionService" , BackForwardCacheNotRestoredReason :: ContentScreenReader => "ContentScreenReader" , BackForwardCacheNotRestoredReason :: ContentDiscarded => "ContentDiscarded" , BackForwardCacheNotRestoredReason :: EmbedderPopupBlockerTabHelper => "EmbedderPopupBlockerTabHelper" , BackForwardCacheNotRestoredReason :: EmbedderSafeBrowsingTriggeredPopupBlocker => "EmbedderSafeBrowsingTriggeredPopupBlocker" , BackForwardCacheNotRestoredReason :: EmbedderSafeBrowsingThreatDetails => "EmbedderSafeBrowsingThreatDetails" , BackForwardCacheNotRestoredReason :: EmbedderAppBannerManager => "EmbedderAppBannerManager" , BackForwardCacheNotRestoredReason :: EmbedderDomDistillerViewerSource => "EmbedderDomDistillerViewerSource" , BackForwardCacheNotRestoredReason :: EmbedderDomDistillerSelfDeletingRequestDelegate => "EmbedderDomDistillerSelfDeletingRequestDelegate" , BackForwardCacheNotRestoredReason :: EmbedderOomInterventionTabHelper => "EmbedderOomInterventionTabHelper" , BackForwardCacheNotRestoredReason :: EmbedderOfflinePage => "EmbedderOfflinePage" , BackForwardCacheNotRestoredReason :: EmbedderChromePasswordManagerClientBindCredentialManager => "EmbedderChromePasswordManagerClientBindCredentialManager" , BackForwardCacheNotRestoredReason :: EmbedderPermissionRequestManager => "EmbedderPermissionRequestManager" , BackForwardCacheNotRestoredReason :: EmbedderModalDialog => "EmbedderModalDialog" , BackForwardCacheNotRestoredReason :: EmbedderExtensions => "EmbedderExtensions" , BackForwardCacheNotRestoredReason :: EmbedderExtensionMessaging => "EmbedderExtensionMessaging" , BackForwardCacheNotRestoredReason :: EmbedderExtensionMessagingForOpenPort => "EmbedderExtensionMessagingForOpenPort" , BackForwardCacheNotRestoredReason :: EmbedderExtensionSentMessageToCachedFrame => "EmbedderExtensionSentMessageToCachedFrame" , BackForwardCacheNotRestoredReason :: RequestedByWebViewClient => "RequestedByWebViewClient" , BackForwardCacheNotRestoredReason :: PostMessageByWebViewClient => "PostMessageByWebViewClient" , BackForwardCacheNotRestoredReason :: CacheControlNoStoreDeviceBoundSessionTerminated => "CacheControlNoStoreDeviceBoundSessionTerminated" , BackForwardCacheNotRestoredReason :: CacheLimitPrunedOnModerateMemoryPressure => "CacheLimitPrunedOnModerateMemoryPressure" , BackForwardCacheNotRestoredReason :: CacheLimitPrunedOnCriticalMemoryPressure => "CacheLimitPrunedOnCriticalMemoryPressure" }
+            }
+        }
+        impl ::std::str::FromStr for BackForwardCacheNotRestoredReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s { "NotPrimaryMainFrame" | "notprimarymainframe" => Ok (BackForwardCacheNotRestoredReason :: NotPrimaryMainFrame) , "BackForwardCacheDisabled" | "backforwardcachedisabled" => Ok (BackForwardCacheNotRestoredReason :: BackForwardCacheDisabled) , "RelatedActiveContentsExist" | "relatedactivecontentsexist" => Ok (BackForwardCacheNotRestoredReason :: RelatedActiveContentsExist) , "HTTPStatusNotOK" | "HttpStatusNotOk" | "httpstatusnotok" => Ok (BackForwardCacheNotRestoredReason :: HttpStatusNotOk) , "SchemeNotHTTPOrHTTPS" | "SchemeNotHttpOrHttps" | "schemenothttporhttps" => Ok (BackForwardCacheNotRestoredReason :: SchemeNotHttpOrHttps) , "Loading" | "loading" => Ok (BackForwardCacheNotRestoredReason :: Loading) , "WasGrantedMediaAccess" | "wasgrantedmediaaccess" => Ok (BackForwardCacheNotRestoredReason :: WasGrantedMediaAccess) , "DisableForRenderFrameHostCalled" | "disableforrenderframehostcalled" => Ok (BackForwardCacheNotRestoredReason :: DisableForRenderFrameHostCalled) , "DomainNotAllowed" | "domainnotallowed" => Ok (BackForwardCacheNotRestoredReason :: DomainNotAllowed) , "HTTPMethodNotGET" | "HttpMethodNotGet" | "httpmethodnotget" => Ok (BackForwardCacheNotRestoredReason :: HttpMethodNotGet) , "SubframeIsNavigating" | "subframeisnavigating" => Ok (BackForwardCacheNotRestoredReason :: SubframeIsNavigating) , "Timeout" | "timeout" => Ok (BackForwardCacheNotRestoredReason :: Timeout) , "CacheLimit" | "cachelimit" => Ok (BackForwardCacheNotRestoredReason :: CacheLimit) , "JavaScriptExecution" | "javascriptexecution" => Ok (BackForwardCacheNotRestoredReason :: JavaScriptExecution) , "RendererProcessKilled" | "rendererprocesskilled" => Ok (BackForwardCacheNotRestoredReason :: RendererProcessKilled) , "RendererProcessCrashed" | "rendererprocesscrashed" => Ok (BackForwardCacheNotRestoredReason :: RendererProcessCrashed) , "SchedulerTrackedFeatureUsed" | "schedulertrackedfeatureused" => Ok (BackForwardCacheNotRestoredReason :: SchedulerTrackedFeatureUsed) , "ConflictingBrowsingInstance" | "conflictingbrowsinginstance" => Ok (BackForwardCacheNotRestoredReason :: ConflictingBrowsingInstance) , "CacheFlushed" | "cacheflushed" => Ok (BackForwardCacheNotRestoredReason :: CacheFlushed) , "ServiceWorkerVersionActivation" | "serviceworkerversionactivation" => Ok (BackForwardCacheNotRestoredReason :: ServiceWorkerVersionActivation) , "SessionRestored" | "sessionrestored" => Ok (BackForwardCacheNotRestoredReason :: SessionRestored) , "ServiceWorkerPostMessage" | "serviceworkerpostmessage" => Ok (BackForwardCacheNotRestoredReason :: ServiceWorkerPostMessage) , "EnteredBackForwardCacheBeforeServiceWorkerHostAdded" | "enteredbackforwardcachebeforeserviceworkerhostadded" => Ok (BackForwardCacheNotRestoredReason :: EnteredBackForwardCacheBeforeServiceWorkerHostAdded) , "RenderFrameHostReused_SameSite" | "RenderFrameHostReusedSameSite" | "renderframehostreused_samesite" => Ok (BackForwardCacheNotRestoredReason :: RenderFrameHostReusedSameSite) , "RenderFrameHostReused_CrossSite" | "RenderFrameHostReusedCrossSite" | "renderframehostreused_crosssite" => Ok (BackForwardCacheNotRestoredReason :: RenderFrameHostReusedCrossSite) , "ServiceWorkerClaim" | "serviceworkerclaim" => Ok (BackForwardCacheNotRestoredReason :: ServiceWorkerClaim) , "IgnoreEventAndEvict" | "ignoreeventandevict" => Ok (BackForwardCacheNotRestoredReason :: IgnoreEventAndEvict) , "HaveInnerContents" | "haveinnercontents" => Ok (BackForwardCacheNotRestoredReason :: HaveInnerContents) , "TimeoutPuttingInCache" | "timeoutputtingincache" => Ok (BackForwardCacheNotRestoredReason :: TimeoutPuttingInCache) , "BackForwardCacheDisabledByLowMemory" | "backforwardcachedisabledbylowmemory" => Ok (BackForwardCacheNotRestoredReason :: BackForwardCacheDisabledByLowMemory) , "BackForwardCacheDisabledByCommandLine" | "backforwardcachedisabledbycommandline" => Ok (BackForwardCacheNotRestoredReason :: BackForwardCacheDisabledByCommandLine) , "NetworkRequestDatapipeDrainedAsBytesConsumer" | "networkrequestdatapipedrainedasbytesconsumer" => Ok (BackForwardCacheNotRestoredReason :: NetworkRequestDatapipeDrainedAsBytesConsumer) , "NetworkRequestRedirected" | "networkrequestredirected" => Ok (BackForwardCacheNotRestoredReason :: NetworkRequestRedirected) , "NetworkRequestTimeout" | "networkrequesttimeout" => Ok (BackForwardCacheNotRestoredReason :: NetworkRequestTimeout) , "NetworkExceedsBufferLimit" | "networkexceedsbufferlimit" => Ok (BackForwardCacheNotRestoredReason :: NetworkExceedsBufferLimit) , "NavigationCancelledWhileRestoring" | "navigationcancelledwhilerestoring" => Ok (BackForwardCacheNotRestoredReason :: NavigationCancelledWhileRestoring) , "NotMostRecentNavigationEntry" | "notmostrecentnavigationentry" => Ok (BackForwardCacheNotRestoredReason :: NotMostRecentNavigationEntry) , "BackForwardCacheDisabledForPrerender" | "backforwardcachedisabledforprerender" => Ok (BackForwardCacheNotRestoredReason :: BackForwardCacheDisabledForPrerender) , "UserAgentOverrideDiffers" | "useragentoverridediffers" => Ok (BackForwardCacheNotRestoredReason :: UserAgentOverrideDiffers) , "ForegroundCacheLimit" | "foregroundcachelimit" => Ok (BackForwardCacheNotRestoredReason :: ForegroundCacheLimit) , "BrowsingInstanceNotSwapped" | "browsinginstancenotswapped" => Ok (BackForwardCacheNotRestoredReason :: BrowsingInstanceNotSwapped) , "BackForwardCacheDisabledForDelegate" | "backforwardcachedisabledfordelegate" => Ok (BackForwardCacheNotRestoredReason :: BackForwardCacheDisabledForDelegate) , "UnloadHandlerExistsInMainFrame" | "unloadhandlerexistsinmainframe" => Ok (BackForwardCacheNotRestoredReason :: UnloadHandlerExistsInMainFrame) , "UnloadHandlerExistsInSubFrame" | "unloadhandlerexistsinsubframe" => Ok (BackForwardCacheNotRestoredReason :: UnloadHandlerExistsInSubFrame) , "ServiceWorkerUnregistration" | "serviceworkerunregistration" => Ok (BackForwardCacheNotRestoredReason :: ServiceWorkerUnregistration) , "CacheControlNoStore" | "cachecontrolnostore" => Ok (BackForwardCacheNotRestoredReason :: CacheControlNoStore) , "CacheControlNoStoreCookieModified" | "cachecontrolnostorecookiemodified" => Ok (BackForwardCacheNotRestoredReason :: CacheControlNoStoreCookieModified) , "CacheControlNoStoreHTTPOnlyCookieModified" | "CacheControlNoStoreHttpOnlyCookieModified" | "cachecontrolnostorehttponlycookiemodified" => Ok (BackForwardCacheNotRestoredReason :: CacheControlNoStoreHttpOnlyCookieModified) , "NoResponseHead" | "noresponsehead" => Ok (BackForwardCacheNotRestoredReason :: NoResponseHead) , "Unknown" | "unknown" => Ok (BackForwardCacheNotRestoredReason :: Unknown) , "ActivationNavigationsDisallowedForBug1234857" | "activationnavigationsdisallowedforbug1234857" => Ok (BackForwardCacheNotRestoredReason :: ActivationNavigationsDisallowedForBug1234857) , "ErrorDocument" | "errordocument" => Ok (BackForwardCacheNotRestoredReason :: ErrorDocument) , "FencedFramesEmbedder" | "fencedframesembedder" => Ok (BackForwardCacheNotRestoredReason :: FencedFramesEmbedder) , "CookieDisabled" | "cookiedisabled" => Ok (BackForwardCacheNotRestoredReason :: CookieDisabled) , "HTTPAuthRequired" | "HttpAuthRequired" | "httpauthrequired" => Ok (BackForwardCacheNotRestoredReason :: HttpAuthRequired) , "CookieFlushed" | "cookieflushed" => Ok (BackForwardCacheNotRestoredReason :: CookieFlushed) , "BroadcastChannelOnMessage" | "broadcastchannelonmessage" => Ok (BackForwardCacheNotRestoredReason :: BroadcastChannelOnMessage) , "WebViewSettingsChanged" | "webviewsettingschanged" => Ok (BackForwardCacheNotRestoredReason :: WebViewSettingsChanged) , "WebViewJavaScriptObjectChanged" | "webviewjavascriptobjectchanged" => Ok (BackForwardCacheNotRestoredReason :: WebViewJavaScriptObjectChanged) , "WebViewMessageListenerInjected" | "webviewmessagelistenerinjected" => Ok (BackForwardCacheNotRestoredReason :: WebViewMessageListenerInjected) , "WebViewSafeBrowsingAllowlistChanged" | "webviewsafebrowsingallowlistchanged" => Ok (BackForwardCacheNotRestoredReason :: WebViewSafeBrowsingAllowlistChanged) , "WebViewDocumentStartJavascriptChanged" | "webviewdocumentstartjavascriptchanged" => Ok (BackForwardCacheNotRestoredReason :: WebViewDocumentStartJavascriptChanged) , "WebSocket" | "websocket" => Ok (BackForwardCacheNotRestoredReason :: WebSocket) , "WebTransport" | "webtransport" => Ok (BackForwardCacheNotRestoredReason :: WebTransport) , "WebRTC" | "WebRtc" | "webrtc" => Ok (BackForwardCacheNotRestoredReason :: WebRtc) , "MainResourceHasCacheControlNoStore" | "mainresourcehascachecontrolnostore" => Ok (BackForwardCacheNotRestoredReason :: MainResourceHasCacheControlNoStore) , "MainResourceHasCacheControlNoCache" | "mainresourcehascachecontrolnocache" => Ok (BackForwardCacheNotRestoredReason :: MainResourceHasCacheControlNoCache) , "SubresourceHasCacheControlNoStore" | "subresourcehascachecontrolnostore" => Ok (BackForwardCacheNotRestoredReason :: SubresourceHasCacheControlNoStore) , "SubresourceHasCacheControlNoCache" | "subresourcehascachecontrolnocache" => Ok (BackForwardCacheNotRestoredReason :: SubresourceHasCacheControlNoCache) , "ContainsPlugins" | "containsplugins" => Ok (BackForwardCacheNotRestoredReason :: ContainsPlugins) , "DocumentLoaded" | "documentloaded" => Ok (BackForwardCacheNotRestoredReason :: DocumentLoaded) , "OutstandingNetworkRequestOthers" | "outstandingnetworkrequestothers" => Ok (BackForwardCacheNotRestoredReason :: OutstandingNetworkRequestOthers) , "RequestedMIDIPermission" | "RequestedMidiPermission" | "requestedmidipermission" => Ok (BackForwardCacheNotRestoredReason :: RequestedMidiPermission) , "RequestedAudioCapturePermission" | "requestedaudiocapturepermission" => Ok (BackForwardCacheNotRestoredReason :: RequestedAudioCapturePermission) , "RequestedVideoCapturePermission" | "requestedvideocapturepermission" => Ok (BackForwardCacheNotRestoredReason :: RequestedVideoCapturePermission) , "RequestedBackForwardCacheBlockedSensors" | "requestedbackforwardcacheblockedsensors" => Ok (BackForwardCacheNotRestoredReason :: RequestedBackForwardCacheBlockedSensors) , "RequestedBackgroundWorkPermission" | "requestedbackgroundworkpermission" => Ok (BackForwardCacheNotRestoredReason :: RequestedBackgroundWorkPermission) , "BroadcastChannel" | "broadcastchannel" => Ok (BackForwardCacheNotRestoredReason :: BroadcastChannel) , "WebXR" | "WebXr" | "webxr" => Ok (BackForwardCacheNotRestoredReason :: WebXr) , "SharedWorker" | "sharedworker" => Ok (BackForwardCacheNotRestoredReason :: SharedWorker) , "SharedWorkerMessage" | "sharedworkermessage" => Ok (BackForwardCacheNotRestoredReason :: SharedWorkerMessage) , "SharedWorkerWithNoActiveClient" | "sharedworkerwithnoactiveclient" => Ok (BackForwardCacheNotRestoredReason :: SharedWorkerWithNoActiveClient) , "WebLocks" | "weblocks" => Ok (BackForwardCacheNotRestoredReason :: WebLocks) , "WebHID" | "WebHid" | "webhid" => Ok (BackForwardCacheNotRestoredReason :: WebHid) , "WebBluetooth" | "webbluetooth" => Ok (BackForwardCacheNotRestoredReason :: WebBluetooth) , "WebShare" | "webshare" => Ok (BackForwardCacheNotRestoredReason :: WebShare) , "RequestedStorageAccessGrant" | "requestedstorageaccessgrant" => Ok (BackForwardCacheNotRestoredReason :: RequestedStorageAccessGrant) , "WebNfc" | "webnfc" => Ok (BackForwardCacheNotRestoredReason :: WebNfc) , "OutstandingNetworkRequestFetch" | "outstandingnetworkrequestfetch" => Ok (BackForwardCacheNotRestoredReason :: OutstandingNetworkRequestFetch) , "OutstandingNetworkRequestXHR" | "OutstandingNetworkRequestXhr" | "outstandingnetworkrequestxhr" => Ok (BackForwardCacheNotRestoredReason :: OutstandingNetworkRequestXhr) , "AppBanner" | "appbanner" => Ok (BackForwardCacheNotRestoredReason :: AppBanner) , "Printing" | "printing" => Ok (BackForwardCacheNotRestoredReason :: Printing) , "WebDatabase" | "webdatabase" => Ok (BackForwardCacheNotRestoredReason :: WebDatabase) , "PictureInPicture" | "pictureinpicture" => Ok (BackForwardCacheNotRestoredReason :: PictureInPicture) , "SpeechRecognizer" | "speechrecognizer" => Ok (BackForwardCacheNotRestoredReason :: SpeechRecognizer) , "IdleManager" | "idlemanager" => Ok (BackForwardCacheNotRestoredReason :: IdleManager) , "PaymentManager" | "paymentmanager" => Ok (BackForwardCacheNotRestoredReason :: PaymentManager) , "SpeechSynthesis" | "speechsynthesis" => Ok (BackForwardCacheNotRestoredReason :: SpeechSynthesis) , "KeyboardLock" | "keyboardlock" => Ok (BackForwardCacheNotRestoredReason :: KeyboardLock) , "WebOTPService" | "WebOtpService" | "webotpservice" => Ok (BackForwardCacheNotRestoredReason :: WebOtpService) , "OutstandingNetworkRequestDirectSocket" | "outstandingnetworkrequestdirectsocket" => Ok (BackForwardCacheNotRestoredReason :: OutstandingNetworkRequestDirectSocket) , "InjectedJavascript" | "injectedjavascript" => Ok (BackForwardCacheNotRestoredReason :: InjectedJavascript) , "InjectedStyleSheet" | "injectedstylesheet" => Ok (BackForwardCacheNotRestoredReason :: InjectedStyleSheet) , "KeepaliveRequest" | "keepaliverequest" => Ok (BackForwardCacheNotRestoredReason :: KeepaliveRequest) , "IndexedDBEvent" | "IndexedDbEvent" | "indexeddbevent" => Ok (BackForwardCacheNotRestoredReason :: IndexedDbEvent) , "Dummy" | "dummy" => Ok (BackForwardCacheNotRestoredReason :: Dummy) , "JsNetworkRequestReceivedCacheControlNoStoreResource" | "jsnetworkrequestreceivedcachecontrolnostoreresource" => Ok (BackForwardCacheNotRestoredReason :: JsNetworkRequestReceivedCacheControlNoStoreResource) , "WebRTCUsedWithCCNS" | "WebRtcUsedWithCcns" | "webrtcusedwithccns" => Ok (BackForwardCacheNotRestoredReason :: WebRtcUsedWithCcns) , "WebTransportUsedWithCCNS" | "WebTransportUsedWithCcns" | "webtransportusedwithccns" => Ok (BackForwardCacheNotRestoredReason :: WebTransportUsedWithCcns) , "WebSocketUsedWithCCNS" | "WebSocketUsedWithCcns" | "websocketusedwithccns" => Ok (BackForwardCacheNotRestoredReason :: WebSocketUsedWithCcns) , "SmartCard" | "smartcard" => Ok (BackForwardCacheNotRestoredReason :: SmartCard) , "LiveMediaStreamTrack" | "livemediastreamtrack" => Ok (BackForwardCacheNotRestoredReason :: LiveMediaStreamTrack) , "UnloadHandler" | "unloadhandler" => Ok (BackForwardCacheNotRestoredReason :: UnloadHandler) , "ParserAborted" | "parseraborted" => Ok (BackForwardCacheNotRestoredReason :: ParserAborted) , "ContentSecurityHandler" | "contentsecurityhandler" => Ok (BackForwardCacheNotRestoredReason :: ContentSecurityHandler) , "ContentWebAuthenticationAPI" | "ContentWebAuthenticationApi" | "contentwebauthenticationapi" => Ok (BackForwardCacheNotRestoredReason :: ContentWebAuthenticationApi) , "ContentFileChooser" | "contentfilechooser" => Ok (BackForwardCacheNotRestoredReason :: ContentFileChooser) , "ContentSerial" | "contentserial" => Ok (BackForwardCacheNotRestoredReason :: ContentSerial) , "ContentFileSystemAccess" | "contentfilesystemaccess" => Ok (BackForwardCacheNotRestoredReason :: ContentFileSystemAccess) , "ContentMediaDevicesDispatcherHost" | "contentmediadevicesdispatcherhost" => Ok (BackForwardCacheNotRestoredReason :: ContentMediaDevicesDispatcherHost) , "ContentWebBluetooth" | "contentwebbluetooth" => Ok (BackForwardCacheNotRestoredReason :: ContentWebBluetooth) , "ContentWebUSB" | "ContentWebUsb" | "contentwebusb" => Ok (BackForwardCacheNotRestoredReason :: ContentWebUsb) , "ContentMediaSessionService" | "contentmediasessionservice" => Ok (BackForwardCacheNotRestoredReason :: ContentMediaSessionService) , "ContentScreenReader" | "contentscreenreader" => Ok (BackForwardCacheNotRestoredReason :: ContentScreenReader) , "ContentDiscarded" | "contentdiscarded" => Ok (BackForwardCacheNotRestoredReason :: ContentDiscarded) , "EmbedderPopupBlockerTabHelper" | "embedderpopupblockertabhelper" => Ok (BackForwardCacheNotRestoredReason :: EmbedderPopupBlockerTabHelper) , "EmbedderSafeBrowsingTriggeredPopupBlocker" | "embeddersafebrowsingtriggeredpopupblocker" => Ok (BackForwardCacheNotRestoredReason :: EmbedderSafeBrowsingTriggeredPopupBlocker) , "EmbedderSafeBrowsingThreatDetails" | "embeddersafebrowsingthreatdetails" => Ok (BackForwardCacheNotRestoredReason :: EmbedderSafeBrowsingThreatDetails) , "EmbedderAppBannerManager" | "embedderappbannermanager" => Ok (BackForwardCacheNotRestoredReason :: EmbedderAppBannerManager) , "EmbedderDomDistillerViewerSource" | "embedderdomdistillerviewersource" => Ok (BackForwardCacheNotRestoredReason :: EmbedderDomDistillerViewerSource) , "EmbedderDomDistillerSelfDeletingRequestDelegate" | "embedderdomdistillerselfdeletingrequestdelegate" => Ok (BackForwardCacheNotRestoredReason :: EmbedderDomDistillerSelfDeletingRequestDelegate) , "EmbedderOomInterventionTabHelper" | "embedderoominterventiontabhelper" => Ok (BackForwardCacheNotRestoredReason :: EmbedderOomInterventionTabHelper) , "EmbedderOfflinePage" | "embedderofflinepage" => Ok (BackForwardCacheNotRestoredReason :: EmbedderOfflinePage) , "EmbedderChromePasswordManagerClientBindCredentialManager" | "embedderchromepasswordmanagerclientbindcredentialmanager" => Ok (BackForwardCacheNotRestoredReason :: EmbedderChromePasswordManagerClientBindCredentialManager) , "EmbedderPermissionRequestManager" | "embedderpermissionrequestmanager" => Ok (BackForwardCacheNotRestoredReason :: EmbedderPermissionRequestManager) , "EmbedderModalDialog" | "embeddermodaldialog" => Ok (BackForwardCacheNotRestoredReason :: EmbedderModalDialog) , "EmbedderExtensions" | "embedderextensions" => Ok (BackForwardCacheNotRestoredReason :: EmbedderExtensions) , "EmbedderExtensionMessaging" | "embedderextensionmessaging" => Ok (BackForwardCacheNotRestoredReason :: EmbedderExtensionMessaging) , "EmbedderExtensionMessagingForOpenPort" | "embedderextensionmessagingforopenport" => Ok (BackForwardCacheNotRestoredReason :: EmbedderExtensionMessagingForOpenPort) , "EmbedderExtensionSentMessageToCachedFrame" | "embedderextensionsentmessagetocachedframe" => Ok (BackForwardCacheNotRestoredReason :: EmbedderExtensionSentMessageToCachedFrame) , "RequestedByWebViewClient" | "requestedbywebviewclient" => Ok (BackForwardCacheNotRestoredReason :: RequestedByWebViewClient) , "PostMessageByWebViewClient" | "postmessagebywebviewclient" => Ok (BackForwardCacheNotRestoredReason :: PostMessageByWebViewClient) , "CacheControlNoStoreDeviceBoundSessionTerminated" | "cachecontrolnostoredeviceboundsessionterminated" => Ok (BackForwardCacheNotRestoredReason :: CacheControlNoStoreDeviceBoundSessionTerminated) , "CacheLimitPrunedOnModerateMemoryPressure" | "cachelimitprunedonmoderatememorypressure" => Ok (BackForwardCacheNotRestoredReason :: CacheLimitPrunedOnModerateMemoryPressure) , "CacheLimitPrunedOnCriticalMemoryPressure" | "cachelimitprunedoncriticalmemorypressure" => Ok (BackForwardCacheNotRestoredReason :: CacheLimitPrunedOnCriticalMemoryPressure) , _ => Err (s . to_string ()) }
+            }
+        }
+        #[doc = "Types of not restored reasons for back-forward cache."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum BackForwardCacheNotRestoredReasonType {
+            #[serde(rename = "SupportPending")]
+            SupportPending,
+            #[serde(rename = "PageSupportNeeded")]
+            PageSupportNeeded,
+            #[serde(rename = "Circumstantial")]
+            Circumstantial,
+        }
+        impl AsRef<str> for BackForwardCacheNotRestoredReasonType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    BackForwardCacheNotRestoredReasonType::SupportPending => "SupportPending",
+                    BackForwardCacheNotRestoredReasonType::PageSupportNeeded => "PageSupportNeeded",
+                    BackForwardCacheNotRestoredReasonType::Circumstantial => "Circumstantial",
+                }
+            }
+        }
+        impl ::std::str::FromStr for BackForwardCacheNotRestoredReasonType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "SupportPending" | "supportpending" => {
+                        Ok(BackForwardCacheNotRestoredReasonType::SupportPending)
+                    }
+                    "PageSupportNeeded" | "pagesupportneeded" => {
+                        Ok(BackForwardCacheNotRestoredReasonType::PageSupportNeeded)
+                    }
+                    "Circumstantial" | "circumstantial" => {
+                        Ok(BackForwardCacheNotRestoredReasonType::Circumstantial)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BackForwardCacheBlockingDetails {
+            #[doc = "Url of the file where blockage happened. Optional because of tests."]
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[doc = "Function name where blockage happened. Optional because of anonymous functions and tests."]
+            #[serde(rename = "function")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub function: Option<String>,
+            #[doc = "Line number in the script (0-based)."]
+            #[serde(rename = "lineNumber")]
+            pub line_number: i64,
+            #[doc = "Column number in the script (0-based)."]
+            #[serde(rename = "columnNumber")]
+            pub column_number: i64,
+        }
+        impl BackForwardCacheBlockingDetails {
+            pub fn new(line_number: impl Into<i64>, column_number: impl Into<i64>) -> Self {
+                Self {
+                    line_number: line_number.into(),
+                    column_number: column_number.into(),
+                    url: None,
+                    function: None,
+                }
+            }
+        }
+        impl BackForwardCacheBlockingDetails {
+            pub fn builder() -> BackForwardCacheBlockingDetailsBuilder {
+                BackForwardCacheBlockingDetailsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BackForwardCacheBlockingDetailsBuilder {
+            url: Option<String>,
+            function: Option<String>,
+            line_number: Option<i64>,
+            column_number: Option<i64>,
+        }
+        impl BackForwardCacheBlockingDetailsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn function(mut self, function: impl Into<String>) -> Self {
+                self.function = Some(function.into());
+                self
+            }
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<i64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn build(self) -> Result<BackForwardCacheBlockingDetails, String> {
+                Ok(BackForwardCacheBlockingDetails {
+                    url: self.url,
+                    function: self.function,
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    column_number: self.column_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(column_number))
+                    })?,
+                })
+            }
+        }
+        impl BackForwardCacheBlockingDetails {
+            pub const IDENTIFIER: &'static str = "Page.BackForwardCacheBlockingDetails";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BackForwardCacheNotRestoredExplanation {
+            #[doc = "Type of the reason"]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: BackForwardCacheNotRestoredReasonType,
+            #[doc = "Not restored reason"]
+            #[serde(rename = "reason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub reason: BackForwardCacheNotRestoredReason,
+            #[doc = "Context associated with the reason. The meaning of this context is\ndependent on the reason:\n- EmbedderExtensionSentMessageToCachedFrame: the extension ID.\n"]
+            #[serde(rename = "context")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub context: Option<String>,
+            #[serde(rename = "details")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub details: Option<Vec<BackForwardCacheBlockingDetails>>,
+        }
+        impl BackForwardCacheNotRestoredExplanation {
+            pub fn new(
+                r#type: impl Into<BackForwardCacheNotRestoredReasonType>,
+                reason: impl Into<BackForwardCacheNotRestoredReason>,
+            ) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    reason: reason.into(),
+                    context: None,
+                    details: None,
+                }
+            }
+        }
+        impl BackForwardCacheNotRestoredExplanation {
+            pub fn builder() -> BackForwardCacheNotRestoredExplanationBuilder {
+                BackForwardCacheNotRestoredExplanationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BackForwardCacheNotRestoredExplanationBuilder {
+            r#type: Option<BackForwardCacheNotRestoredReasonType>,
+            reason: Option<BackForwardCacheNotRestoredReason>,
+            context: Option<String>,
+            details: Option<Vec<BackForwardCacheBlockingDetails>>,
+        }
+        impl BackForwardCacheNotRestoredExplanationBuilder {
+            pub fn r#type(
+                mut self,
+                r#type: impl Into<BackForwardCacheNotRestoredReasonType>,
+            ) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn reason(mut self, reason: impl Into<BackForwardCacheNotRestoredReason>) -> Self {
+                self.reason = Some(reason.into());
+                self
+            }
+            pub fn context(mut self, context: impl Into<String>) -> Self {
+                self.context = Some(context.into());
+                self
+            }
+            pub fn detail(mut self, detail: impl Into<BackForwardCacheBlockingDetails>) -> Self {
+                let v = self.details.get_or_insert(Vec::new());
+                v.push(detail.into());
+                self
+            }
+            pub fn details<I, S>(mut self, details: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<BackForwardCacheBlockingDetails>,
+            {
+                let v = self.details.get_or_insert(Vec::new());
+                for val in details {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<BackForwardCacheNotRestoredExplanation, String> {
+                Ok(BackForwardCacheNotRestoredExplanation {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    reason: self.reason.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(reason))
+                    })?,
+                    context: self.context,
+                    details: self.details,
+                })
+            }
+        }
+        impl BackForwardCacheNotRestoredExplanation {
+            pub const IDENTIFIER: &'static str = "Page.BackForwardCacheNotRestoredExplanation";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BackForwardCacheNotRestoredExplanationTree {
+            #[doc = "URL of each frame"]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Not restored reasons of each frame"]
+            #[serde(rename = "explanations")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub explanations: Vec<BackForwardCacheNotRestoredExplanation>,
+            #[doc = "Array of children frame"]
+            #[serde(rename = "children")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub children: Vec<BackForwardCacheNotRestoredExplanationTree>,
+        }
+        impl BackForwardCacheNotRestoredExplanationTree {
+            pub fn new(
+                url: impl Into<String>,
+                explanations: Vec<BackForwardCacheNotRestoredExplanation>,
+                children: Vec<BackForwardCacheNotRestoredExplanationTree>,
+            ) -> Self {
+                Self {
+                    url: url.into(),
+                    explanations,
+                    children,
+                }
+            }
+        }
+        impl BackForwardCacheNotRestoredExplanationTree {
+            pub fn builder() -> BackForwardCacheNotRestoredExplanationTreeBuilder {
+                BackForwardCacheNotRestoredExplanationTreeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BackForwardCacheNotRestoredExplanationTreeBuilder {
+            url: Option<String>,
+            explanations: Option<Vec<BackForwardCacheNotRestoredExplanation>>,
+            children: Option<Vec<BackForwardCacheNotRestoredExplanationTree>>,
+        }
+        impl BackForwardCacheNotRestoredExplanationTreeBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn explanation(
+                mut self,
+                explanation: impl Into<BackForwardCacheNotRestoredExplanation>,
+            ) -> Self {
+                let v = self.explanations.get_or_insert(Vec::new());
+                v.push(explanation.into());
+                self
+            }
+            pub fn explanations<I, S>(mut self, explanations: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<BackForwardCacheNotRestoredExplanation>,
+            {
+                let v = self.explanations.get_or_insert(Vec::new());
+                for val in explanations {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn children(
+                mut self,
+                children: impl Into<BackForwardCacheNotRestoredExplanationTree>,
+            ) -> Self {
+                let v = self.children.get_or_insert(Vec::new());
+                v.push(children.into());
+                self
+            }
+            pub fn childrens<I, S>(mut self, childrens: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<BackForwardCacheNotRestoredExplanationTree>,
+            {
+                let v = self.children.get_or_insert(Vec::new());
+                for val in childrens {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<BackForwardCacheNotRestoredExplanationTree, String> {
+                Ok(BackForwardCacheNotRestoredExplanationTree {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    explanations: self.explanations.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(explanations))
+                    })?,
+                    children: self.children.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(children))
+                    })?,
+                })
+            }
+        }
+        impl BackForwardCacheNotRestoredExplanationTree {
+            pub const IDENTIFIER: &'static str = "Page.BackForwardCacheNotRestoredExplanationTree";
+        }
+        #[doc = "Evaluates given script in every frame upon creation (before loading frame's scripts).\n[addScriptToEvaluateOnNewDocument](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-addScriptToEvaluateOnNewDocument)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddScriptToEvaluateOnNewDocumentParams {
+            #[serde(rename = "source")]
+            pub source: String,
+            #[doc = "If specified, creates an isolated world with the given name and evaluates given script in it.\nThis world name will be used as the ExecutionContextDescription::name when the corresponding\nevent is emitted."]
+            #[serde(rename = "worldName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub world_name: Option<String>,
+            #[doc = "Specifies whether command line API should be available to the script, defaults\nto false."]
+            #[serde(rename = "includeCommandLineAPI")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_command_line_api: Option<bool>,
+            #[doc = "If true, runs the script immediately on existing execution contexts or worlds.\nDefault: false."]
+            #[serde(rename = "runImmediately")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub run_immediately: Option<bool>,
+        }
+        impl AddScriptToEvaluateOnNewDocumentParams {
+            pub fn new(source: impl Into<String>) -> Self {
+                Self {
+                    source: source.into(),
+                    world_name: None,
+                    include_command_line_api: None,
+                    run_immediately: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for AddScriptToEvaluateOnNewDocumentParams {
+            fn from(url: T) -> Self {
+                AddScriptToEvaluateOnNewDocumentParams::new(url)
+            }
+        }
+        impl AddScriptToEvaluateOnNewDocumentParams {
+            pub fn builder() -> AddScriptToEvaluateOnNewDocumentParamsBuilder {
+                AddScriptToEvaluateOnNewDocumentParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddScriptToEvaluateOnNewDocumentParamsBuilder {
+            source: Option<String>,
+            world_name: Option<String>,
+            include_command_line_api: Option<bool>,
+            run_immediately: Option<bool>,
+        }
+        impl AddScriptToEvaluateOnNewDocumentParamsBuilder {
+            pub fn source(mut self, source: impl Into<String>) -> Self {
+                self.source = Some(source.into());
+                self
+            }
+            pub fn world_name(mut self, world_name: impl Into<String>) -> Self {
+                self.world_name = Some(world_name.into());
+                self
+            }
+            pub fn include_command_line_api(
+                mut self,
+                include_command_line_api: impl Into<bool>,
+            ) -> Self {
+                self.include_command_line_api = Some(include_command_line_api.into());
+                self
+            }
+            pub fn run_immediately(mut self, run_immediately: impl Into<bool>) -> Self {
+                self.run_immediately = Some(run_immediately.into());
+                self
+            }
+            pub fn build(self) -> Result<AddScriptToEvaluateOnNewDocumentParams, String> {
+                Ok(AddScriptToEvaluateOnNewDocumentParams {
+                    source: self.source.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source))
+                    })?,
+                    world_name: self.world_name,
+                    include_command_line_api: self.include_command_line_api,
+                    run_immediately: self.run_immediately,
+                })
+            }
+        }
+        impl AddScriptToEvaluateOnNewDocumentParams {
+            pub const IDENTIFIER: &'static str = "Page.addScriptToEvaluateOnNewDocument";
+        }
+        impl chromiumoxide_types::Method for AddScriptToEvaluateOnNewDocumentParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddScriptToEvaluateOnNewDocumentParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Evaluates given script in every frame upon creation (before loading frame's scripts).\n[addScriptToEvaluateOnNewDocument](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-addScriptToEvaluateOnNewDocument)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddScriptToEvaluateOnNewDocumentReturns {
+            #[doc = "Identifier of the added script."]
+            #[serde(rename = "identifier")]
+            pub identifier: ScriptIdentifier,
+        }
+        impl AddScriptToEvaluateOnNewDocumentReturns {
+            pub fn new(identifier: impl Into<ScriptIdentifier>) -> Self {
+                Self {
+                    identifier: identifier.into(),
+                }
+            }
+        }
+        impl AddScriptToEvaluateOnNewDocumentReturns {
+            pub fn builder() -> AddScriptToEvaluateOnNewDocumentReturnsBuilder {
+                AddScriptToEvaluateOnNewDocumentReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddScriptToEvaluateOnNewDocumentReturnsBuilder {
+            identifier: Option<ScriptIdentifier>,
+        }
+        impl AddScriptToEvaluateOnNewDocumentReturnsBuilder {
+            pub fn identifier(mut self, identifier: impl Into<ScriptIdentifier>) -> Self {
+                self.identifier = Some(identifier.into());
+                self
+            }
+            pub fn build(self) -> Result<AddScriptToEvaluateOnNewDocumentReturns, String> {
+                Ok(AddScriptToEvaluateOnNewDocumentReturns {
+                    identifier: self.identifier.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(identifier))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for AddScriptToEvaluateOnNewDocumentParams {
+            type Response = AddScriptToEvaluateOnNewDocumentReturns;
+        }
+        #[doc = "Brings page to front (activates tab).\n[bringToFront](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-bringToFront)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct BringToFrontParams {}
+        impl BringToFrontParams {
+            pub const IDENTIFIER: &'static str = "Page.bringToFront";
+        }
+        impl chromiumoxide_types::Method for BringToFrontParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for BringToFrontParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Brings page to front (activates tab).\n[bringToFront](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-bringToFront)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct BringToFrontReturns {}
+        impl chromiumoxide_types::Command for BringToFrontParams {
+            type Response = BringToFrontReturns;
+        }
+        #[doc = "Capture page screenshot.\n[captureScreenshot](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-captureScreenshot)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CaptureScreenshotParams {
+            #[doc = "Image compression format (defaults to png)."]
+            #[serde(rename = "format")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub format: Option<CaptureScreenshotFormat>,
+            #[doc = "Compression quality from range [0..100] (jpeg only)."]
+            #[serde(rename = "quality")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub quality: Option<i64>,
+            #[doc = "Capture the screenshot of a given region only."]
+            #[serde(rename = "clip")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub clip: Option<Viewport>,
+            #[doc = "Capture the screenshot from the surface, rather than the view. Defaults to true."]
+            #[serde(rename = "fromSurface")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub from_surface: Option<bool>,
+            #[doc = "Capture the screenshot beyond the viewport. Defaults to false."]
+            #[serde(rename = "captureBeyondViewport")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub capture_beyond_viewport: Option<bool>,
+            #[doc = "Optimize image encoding for speed, not for resulting size (defaults to false)"]
+            #[serde(rename = "optimizeForSpeed")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub optimize_for_speed: Option<bool>,
+        }
+        #[doc = "Image compression format (defaults to png)."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CaptureScreenshotFormat {
+            #[serde(rename = "jpeg")]
+            Jpeg,
+            #[serde(rename = "png")]
+            Png,
+            #[serde(rename = "webp")]
+            Webp,
+        }
+        impl AsRef<str> for CaptureScreenshotFormat {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CaptureScreenshotFormat::Jpeg => "jpeg",
+                    CaptureScreenshotFormat::Png => "png",
+                    CaptureScreenshotFormat::Webp => "webp",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CaptureScreenshotFormat {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "jpeg" | "Jpeg" => Ok(CaptureScreenshotFormat::Jpeg),
+                    "png" | "Png" => Ok(CaptureScreenshotFormat::Png),
+                    "webp" | "Webp" => Ok(CaptureScreenshotFormat::Webp),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl CaptureScreenshotParams {
+            pub fn builder() -> CaptureScreenshotParamsBuilder {
+                CaptureScreenshotParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CaptureScreenshotParamsBuilder {
+            format: Option<CaptureScreenshotFormat>,
+            quality: Option<i64>,
+            clip: Option<Viewport>,
+            from_surface: Option<bool>,
+            capture_beyond_viewport: Option<bool>,
+            optimize_for_speed: Option<bool>,
+        }
+        impl CaptureScreenshotParamsBuilder {
+            pub fn format(mut self, format: impl Into<CaptureScreenshotFormat>) -> Self {
+                self.format = Some(format.into());
+                self
+            }
+            pub fn quality(mut self, quality: impl Into<i64>) -> Self {
+                self.quality = Some(quality.into());
+                self
+            }
+            pub fn clip(mut self, clip: impl Into<Viewport>) -> Self {
+                self.clip = Some(clip.into());
+                self
+            }
+            pub fn from_surface(mut self, from_surface: impl Into<bool>) -> Self {
+                self.from_surface = Some(from_surface.into());
+                self
+            }
+            pub fn capture_beyond_viewport(
+                mut self,
+                capture_beyond_viewport: impl Into<bool>,
+            ) -> Self {
+                self.capture_beyond_viewport = Some(capture_beyond_viewport.into());
+                self
+            }
+            pub fn optimize_for_speed(mut self, optimize_for_speed: impl Into<bool>) -> Self {
+                self.optimize_for_speed = Some(optimize_for_speed.into());
+                self
+            }
+            pub fn build(self) -> CaptureScreenshotParams {
+                CaptureScreenshotParams {
+                    format: self.format,
+                    quality: self.quality,
+                    clip: self.clip,
+                    from_surface: self.from_surface,
+                    capture_beyond_viewport: self.capture_beyond_viewport,
+                    optimize_for_speed: self.optimize_for_speed,
+                }
+            }
+        }
+        impl CaptureScreenshotParams {
+            pub const IDENTIFIER: &'static str = "Page.captureScreenshot";
+        }
+        impl chromiumoxide_types::Method for CaptureScreenshotParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CaptureScreenshotParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Capture page screenshot.\n[captureScreenshot](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-captureScreenshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CaptureScreenshotReturns {
+            #[doc = "Base64-encoded image data."]
+            #[serde(rename = "data")]
+            pub data: chromiumoxide_types::Binary,
+        }
+        impl CaptureScreenshotReturns {
+            pub fn new(data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                Self { data: data.into() }
+            }
+        }
+        impl CaptureScreenshotReturns {
+            pub fn builder() -> CaptureScreenshotReturnsBuilder {
+                CaptureScreenshotReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CaptureScreenshotReturnsBuilder {
+            data: Option<chromiumoxide_types::Binary>,
+        }
+        impl CaptureScreenshotReturnsBuilder {
+            pub fn data(mut self, data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn build(self) -> Result<CaptureScreenshotReturns, String> {
+                Ok(CaptureScreenshotReturns {
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CaptureScreenshotParams {
+            type Response = CaptureScreenshotReturns;
+        }
+        #[doc = "Returns a snapshot of the page as a string. For MHTML format, the serialization includes\niframes, shadow DOM, external resources, and element-inline styles.\n[captureSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-captureSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CaptureSnapshotParams {
+            #[doc = "Format (defaults to mhtml)."]
+            #[serde(rename = "format")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub format: Option<CaptureSnapshotFormat>,
+        }
+        #[doc = "Format (defaults to mhtml)."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CaptureSnapshotFormat {
+            #[serde(rename = "mhtml")]
+            Mhtml,
+        }
+        impl AsRef<str> for CaptureSnapshotFormat {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CaptureSnapshotFormat::Mhtml => "mhtml",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CaptureSnapshotFormat {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "mhtml" | "Mhtml" => Ok(CaptureSnapshotFormat::Mhtml),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl CaptureSnapshotParams {
+            pub fn builder() -> CaptureSnapshotParamsBuilder {
+                CaptureSnapshotParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CaptureSnapshotParamsBuilder {
+            format: Option<CaptureSnapshotFormat>,
+        }
+        impl CaptureSnapshotParamsBuilder {
+            pub fn format(mut self, format: impl Into<CaptureSnapshotFormat>) -> Self {
+                self.format = Some(format.into());
+                self
+            }
+            pub fn build(self) -> CaptureSnapshotParams {
+                CaptureSnapshotParams {
+                    format: self.format,
+                }
+            }
+        }
+        impl CaptureSnapshotParams {
+            pub const IDENTIFIER: &'static str = "Page.captureSnapshot";
+        }
+        impl chromiumoxide_types::Method for CaptureSnapshotParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CaptureSnapshotParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns a snapshot of the page as a string. For MHTML format, the serialization includes\niframes, shadow DOM, external resources, and element-inline styles.\n[captureSnapshot](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-captureSnapshot)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CaptureSnapshotReturns {
+            #[doc = "Serialized page data."]
+            #[serde(rename = "data")]
+            pub data: String,
+        }
+        impl CaptureSnapshotReturns {
+            pub fn new(data: impl Into<String>) -> Self {
+                Self { data: data.into() }
+            }
+        }
+        impl<T: Into<String>> From<T> for CaptureSnapshotReturns {
+            fn from(url: T) -> Self {
+                CaptureSnapshotReturns::new(url)
+            }
+        }
+        impl CaptureSnapshotReturns {
+            pub fn builder() -> CaptureSnapshotReturnsBuilder {
+                CaptureSnapshotReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CaptureSnapshotReturnsBuilder {
+            data: Option<String>,
+        }
+        impl CaptureSnapshotReturnsBuilder {
+            pub fn data(mut self, data: impl Into<String>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn build(self) -> Result<CaptureSnapshotReturns, String> {
+                Ok(CaptureSnapshotReturns {
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CaptureSnapshotParams {
+            type Response = CaptureSnapshotReturns;
+        }
+        #[doc = "Creates an isolated world for the given frame.\n[createIsolatedWorld](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-createIsolatedWorld)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CreateIsolatedWorldParams {
+            #[doc = "Id of the frame in which the isolated world should be created."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "An optional name which is reported in the Execution Context."]
+            #[serde(rename = "worldName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub world_name: Option<String>,
+            #[doc = "Whether or not universal access should be granted to the isolated world. This is a powerful\noption, use with caution."]
+            #[serde(rename = "grantUniveralAccess")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub grant_univeral_access: Option<bool>,
+        }
+        impl CreateIsolatedWorldParams {
+            pub fn new(frame_id: impl Into<FrameId>) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                    world_name: None,
+                    grant_univeral_access: None,
+                }
+            }
+        }
+        impl CreateIsolatedWorldParams {
+            pub fn builder() -> CreateIsolatedWorldParamsBuilder {
+                CreateIsolatedWorldParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CreateIsolatedWorldParamsBuilder {
+            frame_id: Option<FrameId>,
+            world_name: Option<String>,
+            grant_univeral_access: Option<bool>,
+        }
+        impl CreateIsolatedWorldParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn world_name(mut self, world_name: impl Into<String>) -> Self {
+                self.world_name = Some(world_name.into());
+                self
+            }
+            pub fn grant_univeral_access(mut self, grant_univeral_access: impl Into<bool>) -> Self {
+                self.grant_univeral_access = Some(grant_univeral_access.into());
+                self
+            }
+            pub fn build(self) -> Result<CreateIsolatedWorldParams, String> {
+                Ok(CreateIsolatedWorldParams {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    world_name: self.world_name,
+                    grant_univeral_access: self.grant_univeral_access,
+                })
+            }
+        }
+        impl CreateIsolatedWorldParams {
+            pub const IDENTIFIER: &'static str = "Page.createIsolatedWorld";
+        }
+        impl chromiumoxide_types::Method for CreateIsolatedWorldParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CreateIsolatedWorldParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Creates an isolated world for the given frame.\n[createIsolatedWorld](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-createIsolatedWorld)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CreateIsolatedWorldReturns {
+            #[doc = "Execution context of the isolated world."]
+            #[serde(rename = "executionContextId")]
+            pub execution_context_id: super::super::js_protocol::runtime::ExecutionContextId,
+        }
+        impl CreateIsolatedWorldReturns {
+            pub fn new(
+                execution_context_id: impl Into<super::super::js_protocol::runtime::ExecutionContextId>,
+            ) -> Self {
+                Self {
+                    execution_context_id: execution_context_id.into(),
+                }
+            }
+        }
+        impl CreateIsolatedWorldReturns {
+            pub fn builder() -> CreateIsolatedWorldReturnsBuilder {
+                CreateIsolatedWorldReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CreateIsolatedWorldReturnsBuilder {
+            execution_context_id: Option<super::super::js_protocol::runtime::ExecutionContextId>,
+        }
+        impl CreateIsolatedWorldReturnsBuilder {
+            pub fn execution_context_id(
+                mut self,
+                execution_context_id: impl Into<super::super::js_protocol::runtime::ExecutionContextId>,
+            ) -> Self {
+                self.execution_context_id = Some(execution_context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CreateIsolatedWorldReturns, String> {
+                Ok(CreateIsolatedWorldReturns {
+                    execution_context_id: self.execution_context_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(execution_context_id)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CreateIsolatedWorldParams {
+            type Response = CreateIsolatedWorldReturns;
+        }
+        #[doc = "Disables page domain notifications.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Page.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables page domain notifications.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables page domain notifications.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[doc = "If true, the `Page.fileChooserOpened` event will be emitted regardless of the state set by\n`Page.setInterceptFileChooserDialog` command (default: false)."]
+            #[serde(rename = "enableFileChooserOpenedEvent")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub enable_file_chooser_opened_event: Option<bool>,
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            enable_file_chooser_opened_event: Option<bool>,
+        }
+        impl EnableParamsBuilder {
+            pub fn enable_file_chooser_opened_event(
+                mut self,
+                enable_file_chooser_opened_event: impl Into<bool>,
+            ) -> Self {
+                self.enable_file_chooser_opened_event =
+                    Some(enable_file_chooser_opened_event.into());
+                self
+            }
+            pub fn build(self) -> EnableParams {
+                EnableParams {
+                    enable_file_chooser_opened_event: self.enable_file_chooser_opened_event,
+                }
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Page.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables page domain notifications.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Gets the processed manifest for this current document.\nThis API always waits for the manifest to be loaded.\nIf manifestId is provided, and it does not match the manifest of the\ncurrent document, this API errors out.\nIf there is not a loaded page, this API errors out immediately.\n[getAppManifest](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getAppManifest)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetAppManifestParams {
+            #[serde(rename = "manifestId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub manifest_id: Option<String>,
+        }
+        impl GetAppManifestParams {
+            pub fn builder() -> GetAppManifestParamsBuilder {
+                GetAppManifestParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAppManifestParamsBuilder {
+            manifest_id: Option<String>,
+        }
+        impl GetAppManifestParamsBuilder {
+            pub fn manifest_id(mut self, manifest_id: impl Into<String>) -> Self {
+                self.manifest_id = Some(manifest_id.into());
+                self
+            }
+            pub fn build(self) -> GetAppManifestParams {
+                GetAppManifestParams {
+                    manifest_id: self.manifest_id,
+                }
+            }
+        }
+        impl GetAppManifestParams {
+            pub const IDENTIFIER: &'static str = "Page.getAppManifest";
+        }
+        impl chromiumoxide_types::Method for GetAppManifestParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetAppManifestParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets the processed manifest for this current document.\nThis API always waits for the manifest to be loaded.\nIf manifestId is provided, and it does not match the manifest of the\ncurrent document, this API errors out.\nIf there is not a loaded page, this API errors out immediately.\n[getAppManifest](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getAppManifest)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAppManifestReturns {
+            #[doc = "Manifest location."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[serde(rename = "errors")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub errors: Vec<AppManifestError>,
+            #[doc = "Manifest content."]
+            #[serde(rename = "data")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub data: Option<String>,
+            #[serde(rename = "manifest")]
+            pub manifest: WebAppManifest,
+        }
+        impl GetAppManifestReturns {
+            pub fn new(
+                url: impl Into<String>,
+                errors: Vec<AppManifestError>,
+                manifest: impl Into<WebAppManifest>,
+            ) -> Self {
+                Self {
+                    url: url.into(),
+                    errors,
+                    manifest: manifest.into(),
+                    data: None,
+                }
+            }
+        }
+        impl GetAppManifestReturns {
+            pub fn builder() -> GetAppManifestReturnsBuilder {
+                GetAppManifestReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAppManifestReturnsBuilder {
+            url: Option<String>,
+            errors: Option<Vec<AppManifestError>>,
+            data: Option<String>,
+            manifest: Option<WebAppManifest>,
+        }
+        impl GetAppManifestReturnsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn error(mut self, error: impl Into<AppManifestError>) -> Self {
+                let v = self.errors.get_or_insert(Vec::new());
+                v.push(error.into());
+                self
+            }
+            pub fn errors<I, S>(mut self, errors: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AppManifestError>,
+            {
+                let v = self.errors.get_or_insert(Vec::new());
+                for val in errors {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn data(mut self, data: impl Into<String>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn manifest(mut self, manifest: impl Into<WebAppManifest>) -> Self {
+                self.manifest = Some(manifest.into());
+                self
+            }
+            pub fn build(self) -> Result<GetAppManifestReturns, String> {
+                Ok(GetAppManifestReturns {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    errors: self.errors.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(errors))
+                    })?,
+                    data: self.data,
+                    manifest: self.manifest.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(manifest))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetAppManifestParams {
+            type Response = GetAppManifestReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetInstallabilityErrorsParams {}
+        impl GetInstallabilityErrorsParams {
+            pub const IDENTIFIER: &'static str = "Page.getInstallabilityErrors";
+        }
+        impl chromiumoxide_types::Method for GetInstallabilityErrorsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetInstallabilityErrorsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetInstallabilityErrorsReturns {
+            #[serde(rename = "installabilityErrors")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub installability_errors: Vec<InstallabilityError>,
+        }
+        impl GetInstallabilityErrorsReturns {
+            pub fn new(installability_errors: Vec<InstallabilityError>) -> Self {
+                Self {
+                    installability_errors,
+                }
+            }
+        }
+        impl GetInstallabilityErrorsReturns {
+            pub fn builder() -> GetInstallabilityErrorsReturnsBuilder {
+                GetInstallabilityErrorsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetInstallabilityErrorsReturnsBuilder {
+            installability_errors: Option<Vec<InstallabilityError>>,
+        }
+        impl GetInstallabilityErrorsReturnsBuilder {
+            pub fn installability_error(
+                mut self,
+                installability_error: impl Into<InstallabilityError>,
+            ) -> Self {
+                let v = self.installability_errors.get_or_insert(Vec::new());
+                v.push(installability_error.into());
+                self
+            }
+            pub fn installability_errors<I, S>(mut self, installability_errors: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<InstallabilityError>,
+            {
+                let v = self.installability_errors.get_or_insert(Vec::new());
+                for val in installability_errors {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetInstallabilityErrorsReturns, String> {
+                Ok(GetInstallabilityErrorsReturns {
+                    installability_errors: self.installability_errors.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(installability_errors)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetInstallabilityErrorsParams {
+            type Response = GetInstallabilityErrorsReturns;
+        }
+        #[doc = "Returns the unique (PWA) app id.\nOnly returns values if the feature flag 'WebAppEnableManifestId' is enabled\n[getAppId](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getAppId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetAppIdParams {}
+        impl GetAppIdParams {
+            pub const IDENTIFIER: &'static str = "Page.getAppId";
+        }
+        impl chromiumoxide_types::Method for GetAppIdParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetAppIdParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the unique (PWA) app id.\nOnly returns values if the feature flag 'WebAppEnableManifestId' is enabled\n[getAppId](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getAppId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetAppIdReturns {
+            #[doc = "App id, either from manifest's id attribute or computed from start_url"]
+            #[serde(rename = "appId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub app_id: Option<String>,
+            #[doc = "Recommendation for manifest's id attribute to match current id computed from start_url"]
+            #[serde(rename = "recommendedId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub recommended_id: Option<String>,
+        }
+        impl GetAppIdReturns {
+            pub fn builder() -> GetAppIdReturnsBuilder {
+                GetAppIdReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAppIdReturnsBuilder {
+            app_id: Option<String>,
+            recommended_id: Option<String>,
+        }
+        impl GetAppIdReturnsBuilder {
+            pub fn app_id(mut self, app_id: impl Into<String>) -> Self {
+                self.app_id = Some(app_id.into());
+                self
+            }
+            pub fn recommended_id(mut self, recommended_id: impl Into<String>) -> Self {
+                self.recommended_id = Some(recommended_id.into());
+                self
+            }
+            pub fn build(self) -> GetAppIdReturns {
+                GetAppIdReturns {
+                    app_id: self.app_id,
+                    recommended_id: self.recommended_id,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for GetAppIdParams {
+            type Response = GetAppIdReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAdScriptAncestryParams {
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+        }
+        impl GetAdScriptAncestryParams {
+            pub fn new(frame_id: impl Into<FrameId>) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                }
+            }
+        }
+        impl GetAdScriptAncestryParams {
+            pub fn builder() -> GetAdScriptAncestryParamsBuilder {
+                GetAdScriptAncestryParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAdScriptAncestryParamsBuilder {
+            frame_id: Option<FrameId>,
+        }
+        impl GetAdScriptAncestryParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetAdScriptAncestryParams, String> {
+                Ok(GetAdScriptAncestryParams {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                })
+            }
+        }
+        impl GetAdScriptAncestryParams {
+            pub const IDENTIFIER: &'static str = "Page.getAdScriptAncestry";
+        }
+        impl chromiumoxide_types::Method for GetAdScriptAncestryParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetAdScriptAncestryParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetAdScriptAncestryReturns {
+            #[doc = "The ancestry chain of ad script identifiers leading to this frame's\ncreation, along with the root script's filterlist rule. The ancestry\nchain is ordered from the most immediate script (in the frame creation\nstack) to more distant ancestors (that created the immediately preceding\nscript). Only sent if frame is labelled as an ad and ids are available."]
+            #[serde(rename = "adScriptAncestry")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub ad_script_ancestry: Option<AdScriptAncestry>,
+        }
+        impl GetAdScriptAncestryReturns {
+            pub fn builder() -> GetAdScriptAncestryReturnsBuilder {
+                GetAdScriptAncestryReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAdScriptAncestryReturnsBuilder {
+            ad_script_ancestry: Option<AdScriptAncestry>,
+        }
+        impl GetAdScriptAncestryReturnsBuilder {
+            pub fn ad_script_ancestry(
+                mut self,
+                ad_script_ancestry: impl Into<AdScriptAncestry>,
+            ) -> Self {
+                self.ad_script_ancestry = Some(ad_script_ancestry.into());
+                self
+            }
+            pub fn build(self) -> GetAdScriptAncestryReturns {
+                GetAdScriptAncestryReturns {
+                    ad_script_ancestry: self.ad_script_ancestry,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for GetAdScriptAncestryParams {
+            type Response = GetAdScriptAncestryReturns;
+        }
+        #[doc = "Returns present frame tree structure.\n[getFrameTree](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getFrameTree)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetFrameTreeParams {}
+        impl GetFrameTreeParams {
+            pub const IDENTIFIER: &'static str = "Page.getFrameTree";
+        }
+        impl chromiumoxide_types::Method for GetFrameTreeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetFrameTreeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns present frame tree structure.\n[getFrameTree](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getFrameTree)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetFrameTreeReturns {
+            #[doc = "Present frame tree structure."]
+            #[serde(rename = "frameTree")]
+            pub frame_tree: FrameTree,
+        }
+        impl GetFrameTreeReturns {
+            pub fn new(frame_tree: impl Into<FrameTree>) -> Self {
+                Self {
+                    frame_tree: frame_tree.into(),
+                }
+            }
+        }
+        impl GetFrameTreeReturns {
+            pub fn builder() -> GetFrameTreeReturnsBuilder {
+                GetFrameTreeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetFrameTreeReturnsBuilder {
+            frame_tree: Option<FrameTree>,
+        }
+        impl GetFrameTreeReturnsBuilder {
+            pub fn frame_tree(mut self, frame_tree: impl Into<FrameTree>) -> Self {
+                self.frame_tree = Some(frame_tree.into());
+                self
+            }
+            pub fn build(self) -> Result<GetFrameTreeReturns, String> {
+                Ok(GetFrameTreeReturns {
+                    frame_tree: self.frame_tree.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_tree))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetFrameTreeParams {
+            type Response = GetFrameTreeReturns;
+        }
+        #[doc = "Returns metrics relating to the layouting of the page, such as viewport bounds/scale.\n[getLayoutMetrics](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getLayoutMetrics)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetLayoutMetricsParams {}
+        impl GetLayoutMetricsParams {
+            pub const IDENTIFIER: &'static str = "Page.getLayoutMetrics";
+        }
+        impl chromiumoxide_types::Method for GetLayoutMetricsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetLayoutMetricsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns metrics relating to the layouting of the page, such as viewport bounds/scale.\n[getLayoutMetrics](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getLayoutMetrics)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetLayoutMetricsReturns {
+            #[doc = "Metrics relating to the layout viewport in CSS pixels."]
+            #[serde(rename = "cssLayoutViewport")]
+            pub css_layout_viewport: LayoutViewport,
+            #[doc = "Metrics relating to the visual viewport in CSS pixels."]
+            #[serde(rename = "cssVisualViewport")]
+            pub css_visual_viewport: VisualViewport,
+            #[doc = "Size of scrollable area in CSS pixels."]
+            #[serde(rename = "cssContentSize")]
+            pub css_content_size: super::dom::Rect,
+        }
+        impl GetLayoutMetricsReturns {
+            pub fn new(
+                css_layout_viewport: impl Into<LayoutViewport>,
+                css_visual_viewport: impl Into<VisualViewport>,
+                css_content_size: impl Into<super::dom::Rect>,
+            ) -> Self {
+                Self {
+                    css_layout_viewport: css_layout_viewport.into(),
+                    css_visual_viewport: css_visual_viewport.into(),
+                    css_content_size: css_content_size.into(),
+                }
+            }
+        }
+        impl GetLayoutMetricsReturns {
+            pub fn builder() -> GetLayoutMetricsReturnsBuilder {
+                GetLayoutMetricsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetLayoutMetricsReturnsBuilder {
+            css_layout_viewport: Option<LayoutViewport>,
+            css_visual_viewport: Option<VisualViewport>,
+            css_content_size: Option<super::dom::Rect>,
+        }
+        impl GetLayoutMetricsReturnsBuilder {
+            pub fn css_layout_viewport(
+                mut self,
+                css_layout_viewport: impl Into<LayoutViewport>,
+            ) -> Self {
+                self.css_layout_viewport = Some(css_layout_viewport.into());
+                self
+            }
+            pub fn css_visual_viewport(
+                mut self,
+                css_visual_viewport: impl Into<VisualViewport>,
+            ) -> Self {
+                self.css_visual_viewport = Some(css_visual_viewport.into());
+                self
+            }
+            pub fn css_content_size(
+                mut self,
+                css_content_size: impl Into<super::dom::Rect>,
+            ) -> Self {
+                self.css_content_size = Some(css_content_size.into());
+                self
+            }
+            pub fn build(self) -> Result<GetLayoutMetricsReturns, String> {
+                Ok(GetLayoutMetricsReturns {
+                    css_layout_viewport: self.css_layout_viewport.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(css_layout_viewport)
+                        )
+                    })?,
+                    css_visual_viewport: self.css_visual_viewport.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(css_visual_viewport)
+                        )
+                    })?,
+                    css_content_size: self.css_content_size.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(css_content_size)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetLayoutMetricsParams {
+            type Response = GetLayoutMetricsReturns;
+        }
+        #[doc = "Returns navigation history for the current page.\n[getNavigationHistory](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getNavigationHistory)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetNavigationHistoryParams {}
+        impl GetNavigationHistoryParams {
+            pub const IDENTIFIER: &'static str = "Page.getNavigationHistory";
+        }
+        impl chromiumoxide_types::Method for GetNavigationHistoryParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetNavigationHistoryParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns navigation history for the current page.\n[getNavigationHistory](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getNavigationHistory)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetNavigationHistoryReturns {
+            #[doc = "Index of the current navigation history entry."]
+            #[serde(rename = "currentIndex")]
+            pub current_index: i64,
+            #[doc = "Array of navigation history entries."]
+            #[serde(rename = "entries")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub entries: Vec<NavigationEntry>,
+        }
+        impl GetNavigationHistoryReturns {
+            pub fn new(current_index: impl Into<i64>, entries: Vec<NavigationEntry>) -> Self {
+                Self {
+                    current_index: current_index.into(),
+                    entries,
+                }
+            }
+        }
+        impl GetNavigationHistoryReturns {
+            pub fn builder() -> GetNavigationHistoryReturnsBuilder {
+                GetNavigationHistoryReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetNavigationHistoryReturnsBuilder {
+            current_index: Option<i64>,
+            entries: Option<Vec<NavigationEntry>>,
+        }
+        impl GetNavigationHistoryReturnsBuilder {
+            pub fn current_index(mut self, current_index: impl Into<i64>) -> Self {
+                self.current_index = Some(current_index.into());
+                self
+            }
+            pub fn entrie(mut self, entrie: impl Into<NavigationEntry>) -> Self {
+                let v = self.entries.get_or_insert(Vec::new());
+                v.push(entrie.into());
+                self
+            }
+            pub fn entries<I, S>(mut self, entries: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<NavigationEntry>,
+            {
+                let v = self.entries.get_or_insert(Vec::new());
+                for val in entries {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetNavigationHistoryReturns, String> {
+                Ok(GetNavigationHistoryReturns {
+                    current_index: self.current_index.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(current_index))
+                    })?,
+                    entries: self.entries.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(entries))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetNavigationHistoryParams {
+            type Response = GetNavigationHistoryReturns;
+        }
+        #[doc = "Resets navigation history for the current page.\n[resetNavigationHistory](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-resetNavigationHistory)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResetNavigationHistoryParams {}
+        impl ResetNavigationHistoryParams {
+            pub const IDENTIFIER: &'static str = "Page.resetNavigationHistory";
+        }
+        impl chromiumoxide_types::Method for ResetNavigationHistoryParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ResetNavigationHistoryParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Resets navigation history for the current page.\n[resetNavigationHistory](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-resetNavigationHistory)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResetNavigationHistoryReturns {}
+        impl chromiumoxide_types::Command for ResetNavigationHistoryParams {
+            type Response = ResetNavigationHistoryReturns;
+        }
+        #[doc = "Returns content of the given resource.\n[getResourceContent](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getResourceContent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetResourceContentParams {
+            #[doc = "Frame id to get resource for."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "URL of the resource to get content for."]
+            #[serde(rename = "url")]
+            pub url: String,
+        }
+        impl GetResourceContentParams {
+            pub fn new(frame_id: impl Into<FrameId>, url: impl Into<String>) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                    url: url.into(),
+                }
+            }
+        }
+        impl GetResourceContentParams {
+            pub fn builder() -> GetResourceContentParamsBuilder {
+                GetResourceContentParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetResourceContentParamsBuilder {
+            frame_id: Option<FrameId>,
+            url: Option<String>,
+        }
+        impl GetResourceContentParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn build(self) -> Result<GetResourceContentParams, String> {
+                Ok(GetResourceContentParams {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                })
+            }
+        }
+        impl GetResourceContentParams {
+            pub const IDENTIFIER: &'static str = "Page.getResourceContent";
+        }
+        impl chromiumoxide_types::Method for GetResourceContentParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetResourceContentParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns content of the given resource.\n[getResourceContent](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getResourceContent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetResourceContentReturns {
+            #[doc = "Resource content."]
+            #[serde(rename = "content")]
+            pub content: String,
+            #[doc = "True, if content was served as base64."]
+            #[serde(rename = "base64Encoded")]
+            pub base64_encoded: bool,
+        }
+        impl GetResourceContentReturns {
+            pub fn new(content: impl Into<String>, base64_encoded: impl Into<bool>) -> Self {
+                Self {
+                    content: content.into(),
+                    base64_encoded: base64_encoded.into(),
+                }
+            }
+        }
+        impl GetResourceContentReturns {
+            pub fn builder() -> GetResourceContentReturnsBuilder {
+                GetResourceContentReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetResourceContentReturnsBuilder {
+            content: Option<String>,
+            base64_encoded: Option<bool>,
+        }
+        impl GetResourceContentReturnsBuilder {
+            pub fn content(mut self, content: impl Into<String>) -> Self {
+                self.content = Some(content.into());
+                self
+            }
+            pub fn base64_encoded(mut self, base64_encoded: impl Into<bool>) -> Self {
+                self.base64_encoded = Some(base64_encoded.into());
+                self
+            }
+            pub fn build(self) -> Result<GetResourceContentReturns, String> {
+                Ok(GetResourceContentReturns {
+                    content: self.content.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(content))
+                    })?,
+                    base64_encoded: self.base64_encoded.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(base64_encoded))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetResourceContentParams {
+            type Response = GetResourceContentReturns;
+        }
+        #[doc = "Returns present frame / resource tree structure.\n[getResourceTree](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getResourceTree)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetResourceTreeParams {}
+        impl GetResourceTreeParams {
+            pub const IDENTIFIER: &'static str = "Page.getResourceTree";
+        }
+        impl chromiumoxide_types::Method for GetResourceTreeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetResourceTreeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns present frame / resource tree structure.\n[getResourceTree](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getResourceTree)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetResourceTreeReturns {
+            #[doc = "Present frame / resource tree structure."]
+            #[serde(rename = "frameTree")]
+            pub frame_tree: FrameResourceTree,
+        }
+        impl GetResourceTreeReturns {
+            pub fn new(frame_tree: impl Into<FrameResourceTree>) -> Self {
+                Self {
+                    frame_tree: frame_tree.into(),
+                }
+            }
+        }
+        impl GetResourceTreeReturns {
+            pub fn builder() -> GetResourceTreeReturnsBuilder {
+                GetResourceTreeReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetResourceTreeReturnsBuilder {
+            frame_tree: Option<FrameResourceTree>,
+        }
+        impl GetResourceTreeReturnsBuilder {
+            pub fn frame_tree(mut self, frame_tree: impl Into<FrameResourceTree>) -> Self {
+                self.frame_tree = Some(frame_tree.into());
+                self
+            }
+            pub fn build(self) -> Result<GetResourceTreeReturns, String> {
+                Ok(GetResourceTreeReturns {
+                    frame_tree: self.frame_tree.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_tree))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetResourceTreeParams {
+            type Response = GetResourceTreeReturns;
+        }
+        #[doc = "Accepts or dismisses a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload).\n[handleJavaScriptDialog](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-handleJavaScriptDialog)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct HandleJavaScriptDialogParams {
+            #[doc = "Whether to accept or dismiss the dialog."]
+            #[serde(rename = "accept")]
+            pub accept: bool,
+            #[doc = "The text to enter into the dialog prompt before accepting. Used only if this is a prompt\ndialog."]
+            #[serde(rename = "promptText")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub prompt_text: Option<String>,
+        }
+        impl HandleJavaScriptDialogParams {
+            pub fn new(accept: impl Into<bool>) -> Self {
+                Self {
+                    accept: accept.into(),
+                    prompt_text: None,
+                }
+            }
+        }
+        impl HandleJavaScriptDialogParams {
+            pub fn builder() -> HandleJavaScriptDialogParamsBuilder {
+                HandleJavaScriptDialogParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct HandleJavaScriptDialogParamsBuilder {
+            accept: Option<bool>,
+            prompt_text: Option<String>,
+        }
+        impl HandleJavaScriptDialogParamsBuilder {
+            pub fn accept(mut self, accept: impl Into<bool>) -> Self {
+                self.accept = Some(accept.into());
+                self
+            }
+            pub fn prompt_text(mut self, prompt_text: impl Into<String>) -> Self {
+                self.prompt_text = Some(prompt_text.into());
+                self
+            }
+            pub fn build(self) -> Result<HandleJavaScriptDialogParams, String> {
+                Ok(HandleJavaScriptDialogParams {
+                    accept: self.accept.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(accept))
+                    })?,
+                    prompt_text: self.prompt_text,
+                })
+            }
+        }
+        impl HandleJavaScriptDialogParams {
+            pub const IDENTIFIER: &'static str = "Page.handleJavaScriptDialog";
+        }
+        impl chromiumoxide_types::Method for HandleJavaScriptDialogParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for HandleJavaScriptDialogParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Accepts or dismisses a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload).\n[handleJavaScriptDialog](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-handleJavaScriptDialog)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct HandleJavaScriptDialogReturns {}
+        impl chromiumoxide_types::Command for HandleJavaScriptDialogParams {
+            type Response = HandleJavaScriptDialogReturns;
+        }
+        #[doc = "Navigates current page to the given URL.\n[navigate](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-navigate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct NavigateParams {
+            #[doc = "URL to navigate the page to."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Referrer URL."]
+            #[serde(rename = "referrer")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub referrer: Option<String>,
+            #[doc = "Intended transition type."]
+            #[serde(rename = "transitionType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub transition_type: Option<TransitionType>,
+            #[doc = "Frame id to navigate, if not specified navigates the top frame."]
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<FrameId>,
+            #[doc = "Referrer-policy used for the navigation."]
+            #[serde(rename = "referrerPolicy")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub referrer_policy: Option<ReferrerPolicy>,
+        }
+        impl NavigateParams {
+            pub fn new(url: impl Into<String>) -> Self {
+                Self {
+                    url: url.into(),
+                    referrer: None,
+                    transition_type: None,
+                    frame_id: None,
+                    referrer_policy: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for NavigateParams {
+            fn from(url: T) -> Self {
+                NavigateParams::new(url)
+            }
+        }
+        impl NavigateParams {
+            pub fn builder() -> NavigateParamsBuilder {
+                NavigateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct NavigateParamsBuilder {
+            url: Option<String>,
+            referrer: Option<String>,
+            transition_type: Option<TransitionType>,
+            frame_id: Option<FrameId>,
+            referrer_policy: Option<ReferrerPolicy>,
+        }
+        impl NavigateParamsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn referrer(mut self, referrer: impl Into<String>) -> Self {
+                self.referrer = Some(referrer.into());
+                self
+            }
+            pub fn transition_type(mut self, transition_type: impl Into<TransitionType>) -> Self {
+                self.transition_type = Some(transition_type.into());
+                self
+            }
+            pub fn frame_id(mut self, frame_id: impl Into<FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn referrer_policy(mut self, referrer_policy: impl Into<ReferrerPolicy>) -> Self {
+                self.referrer_policy = Some(referrer_policy.into());
+                self
+            }
+            pub fn build(self) -> Result<NavigateParams, String> {
+                Ok(NavigateParams {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    referrer: self.referrer,
+                    transition_type: self.transition_type,
+                    frame_id: self.frame_id,
+                    referrer_policy: self.referrer_policy,
+                })
+            }
+        }
+        impl NavigateParams {
+            pub const IDENTIFIER: &'static str = "Page.navigate";
+        }
+        impl chromiumoxide_types::Method for NavigateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for NavigateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Navigates current page to the given URL.\n[navigate](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-navigate)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct NavigateReturns {
+            #[doc = "Frame id that has navigated (or failed to navigate)"]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "Loader identifier. This is omitted in case of same-document navigation,\nas the previously committed loaderId would not change."]
+            #[serde(rename = "loaderId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub loader_id: Option<super::network::LoaderId>,
+            #[doc = "User friendly error message, present if and only if navigation has failed."]
+            #[serde(rename = "errorText")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub error_text: Option<String>,
+            #[doc = "Whether the navigation resulted in a download."]
+            #[serde(rename = "isDownload")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_download: Option<bool>,
+        }
+        impl NavigateReturns {
+            pub fn new(frame_id: impl Into<FrameId>) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                    loader_id: None,
+                    error_text: None,
+                    is_download: None,
+                }
+            }
+        }
+        impl NavigateReturns {
+            pub fn builder() -> NavigateReturnsBuilder {
+                NavigateReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct NavigateReturnsBuilder {
+            frame_id: Option<FrameId>,
+            loader_id: Option<super::network::LoaderId>,
+            error_text: Option<String>,
+            is_download: Option<bool>,
+        }
+        impl NavigateReturnsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn loader_id(mut self, loader_id: impl Into<super::network::LoaderId>) -> Self {
+                self.loader_id = Some(loader_id.into());
+                self
+            }
+            pub fn error_text(mut self, error_text: impl Into<String>) -> Self {
+                self.error_text = Some(error_text.into());
+                self
+            }
+            pub fn is_download(mut self, is_download: impl Into<bool>) -> Self {
+                self.is_download = Some(is_download.into());
+                self
+            }
+            pub fn build(self) -> Result<NavigateReturns, String> {
+                Ok(NavigateReturns {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    loader_id: self.loader_id,
+                    error_text: self.error_text,
+                    is_download: self.is_download,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for NavigateParams {
+            type Response = NavigateReturns;
+        }
+        #[doc = "Navigates current page to the given history entry.\n[navigateToHistoryEntry](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-navigateToHistoryEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct NavigateToHistoryEntryParams {
+            #[doc = "Unique id of the entry to navigate to."]
+            #[serde(rename = "entryId")]
+            pub entry_id: i64,
+        }
+        impl NavigateToHistoryEntryParams {
+            pub fn new(entry_id: impl Into<i64>) -> Self {
+                Self {
+                    entry_id: entry_id.into(),
+                }
+            }
+        }
+        impl NavigateToHistoryEntryParams {
+            pub fn builder() -> NavigateToHistoryEntryParamsBuilder {
+                NavigateToHistoryEntryParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct NavigateToHistoryEntryParamsBuilder {
+            entry_id: Option<i64>,
+        }
+        impl NavigateToHistoryEntryParamsBuilder {
+            pub fn entry_id(mut self, entry_id: impl Into<i64>) -> Self {
+                self.entry_id = Some(entry_id.into());
+                self
+            }
+            pub fn build(self) -> Result<NavigateToHistoryEntryParams, String> {
+                Ok(NavigateToHistoryEntryParams {
+                    entry_id: self.entry_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(entry_id))
+                    })?,
+                })
+            }
+        }
+        impl NavigateToHistoryEntryParams {
+            pub const IDENTIFIER: &'static str = "Page.navigateToHistoryEntry";
+        }
+        impl chromiumoxide_types::Method for NavigateToHistoryEntryParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for NavigateToHistoryEntryParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Navigates current page to the given history entry.\n[navigateToHistoryEntry](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-navigateToHistoryEntry)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct NavigateToHistoryEntryReturns {}
+        impl chromiumoxide_types::Command for NavigateToHistoryEntryParams {
+            type Response = NavigateToHistoryEntryReturns;
+        }
+        #[doc = "Print page as PDF.\n[printToPDF](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-printToPDF)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct PrintToPdfParams {
+            #[doc = "Paper orientation. Defaults to false."]
+            #[serde(rename = "landscape")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub landscape: Option<bool>,
+            #[doc = "Display header and footer. Defaults to false."]
+            #[serde(rename = "displayHeaderFooter")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub display_header_footer: Option<bool>,
+            #[doc = "Print background graphics. Defaults to false."]
+            #[serde(rename = "printBackground")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub print_background: Option<bool>,
+            #[doc = "Scale of the webpage rendering. Defaults to 1."]
+            #[serde(rename = "scale")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scale: Option<f64>,
+            #[doc = "Paper width in inches. Defaults to 8.5 inches."]
+            #[serde(rename = "paperWidth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub paper_width: Option<f64>,
+            #[doc = "Paper height in inches. Defaults to 11 inches."]
+            #[serde(rename = "paperHeight")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub paper_height: Option<f64>,
+            #[doc = "Top margin in inches. Defaults to 1cm (~0.4 inches)."]
+            #[serde(rename = "marginTop")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub margin_top: Option<f64>,
+            #[doc = "Bottom margin in inches. Defaults to 1cm (~0.4 inches)."]
+            #[serde(rename = "marginBottom")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub margin_bottom: Option<f64>,
+            #[doc = "Left margin in inches. Defaults to 1cm (~0.4 inches)."]
+            #[serde(rename = "marginLeft")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub margin_left: Option<f64>,
+            #[doc = "Right margin in inches. Defaults to 1cm (~0.4 inches)."]
+            #[serde(rename = "marginRight")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub margin_right: Option<f64>,
+            #[doc = "Paper ranges to print, one based, e.g., '1-5, 8, 11-13'. Pages are\nprinted in the document order, not in the order specified, and no\nmore than once.\nDefaults to empty string, which implies the entire document is printed.\nThe page numbers are quietly capped to actual page count of the\ndocument, and ranges beyond the end of the document are ignored.\nIf this results in no pages to print, an error is reported.\nIt is an error to specify a range with start greater than end."]
+            #[serde(rename = "pageRanges")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub page_ranges: Option<String>,
+            #[doc = "HTML template for the print header. Should be valid HTML markup with following\nclasses used to inject printing values into them:\n- `date`: formatted print date\n- `title`: document title\n- `url`: document location\n- `pageNumber`: current page number\n- `totalPages`: total pages in the document\n\nFor example, `<span class=title></span>` would generate span containing the title."]
+            #[serde(rename = "headerTemplate")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub header_template: Option<String>,
+            #[doc = "HTML template for the print footer. Should use the same format as the `headerTemplate`."]
+            #[serde(rename = "footerTemplate")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub footer_template: Option<String>,
+            #[doc = "Whether or not to prefer page size as defined by css. Defaults to false,\nin which case the content will be scaled to fit the paper size."]
+            #[serde(rename = "preferCSSPageSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub prefer_css_page_size: Option<bool>,
+            #[doc = "return as stream"]
+            #[serde(rename = "transferMode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub transfer_mode: Option<PrintToPdfTransferMode>,
+            #[doc = "Whether or not to generate tagged (accessible) PDF. Defaults to embedder choice."]
+            #[serde(rename = "generateTaggedPDF")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub generate_tagged_pdf: Option<bool>,
+            #[doc = "Whether or not to embed the document outline into the PDF."]
+            #[serde(rename = "generateDocumentOutline")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub generate_document_outline: Option<bool>,
+        }
+        #[doc = "return as stream"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PrintToPdfTransferMode {
+            #[serde(rename = "ReturnAsBase64")]
+            ReturnAsBase64,
+            #[serde(rename = "ReturnAsStream")]
+            ReturnAsStream,
+        }
+        impl AsRef<str> for PrintToPdfTransferMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PrintToPdfTransferMode::ReturnAsBase64 => "ReturnAsBase64",
+                    PrintToPdfTransferMode::ReturnAsStream => "ReturnAsStream",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PrintToPdfTransferMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "ReturnAsBase64" | "returnasbase64" => {
+                        Ok(PrintToPdfTransferMode::ReturnAsBase64)
+                    }
+                    "ReturnAsStream" | "returnasstream" => {
+                        Ok(PrintToPdfTransferMode::ReturnAsStream)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl PrintToPdfParams {
+            pub fn builder() -> PrintToPdfParamsBuilder {
+                PrintToPdfParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PrintToPdfParamsBuilder {
+            landscape: Option<bool>,
+            display_header_footer: Option<bool>,
+            print_background: Option<bool>,
+            scale: Option<f64>,
+            paper_width: Option<f64>,
+            paper_height: Option<f64>,
+            margin_top: Option<f64>,
+            margin_bottom: Option<f64>,
+            margin_left: Option<f64>,
+            margin_right: Option<f64>,
+            page_ranges: Option<String>,
+            header_template: Option<String>,
+            footer_template: Option<String>,
+            prefer_css_page_size: Option<bool>,
+            transfer_mode: Option<PrintToPdfTransferMode>,
+            generate_tagged_pdf: Option<bool>,
+            generate_document_outline: Option<bool>,
+        }
+        impl PrintToPdfParamsBuilder {
+            pub fn landscape(mut self, landscape: impl Into<bool>) -> Self {
+                self.landscape = Some(landscape.into());
+                self
+            }
+            pub fn display_header_footer(mut self, display_header_footer: impl Into<bool>) -> Self {
+                self.display_header_footer = Some(display_header_footer.into());
+                self
+            }
+            pub fn print_background(mut self, print_background: impl Into<bool>) -> Self {
+                self.print_background = Some(print_background.into());
+                self
+            }
+            pub fn scale(mut self, scale: impl Into<f64>) -> Self {
+                self.scale = Some(scale.into());
+                self
+            }
+            pub fn paper_width(mut self, paper_width: impl Into<f64>) -> Self {
+                self.paper_width = Some(paper_width.into());
+                self
+            }
+            pub fn paper_height(mut self, paper_height: impl Into<f64>) -> Self {
+                self.paper_height = Some(paper_height.into());
+                self
+            }
+            pub fn margin_top(mut self, margin_top: impl Into<f64>) -> Self {
+                self.margin_top = Some(margin_top.into());
+                self
+            }
+            pub fn margin_bottom(mut self, margin_bottom: impl Into<f64>) -> Self {
+                self.margin_bottom = Some(margin_bottom.into());
+                self
+            }
+            pub fn margin_left(mut self, margin_left: impl Into<f64>) -> Self {
+                self.margin_left = Some(margin_left.into());
+                self
+            }
+            pub fn margin_right(mut self, margin_right: impl Into<f64>) -> Self {
+                self.margin_right = Some(margin_right.into());
+                self
+            }
+            pub fn page_ranges(mut self, page_ranges: impl Into<String>) -> Self {
+                self.page_ranges = Some(page_ranges.into());
+                self
+            }
+            pub fn header_template(mut self, header_template: impl Into<String>) -> Self {
+                self.header_template = Some(header_template.into());
+                self
+            }
+            pub fn footer_template(mut self, footer_template: impl Into<String>) -> Self {
+                self.footer_template = Some(footer_template.into());
+                self
+            }
+            pub fn prefer_css_page_size(mut self, prefer_css_page_size: impl Into<bool>) -> Self {
+                self.prefer_css_page_size = Some(prefer_css_page_size.into());
+                self
+            }
+            pub fn transfer_mode(
+                mut self,
+                transfer_mode: impl Into<PrintToPdfTransferMode>,
+            ) -> Self {
+                self.transfer_mode = Some(transfer_mode.into());
+                self
+            }
+            pub fn generate_tagged_pdf(mut self, generate_tagged_pdf: impl Into<bool>) -> Self {
+                self.generate_tagged_pdf = Some(generate_tagged_pdf.into());
+                self
+            }
+            pub fn generate_document_outline(
+                mut self,
+                generate_document_outline: impl Into<bool>,
+            ) -> Self {
+                self.generate_document_outline = Some(generate_document_outline.into());
+                self
+            }
+            pub fn build(self) -> PrintToPdfParams {
+                PrintToPdfParams {
+                    landscape: self.landscape,
+                    display_header_footer: self.display_header_footer,
+                    print_background: self.print_background,
+                    scale: self.scale,
+                    paper_width: self.paper_width,
+                    paper_height: self.paper_height,
+                    margin_top: self.margin_top,
+                    margin_bottom: self.margin_bottom,
+                    margin_left: self.margin_left,
+                    margin_right: self.margin_right,
+                    page_ranges: self.page_ranges,
+                    header_template: self.header_template,
+                    footer_template: self.footer_template,
+                    prefer_css_page_size: self.prefer_css_page_size,
+                    transfer_mode: self.transfer_mode,
+                    generate_tagged_pdf: self.generate_tagged_pdf,
+                    generate_document_outline: self.generate_document_outline,
+                }
+            }
+        }
+        impl PrintToPdfParams {
+            pub const IDENTIFIER: &'static str = "Page.printToPDF";
+        }
+        impl chromiumoxide_types::Method for PrintToPdfParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for PrintToPdfParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Print page as PDF.\n[printToPDF](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-printToPDF)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PrintToPdfReturns {
+            #[doc = "Base64-encoded pdf data. Empty if |returnAsStream| is specified."]
+            #[serde(rename = "data")]
+            pub data: chromiumoxide_types::Binary,
+            #[doc = "A handle of the stream that holds resulting PDF data."]
+            #[serde(rename = "stream")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stream: Option<super::io::StreamHandle>,
+        }
+        impl PrintToPdfReturns {
+            pub fn new(data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                Self {
+                    data: data.into(),
+                    stream: None,
+                }
+            }
+        }
+        impl PrintToPdfReturns {
+            pub fn builder() -> PrintToPdfReturnsBuilder {
+                PrintToPdfReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PrintToPdfReturnsBuilder {
+            data: Option<chromiumoxide_types::Binary>,
+            stream: Option<super::io::StreamHandle>,
+        }
+        impl PrintToPdfReturnsBuilder {
+            pub fn data(mut self, data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn stream(mut self, stream: impl Into<super::io::StreamHandle>) -> Self {
+                self.stream = Some(stream.into());
+                self
+            }
+            pub fn build(self) -> Result<PrintToPdfReturns, String> {
+                Ok(PrintToPdfReturns {
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                    stream: self.stream,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for PrintToPdfParams {
+            type Response = PrintToPdfReturns;
+        }
+        #[doc = "Reloads given page optionally ignoring the cache.\n[reload](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-reload)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ReloadParams {
+            #[doc = "If true, browser cache is ignored (as if the user pressed Shift+refresh)."]
+            #[serde(rename = "ignoreCache")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub ignore_cache: Option<bool>,
+            #[doc = "If set, the script will be injected into all frames of the inspected page after reload.\nArgument will be ignored if reloading dataURL origin."]
+            #[serde(rename = "scriptToEvaluateOnLoad")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub script_to_evaluate_on_load: Option<String>,
+            #[doc = "If set, an error will be thrown if the target page's main frame's\nloader id does not match the provided id. This prevents accidentally\nreloading an unintended target in case there's a racing navigation."]
+            #[serde(rename = "loaderId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub loader_id: Option<super::network::LoaderId>,
+        }
+        impl ReloadParams {
+            pub fn builder() -> ReloadParamsBuilder {
+                ReloadParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ReloadParamsBuilder {
+            ignore_cache: Option<bool>,
+            script_to_evaluate_on_load: Option<String>,
+            loader_id: Option<super::network::LoaderId>,
+        }
+        impl ReloadParamsBuilder {
+            pub fn ignore_cache(mut self, ignore_cache: impl Into<bool>) -> Self {
+                self.ignore_cache = Some(ignore_cache.into());
+                self
+            }
+            pub fn script_to_evaluate_on_load(
+                mut self,
+                script_to_evaluate_on_load: impl Into<String>,
+            ) -> Self {
+                self.script_to_evaluate_on_load = Some(script_to_evaluate_on_load.into());
+                self
+            }
+            pub fn loader_id(mut self, loader_id: impl Into<super::network::LoaderId>) -> Self {
+                self.loader_id = Some(loader_id.into());
+                self
+            }
+            pub fn build(self) -> ReloadParams {
+                ReloadParams {
+                    ignore_cache: self.ignore_cache,
+                    script_to_evaluate_on_load: self.script_to_evaluate_on_load,
+                    loader_id: self.loader_id,
+                }
+            }
+        }
+        impl ReloadParams {
+            pub const IDENTIFIER: &'static str = "Page.reload";
+        }
+        impl chromiumoxide_types::Method for ReloadParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ReloadParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Reloads given page optionally ignoring the cache.\n[reload](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-reload)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ReloadReturns {}
+        impl chromiumoxide_types::Command for ReloadParams {
+            type Response = ReloadReturns;
+        }
+        #[doc = "Removes given script from the list.\n[removeScriptToEvaluateOnNewDocument](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-removeScriptToEvaluateOnNewDocument)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveScriptToEvaluateOnNewDocumentParams {
+            #[serde(rename = "identifier")]
+            pub identifier: ScriptIdentifier,
+        }
+        impl RemoveScriptToEvaluateOnNewDocumentParams {
+            pub fn new(identifier: impl Into<ScriptIdentifier>) -> Self {
+                Self {
+                    identifier: identifier.into(),
+                }
+            }
+        }
+        impl RemoveScriptToEvaluateOnNewDocumentParams {
+            pub fn builder() -> RemoveScriptToEvaluateOnNewDocumentParamsBuilder {
+                RemoveScriptToEvaluateOnNewDocumentParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveScriptToEvaluateOnNewDocumentParamsBuilder {
+            identifier: Option<ScriptIdentifier>,
+        }
+        impl RemoveScriptToEvaluateOnNewDocumentParamsBuilder {
+            pub fn identifier(mut self, identifier: impl Into<ScriptIdentifier>) -> Self {
+                self.identifier = Some(identifier.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveScriptToEvaluateOnNewDocumentParams, String> {
+                Ok(RemoveScriptToEvaluateOnNewDocumentParams {
+                    identifier: self.identifier.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(identifier))
+                    })?,
+                })
+            }
+        }
+        impl RemoveScriptToEvaluateOnNewDocumentParams {
+            pub const IDENTIFIER: &'static str = "Page.removeScriptToEvaluateOnNewDocument";
+        }
+        impl chromiumoxide_types::Method for RemoveScriptToEvaluateOnNewDocumentParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveScriptToEvaluateOnNewDocumentParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes given script from the list.\n[removeScriptToEvaluateOnNewDocument](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-removeScriptToEvaluateOnNewDocument)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveScriptToEvaluateOnNewDocumentReturns {}
+        impl chromiumoxide_types::Command for RemoveScriptToEvaluateOnNewDocumentParams {
+            type Response = RemoveScriptToEvaluateOnNewDocumentReturns;
+        }
+        #[doc = "Acknowledges that a screencast frame has been received by the frontend.\n[screencastFrameAck](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-screencastFrameAck)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ScreencastFrameAckParams {
+            #[doc = "Frame number."]
+            #[serde(rename = "sessionId")]
+            pub session_id: i64,
+        }
+        impl ScreencastFrameAckParams {
+            pub fn new(session_id: impl Into<i64>) -> Self {
+                Self {
+                    session_id: session_id.into(),
+                }
+            }
+        }
+        impl ScreencastFrameAckParams {
+            pub fn builder() -> ScreencastFrameAckParamsBuilder {
+                ScreencastFrameAckParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ScreencastFrameAckParamsBuilder {
+            session_id: Option<i64>,
+        }
+        impl ScreencastFrameAckParamsBuilder {
+            pub fn session_id(mut self, session_id: impl Into<i64>) -> Self {
+                self.session_id = Some(session_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ScreencastFrameAckParams, String> {
+                Ok(ScreencastFrameAckParams {
+                    session_id: self.session_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(session_id))
+                    })?,
+                })
+            }
+        }
+        impl ScreencastFrameAckParams {
+            pub const IDENTIFIER: &'static str = "Page.screencastFrameAck";
+        }
+        impl chromiumoxide_types::Method for ScreencastFrameAckParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ScreencastFrameAckParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Acknowledges that a screencast frame has been received by the frontend.\n[screencastFrameAck](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-screencastFrameAck)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ScreencastFrameAckReturns {}
+        impl chromiumoxide_types::Command for ScreencastFrameAckParams {
+            type Response = ScreencastFrameAckReturns;
+        }
+        #[doc = "Searches for given string in resource content.\n[searchInResource](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-searchInResource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SearchInResourceParams {
+            #[doc = "Frame id for resource to search in."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "URL of the resource to search in."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "String to search for."]
+            #[serde(rename = "query")]
+            pub query: String,
+            #[doc = "If true, search is case sensitive."]
+            #[serde(rename = "caseSensitive")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub case_sensitive: Option<bool>,
+            #[doc = "If true, treats string parameter as regex."]
+            #[serde(rename = "isRegex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_regex: Option<bool>,
+        }
+        impl SearchInResourceParams {
+            pub fn new(
+                frame_id: impl Into<FrameId>,
+                url: impl Into<String>,
+                query: impl Into<String>,
+            ) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                    url: url.into(),
+                    query: query.into(),
+                    case_sensitive: None,
+                    is_regex: None,
+                }
+            }
+        }
+        impl SearchInResourceParams {
+            pub fn builder() -> SearchInResourceParamsBuilder {
+                SearchInResourceParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SearchInResourceParamsBuilder {
+            frame_id: Option<FrameId>,
+            url: Option<String>,
+            query: Option<String>,
+            case_sensitive: Option<bool>,
+            is_regex: Option<bool>,
+        }
+        impl SearchInResourceParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn query(mut self, query: impl Into<String>) -> Self {
+                self.query = Some(query.into());
+                self
+            }
+            pub fn case_sensitive(mut self, case_sensitive: impl Into<bool>) -> Self {
+                self.case_sensitive = Some(case_sensitive.into());
+                self
+            }
+            pub fn is_regex(mut self, is_regex: impl Into<bool>) -> Self {
+                self.is_regex = Some(is_regex.into());
+                self
+            }
+            pub fn build(self) -> Result<SearchInResourceParams, String> {
+                Ok(SearchInResourceParams {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    query: self.query.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(query))
+                    })?,
+                    case_sensitive: self.case_sensitive,
+                    is_regex: self.is_regex,
+                })
+            }
+        }
+        impl SearchInResourceParams {
+            pub const IDENTIFIER: &'static str = "Page.searchInResource";
+        }
+        impl chromiumoxide_types::Method for SearchInResourceParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SearchInResourceParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Searches for given string in resource content.\n[searchInResource](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-searchInResource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SearchInResourceReturns {
+            #[doc = "List of search matches."]
+            #[serde(rename = "result")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub result: Vec<super::super::js_protocol::debugger::SearchMatch>,
+        }
+        impl SearchInResourceReturns {
+            pub fn new(result: Vec<super::super::js_protocol::debugger::SearchMatch>) -> Self {
+                Self { result }
+            }
+        }
+        impl SearchInResourceReturns {
+            pub fn builder() -> SearchInResourceReturnsBuilder {
+                SearchInResourceReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SearchInResourceReturnsBuilder {
+            result: Option<Vec<super::super::js_protocol::debugger::SearchMatch>>,
+        }
+        impl SearchInResourceReturnsBuilder {
+            pub fn result(
+                mut self,
+                result: impl Into<super::super::js_protocol::debugger::SearchMatch>,
+            ) -> Self {
+                let v = self.result.get_or_insert(Vec::new());
+                v.push(result.into());
+                self
+            }
+            pub fn results<I, S>(mut self, results: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::super::js_protocol::debugger::SearchMatch>,
+            {
+                let v = self.result.get_or_insert(Vec::new());
+                for val in results {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SearchInResourceReturns, String> {
+                Ok(SearchInResourceReturns {
+                    result: self.result.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(result))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SearchInResourceParams {
+            type Response = SearchInResourceReturns;
+        }
+        #[doc = "Enable Chrome's experimental ad filter on all sites.\n[setAdBlockingEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setAdBlockingEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAdBlockingEnabledParams {
+            #[doc = "Whether to block ads."]
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetAdBlockingEnabledParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetAdBlockingEnabledParams {
+            pub fn builder() -> SetAdBlockingEnabledParamsBuilder {
+                SetAdBlockingEnabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAdBlockingEnabledParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetAdBlockingEnabledParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAdBlockingEnabledParams, String> {
+                Ok(SetAdBlockingEnabledParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetAdBlockingEnabledParams {
+            pub const IDENTIFIER: &'static str = "Page.setAdBlockingEnabled";
+        }
+        impl chromiumoxide_types::Method for SetAdBlockingEnabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAdBlockingEnabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enable Chrome's experimental ad filter on all sites.\n[setAdBlockingEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setAdBlockingEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAdBlockingEnabledReturns {}
+        impl chromiumoxide_types::Command for SetAdBlockingEnabledParams {
+            type Response = SetAdBlockingEnabledReturns;
+        }
+        #[doc = "Enable page Content Security Policy by-passing.\n[setBypassCSP](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setBypassCSP)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetBypassCspParams {
+            #[doc = "Whether to bypass page CSP."]
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetBypassCspParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetBypassCspParams {
+            pub fn builder() -> SetBypassCspParamsBuilder {
+                SetBypassCspParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetBypassCspParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetBypassCspParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetBypassCspParams, String> {
+                Ok(SetBypassCspParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetBypassCspParams {
+            pub const IDENTIFIER: &'static str = "Page.setBypassCSP";
+        }
+        impl chromiumoxide_types::Method for SetBypassCspParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetBypassCspParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enable page Content Security Policy by-passing.\n[setBypassCSP](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setBypassCSP)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetBypassCspReturns {}
+        impl chromiumoxide_types::Command for SetBypassCspParams {
+            type Response = SetBypassCspReturns;
+        }
+        #[doc = "Get Permissions Policy state on given frame.\n[getPermissionsPolicyState](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getPermissionsPolicyState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetPermissionsPolicyStateParams {
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+        }
+        impl GetPermissionsPolicyStateParams {
+            pub fn new(frame_id: impl Into<FrameId>) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                }
+            }
+        }
+        impl GetPermissionsPolicyStateParams {
+            pub fn builder() -> GetPermissionsPolicyStateParamsBuilder {
+                GetPermissionsPolicyStateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPermissionsPolicyStateParamsBuilder {
+            frame_id: Option<FrameId>,
+        }
+        impl GetPermissionsPolicyStateParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetPermissionsPolicyStateParams, String> {
+                Ok(GetPermissionsPolicyStateParams {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                })
+            }
+        }
+        impl GetPermissionsPolicyStateParams {
+            pub const IDENTIFIER: &'static str = "Page.getPermissionsPolicyState";
+        }
+        impl chromiumoxide_types::Method for GetPermissionsPolicyStateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetPermissionsPolicyStateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Get Permissions Policy state on given frame.\n[getPermissionsPolicyState](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getPermissionsPolicyState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetPermissionsPolicyStateReturns {
+            #[serde(rename = "states")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub states: Vec<PermissionsPolicyFeatureState>,
+        }
+        impl GetPermissionsPolicyStateReturns {
+            pub fn new(states: Vec<PermissionsPolicyFeatureState>) -> Self {
+                Self { states }
+            }
+        }
+        impl GetPermissionsPolicyStateReturns {
+            pub fn builder() -> GetPermissionsPolicyStateReturnsBuilder {
+                GetPermissionsPolicyStateReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetPermissionsPolicyStateReturnsBuilder {
+            states: Option<Vec<PermissionsPolicyFeatureState>>,
+        }
+        impl GetPermissionsPolicyStateReturnsBuilder {
+            pub fn state(mut self, state: impl Into<PermissionsPolicyFeatureState>) -> Self {
+                let v = self.states.get_or_insert(Vec::new());
+                v.push(state.into());
+                self
+            }
+            pub fn states<I, S>(mut self, states: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<PermissionsPolicyFeatureState>,
+            {
+                let v = self.states.get_or_insert(Vec::new());
+                for val in states {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetPermissionsPolicyStateReturns, String> {
+                Ok(GetPermissionsPolicyStateReturns {
+                    states: self.states.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(states))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetPermissionsPolicyStateParams {
+            type Response = GetPermissionsPolicyStateReturns;
+        }
+        #[doc = "Get Origin Trials on given frame.\n[getOriginTrials](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getOriginTrials)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetOriginTrialsParams {
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+        }
+        impl GetOriginTrialsParams {
+            pub fn new(frame_id: impl Into<FrameId>) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                }
+            }
+        }
+        impl GetOriginTrialsParams {
+            pub fn builder() -> GetOriginTrialsParamsBuilder {
+                GetOriginTrialsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetOriginTrialsParamsBuilder {
+            frame_id: Option<FrameId>,
+        }
+        impl GetOriginTrialsParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetOriginTrialsParams, String> {
+                Ok(GetOriginTrialsParams {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                })
+            }
+        }
+        impl GetOriginTrialsParams {
+            pub const IDENTIFIER: &'static str = "Page.getOriginTrials";
+        }
+        impl chromiumoxide_types::Method for GetOriginTrialsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetOriginTrialsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Get Origin Trials on given frame.\n[getOriginTrials](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getOriginTrials)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetOriginTrialsReturns {
+            #[serde(rename = "originTrials")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub origin_trials: Vec<OriginTrial>,
+        }
+        impl GetOriginTrialsReturns {
+            pub fn new(origin_trials: Vec<OriginTrial>) -> Self {
+                Self { origin_trials }
+            }
+        }
+        impl GetOriginTrialsReturns {
+            pub fn builder() -> GetOriginTrialsReturnsBuilder {
+                GetOriginTrialsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetOriginTrialsReturnsBuilder {
+            origin_trials: Option<Vec<OriginTrial>>,
+        }
+        impl GetOriginTrialsReturnsBuilder {
+            pub fn origin_trial(mut self, origin_trial: impl Into<OriginTrial>) -> Self {
+                let v = self.origin_trials.get_or_insert(Vec::new());
+                v.push(origin_trial.into());
+                self
+            }
+            pub fn origin_trials<I, S>(mut self, origin_trials: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<OriginTrial>,
+            {
+                let v = self.origin_trials.get_or_insert(Vec::new());
+                for val in origin_trials {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetOriginTrialsReturns, String> {
+                Ok(GetOriginTrialsReturns {
+                    origin_trials: self.origin_trials.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin_trials))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetOriginTrialsParams {
+            type Response = GetOriginTrialsReturns;
+        }
+        #[doc = "Set generic font families.\n[setFontFamilies](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setFontFamilies)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetFontFamiliesParams {
+            #[doc = "Specifies font families to set. If a font family is not specified, it won't be changed."]
+            #[serde(rename = "fontFamilies")]
+            pub font_families: FontFamilies,
+            #[doc = "Specifies font families to set for individual scripts."]
+            #[serde(rename = "forScripts")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub for_scripts: Option<Vec<ScriptFontFamilies>>,
+        }
+        impl SetFontFamiliesParams {
+            pub fn new(font_families: impl Into<FontFamilies>) -> Self {
+                Self {
+                    font_families: font_families.into(),
+                    for_scripts: None,
+                }
+            }
+        }
+        impl SetFontFamiliesParams {
+            pub fn builder() -> SetFontFamiliesParamsBuilder {
+                SetFontFamiliesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetFontFamiliesParamsBuilder {
+            font_families: Option<FontFamilies>,
+            for_scripts: Option<Vec<ScriptFontFamilies>>,
+        }
+        impl SetFontFamiliesParamsBuilder {
+            pub fn font_families(mut self, font_families: impl Into<FontFamilies>) -> Self {
+                self.font_families = Some(font_families.into());
+                self
+            }
+            pub fn for_script(mut self, for_script: impl Into<ScriptFontFamilies>) -> Self {
+                let v = self.for_scripts.get_or_insert(Vec::new());
+                v.push(for_script.into());
+                self
+            }
+            pub fn for_scripts<I, S>(mut self, for_scripts: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ScriptFontFamilies>,
+            {
+                let v = self.for_scripts.get_or_insert(Vec::new());
+                for val in for_scripts {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetFontFamiliesParams, String> {
+                Ok(SetFontFamiliesParams {
+                    font_families: self.font_families.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_families))
+                    })?,
+                    for_scripts: self.for_scripts,
+                })
+            }
+        }
+        impl SetFontFamiliesParams {
+            pub const IDENTIFIER: &'static str = "Page.setFontFamilies";
+        }
+        impl chromiumoxide_types::Method for SetFontFamiliesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetFontFamiliesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set generic font families.\n[setFontFamilies](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setFontFamilies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetFontFamiliesReturns {}
+        impl chromiumoxide_types::Command for SetFontFamiliesParams {
+            type Response = SetFontFamiliesReturns;
+        }
+        #[doc = "Set default font sizes.\n[setFontSizes](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setFontSizes)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetFontSizesParams {
+            #[doc = "Specifies font sizes to set. If a font size is not specified, it won't be changed."]
+            #[serde(rename = "fontSizes")]
+            pub font_sizes: FontSizes,
+        }
+        impl SetFontSizesParams {
+            pub fn new(font_sizes: impl Into<FontSizes>) -> Self {
+                Self {
+                    font_sizes: font_sizes.into(),
+                }
+            }
+        }
+        impl SetFontSizesParams {
+            pub fn builder() -> SetFontSizesParamsBuilder {
+                SetFontSizesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetFontSizesParamsBuilder {
+            font_sizes: Option<FontSizes>,
+        }
+        impl SetFontSizesParamsBuilder {
+            pub fn font_sizes(mut self, font_sizes: impl Into<FontSizes>) -> Self {
+                self.font_sizes = Some(font_sizes.into());
+                self
+            }
+            pub fn build(self) -> Result<SetFontSizesParams, String> {
+                Ok(SetFontSizesParams {
+                    font_sizes: self.font_sizes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(font_sizes))
+                    })?,
+                })
+            }
+        }
+        impl SetFontSizesParams {
+            pub const IDENTIFIER: &'static str = "Page.setFontSizes";
+        }
+        impl chromiumoxide_types::Method for SetFontSizesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetFontSizesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set default font sizes.\n[setFontSizes](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setFontSizes)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetFontSizesReturns {}
+        impl chromiumoxide_types::Command for SetFontSizesParams {
+            type Response = SetFontSizesReturns;
+        }
+        #[doc = "Sets given markup as the document's HTML.\n[setDocumentContent](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setDocumentContent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDocumentContentParams {
+            #[doc = "Frame id to set HTML for."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "HTML content to set."]
+            #[serde(rename = "html")]
+            pub html: String,
+        }
+        impl SetDocumentContentParams {
+            pub fn new(frame_id: impl Into<FrameId>, html: impl Into<String>) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                    html: html.into(),
+                }
+            }
+        }
+        impl SetDocumentContentParams {
+            pub fn builder() -> SetDocumentContentParamsBuilder {
+                SetDocumentContentParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDocumentContentParamsBuilder {
+            frame_id: Option<FrameId>,
+            html: Option<String>,
+        }
+        impl SetDocumentContentParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn html(mut self, html: impl Into<String>) -> Self {
+                self.html = Some(html.into());
+                self
+            }
+            pub fn build(self) -> Result<SetDocumentContentParams, String> {
+                Ok(SetDocumentContentParams {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    html: self.html.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(html))
+                    })?,
+                })
+            }
+        }
+        impl SetDocumentContentParams {
+            pub const IDENTIFIER: &'static str = "Page.setDocumentContent";
+        }
+        impl chromiumoxide_types::Method for SetDocumentContentParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDocumentContentParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets given markup as the document's HTML.\n[setDocumentContent](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setDocumentContent)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDocumentContentReturns {}
+        impl chromiumoxide_types::Command for SetDocumentContentParams {
+            type Response = SetDocumentContentReturns;
+        }
+        #[doc = "Controls whether page will emit lifecycle events.\n[setLifecycleEventsEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setLifecycleEventsEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetLifecycleEventsEnabledParams {
+            #[doc = "If true, starts emitting lifecycle events."]
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetLifecycleEventsEnabledParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetLifecycleEventsEnabledParams {
+            pub fn builder() -> SetLifecycleEventsEnabledParamsBuilder {
+                SetLifecycleEventsEnabledParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetLifecycleEventsEnabledParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetLifecycleEventsEnabledParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetLifecycleEventsEnabledParams, String> {
+                Ok(SetLifecycleEventsEnabledParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetLifecycleEventsEnabledParams {
+            pub const IDENTIFIER: &'static str = "Page.setLifecycleEventsEnabled";
+        }
+        impl chromiumoxide_types::Method for SetLifecycleEventsEnabledParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetLifecycleEventsEnabledParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Controls whether page will emit lifecycle events.\n[setLifecycleEventsEnabled](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setLifecycleEventsEnabled)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetLifecycleEventsEnabledReturns {}
+        impl chromiumoxide_types::Command for SetLifecycleEventsEnabledParams {
+            type Response = SetLifecycleEventsEnabledReturns;
+        }
+        #[doc = "Starts sending each frame using the `screencastFrame` event.\n[startScreencast](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-startScreencast)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartScreencastParams {
+            #[doc = "Image compression format."]
+            #[serde(rename = "format")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub format: Option<StartScreencastFormat>,
+            #[doc = "Compression quality from range [0..100]."]
+            #[serde(rename = "quality")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub quality: Option<i64>,
+            #[doc = "Maximum screenshot width."]
+            #[serde(rename = "maxWidth")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_width: Option<i64>,
+            #[doc = "Maximum screenshot height."]
+            #[serde(rename = "maxHeight")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_height: Option<i64>,
+            #[doc = "Send every n-th frame."]
+            #[serde(rename = "everyNthFrame")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub every_nth_frame: Option<i64>,
+        }
+        #[doc = "Image compression format."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum StartScreencastFormat {
+            #[serde(rename = "jpeg")]
+            Jpeg,
+            #[serde(rename = "png")]
+            Png,
+        }
+        impl AsRef<str> for StartScreencastFormat {
+            fn as_ref(&self) -> &str {
+                match self {
+                    StartScreencastFormat::Jpeg => "jpeg",
+                    StartScreencastFormat::Png => "png",
+                }
+            }
+        }
+        impl ::std::str::FromStr for StartScreencastFormat {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "jpeg" | "Jpeg" => Ok(StartScreencastFormat::Jpeg),
+                    "png" | "Png" => Ok(StartScreencastFormat::Png),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl StartScreencastParams {
+            pub fn builder() -> StartScreencastParamsBuilder {
+                StartScreencastParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartScreencastParamsBuilder {
+            format: Option<StartScreencastFormat>,
+            quality: Option<i64>,
+            max_width: Option<i64>,
+            max_height: Option<i64>,
+            every_nth_frame: Option<i64>,
+        }
+        impl StartScreencastParamsBuilder {
+            pub fn format(mut self, format: impl Into<StartScreencastFormat>) -> Self {
+                self.format = Some(format.into());
+                self
+            }
+            pub fn quality(mut self, quality: impl Into<i64>) -> Self {
+                self.quality = Some(quality.into());
+                self
+            }
+            pub fn max_width(mut self, max_width: impl Into<i64>) -> Self {
+                self.max_width = Some(max_width.into());
+                self
+            }
+            pub fn max_height(mut self, max_height: impl Into<i64>) -> Self {
+                self.max_height = Some(max_height.into());
+                self
+            }
+            pub fn every_nth_frame(mut self, every_nth_frame: impl Into<i64>) -> Self {
+                self.every_nth_frame = Some(every_nth_frame.into());
+                self
+            }
+            pub fn build(self) -> StartScreencastParams {
+                StartScreencastParams {
+                    format: self.format,
+                    quality: self.quality,
+                    max_width: self.max_width,
+                    max_height: self.max_height,
+                    every_nth_frame: self.every_nth_frame,
+                }
+            }
+        }
+        impl StartScreencastParams {
+            pub const IDENTIFIER: &'static str = "Page.startScreencast";
+        }
+        impl chromiumoxide_types::Method for StartScreencastParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartScreencastParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Starts sending each frame using the `screencastFrame` event.\n[startScreencast](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-startScreencast)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartScreencastReturns {}
+        impl chromiumoxide_types::Command for StartScreencastParams {
+            type Response = StartScreencastReturns;
+        }
+        #[doc = "Force the page stop all navigations and pending resource fetches.\n[stopLoading](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-stopLoading)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopLoadingParams {}
+        impl StopLoadingParams {
+            pub const IDENTIFIER: &'static str = "Page.stopLoading";
+        }
+        impl chromiumoxide_types::Method for StopLoadingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopLoadingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Force the page stop all navigations and pending resource fetches.\n[stopLoading](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-stopLoading)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopLoadingReturns {}
+        impl chromiumoxide_types::Command for StopLoadingParams {
+            type Response = StopLoadingReturns;
+        }
+        #[doc = "Crashes renderer on the IO thread, generates minidumps.\n[crash](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-crash)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CrashParams {}
+        impl CrashParams {
+            pub const IDENTIFIER: &'static str = "Page.crash";
+        }
+        impl chromiumoxide_types::Method for CrashParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CrashParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Crashes renderer on the IO thread, generates minidumps.\n[crash](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-crash)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CrashReturns {}
+        impl chromiumoxide_types::Command for CrashParams {
+            type Response = CrashReturns;
+        }
+        #[doc = "Tries to close page, running its beforeunload hooks, if any.\n[close](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-close)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CloseParams {}
+        impl CloseParams {
+            pub const IDENTIFIER: &'static str = "Page.close";
+        }
+        impl chromiumoxide_types::Method for CloseParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CloseParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Tries to close page, running its beforeunload hooks, if any.\n[close](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-close)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CloseReturns {}
+        impl chromiumoxide_types::Command for CloseParams {
+            type Response = CloseReturns;
+        }
+        #[doc = "Tries to update the web lifecycle state of the page.\nIt will transition the page to the given state according to:\nhttps://github.com/WICG/web-lifecycle/\n[setWebLifecycleState](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setWebLifecycleState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetWebLifecycleStateParams {
+            #[doc = "Target lifecycle state"]
+            #[serde(rename = "state")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub state: SetWebLifecycleStateState,
+        }
+        #[doc = "Target lifecycle state"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SetWebLifecycleStateState {
+            #[serde(rename = "frozen")]
+            Frozen,
+            #[serde(rename = "active")]
+            Active,
+        }
+        impl AsRef<str> for SetWebLifecycleStateState {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SetWebLifecycleStateState::Frozen => "frozen",
+                    SetWebLifecycleStateState::Active => "active",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SetWebLifecycleStateState {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "frozen" | "Frozen" => Ok(SetWebLifecycleStateState::Frozen),
+                    "active" | "Active" => Ok(SetWebLifecycleStateState::Active),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl SetWebLifecycleStateParams {
+            pub fn new(state: impl Into<SetWebLifecycleStateState>) -> Self {
+                Self {
+                    state: state.into(),
+                }
+            }
+        }
+        impl SetWebLifecycleStateParams {
+            pub fn builder() -> SetWebLifecycleStateParamsBuilder {
+                SetWebLifecycleStateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetWebLifecycleStateParamsBuilder {
+            state: Option<SetWebLifecycleStateState>,
+        }
+        impl SetWebLifecycleStateParamsBuilder {
+            pub fn state(mut self, state: impl Into<SetWebLifecycleStateState>) -> Self {
+                self.state = Some(state.into());
+                self
+            }
+            pub fn build(self) -> Result<SetWebLifecycleStateParams, String> {
+                Ok(SetWebLifecycleStateParams {
+                    state: self.state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(state))
+                    })?,
+                })
+            }
+        }
+        impl SetWebLifecycleStateParams {
+            pub const IDENTIFIER: &'static str = "Page.setWebLifecycleState";
+        }
+        impl chromiumoxide_types::Method for SetWebLifecycleStateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetWebLifecycleStateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Tries to update the web lifecycle state of the page.\nIt will transition the page to the given state according to:\nhttps://github.com/WICG/web-lifecycle/\n[setWebLifecycleState](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setWebLifecycleState)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetWebLifecycleStateReturns {}
+        impl chromiumoxide_types::Command for SetWebLifecycleStateParams {
+            type Response = SetWebLifecycleStateReturns;
+        }
+        #[doc = "Stops sending each frame in the `screencastFrame`.\n[stopScreencast](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-stopScreencast)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopScreencastParams {}
+        impl StopScreencastParams {
+            pub const IDENTIFIER: &'static str = "Page.stopScreencast";
+        }
+        impl chromiumoxide_types::Method for StopScreencastParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopScreencastParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Stops sending each frame in the `screencastFrame`.\n[stopScreencast](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-stopScreencast)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopScreencastReturns {}
+        impl chromiumoxide_types::Command for StopScreencastParams {
+            type Response = StopScreencastReturns;
+        }
+        #[doc = "Requests backend to produce compilation cache for the specified scripts.\n`scripts` are appended to the list of scripts for which the cache\nwould be produced. The list may be reset during page navigation.\nWhen script with a matching URL is encountered, the cache is optionally\nproduced upon backend discretion, based on internal heuristics.\nSee also: `Page.compilationCacheProduced`.\n[produceCompilationCache](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-produceCompilationCache)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ProduceCompilationCacheParams {
+            #[serde(rename = "scripts")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub scripts: Vec<CompilationCacheParams>,
+        }
+        impl ProduceCompilationCacheParams {
+            pub fn new(scripts: Vec<CompilationCacheParams>) -> Self {
+                Self { scripts }
+            }
+        }
+        impl ProduceCompilationCacheParams {
+            pub fn builder() -> ProduceCompilationCacheParamsBuilder {
+                ProduceCompilationCacheParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ProduceCompilationCacheParamsBuilder {
+            scripts: Option<Vec<CompilationCacheParams>>,
+        }
+        impl ProduceCompilationCacheParamsBuilder {
+            pub fn script(mut self, script: impl Into<CompilationCacheParams>) -> Self {
+                let v = self.scripts.get_or_insert(Vec::new());
+                v.push(script.into());
+                self
+            }
+            pub fn scripts<I, S>(mut self, scripts: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<CompilationCacheParams>,
+            {
+                let v = self.scripts.get_or_insert(Vec::new());
+                for val in scripts {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<ProduceCompilationCacheParams, String> {
+                Ok(ProduceCompilationCacheParams {
+                    scripts: self.scripts.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scripts))
+                    })?,
+                })
+            }
+        }
+        impl ProduceCompilationCacheParams {
+            pub const IDENTIFIER: &'static str = "Page.produceCompilationCache";
+        }
+        impl chromiumoxide_types::Method for ProduceCompilationCacheParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ProduceCompilationCacheParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Requests backend to produce compilation cache for the specified scripts.\n`scripts` are appended to the list of scripts for which the cache\nwould be produced. The list may be reset during page navigation.\nWhen script with a matching URL is encountered, the cache is optionally\nproduced upon backend discretion, based on internal heuristics.\nSee also: `Page.compilationCacheProduced`.\n[produceCompilationCache](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-produceCompilationCache)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ProduceCompilationCacheReturns {}
+        impl chromiumoxide_types::Command for ProduceCompilationCacheParams {
+            type Response = ProduceCompilationCacheReturns;
+        }
+        #[doc = "Seeds compilation cache for given url. Compilation cache does not survive\ncross-process navigation.\n[addCompilationCache](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-addCompilationCache)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddCompilationCacheParams {
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Base64-encoded data"]
+            #[serde(rename = "data")]
+            pub data: chromiumoxide_types::Binary,
+        }
+        impl AddCompilationCacheParams {
+            pub fn new(
+                url: impl Into<String>,
+                data: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                Self {
+                    url: url.into(),
+                    data: data.into(),
+                }
+            }
+        }
+        impl AddCompilationCacheParams {
+            pub fn builder() -> AddCompilationCacheParamsBuilder {
+                AddCompilationCacheParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddCompilationCacheParamsBuilder {
+            url: Option<String>,
+            data: Option<chromiumoxide_types::Binary>,
+        }
+        impl AddCompilationCacheParamsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn data(mut self, data: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn build(self) -> Result<AddCompilationCacheParams, String> {
+                Ok(AddCompilationCacheParams {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                })
+            }
+        }
+        impl AddCompilationCacheParams {
+            pub const IDENTIFIER: &'static str = "Page.addCompilationCache";
+        }
+        impl chromiumoxide_types::Method for AddCompilationCacheParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddCompilationCacheParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Seeds compilation cache for given url. Compilation cache does not survive\ncross-process navigation.\n[addCompilationCache](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-addCompilationCache)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct AddCompilationCacheReturns {}
+        impl chromiumoxide_types::Command for AddCompilationCacheParams {
+            type Response = AddCompilationCacheReturns;
+        }
+        #[doc = "Clears seeded compilation cache.\n[clearCompilationCache](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-clearCompilationCache)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearCompilationCacheParams {}
+        impl ClearCompilationCacheParams {
+            pub const IDENTIFIER: &'static str = "Page.clearCompilationCache";
+        }
+        impl chromiumoxide_types::Method for ClearCompilationCacheParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearCompilationCacheParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears seeded compilation cache.\n[clearCompilationCache](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-clearCompilationCache)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearCompilationCacheReturns {}
+        impl chromiumoxide_types::Command for ClearCompilationCacheParams {
+            type Response = ClearCompilationCacheReturns;
+        }
+        #[doc = "Sets the Secure Payment Confirmation transaction mode.\nhttps://w3c.github.io/secure-payment-confirmation/#sctn-automation-set-spc-transaction-mode\n[setSPCTransactionMode](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setSPCTransactionMode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSpcTransactionModeParams {
+            #[serde(rename = "mode")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub mode: SetSpcTransactionModeMode,
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SetSpcTransactionModeMode {
+            #[serde(rename = "none")]
+            None,
+            #[serde(rename = "autoAccept")]
+            AutoAccept,
+            #[serde(rename = "autoChooseToAuthAnotherWay")]
+            AutoChooseToAuthAnotherWay,
+            #[serde(rename = "autoReject")]
+            AutoReject,
+            #[serde(rename = "autoOptOut")]
+            AutoOptOut,
+        }
+        impl AsRef<str> for SetSpcTransactionModeMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SetSpcTransactionModeMode::None => "none",
+                    SetSpcTransactionModeMode::AutoAccept => "autoAccept",
+                    SetSpcTransactionModeMode::AutoChooseToAuthAnotherWay => {
+                        "autoChooseToAuthAnotherWay"
+                    }
+                    SetSpcTransactionModeMode::AutoReject => "autoReject",
+                    SetSpcTransactionModeMode::AutoOptOut => "autoOptOut",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SetSpcTransactionModeMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "none" | "None" => Ok(SetSpcTransactionModeMode::None),
+                    "autoAccept" | "AutoAccept" | "autoaccept" => {
+                        Ok(SetSpcTransactionModeMode::AutoAccept)
+                    }
+                    "autoChooseToAuthAnotherWay"
+                    | "AutoChooseToAuthAnotherWay"
+                    | "autochoosetoauthanotherway" => {
+                        Ok(SetSpcTransactionModeMode::AutoChooseToAuthAnotherWay)
+                    }
+                    "autoReject" | "AutoReject" | "autoreject" => {
+                        Ok(SetSpcTransactionModeMode::AutoReject)
+                    }
+                    "autoOptOut" | "AutoOptOut" | "autooptout" => {
+                        Ok(SetSpcTransactionModeMode::AutoOptOut)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl SetSpcTransactionModeParams {
+            pub fn new(mode: impl Into<SetSpcTransactionModeMode>) -> Self {
+                Self { mode: mode.into() }
+            }
+        }
+        impl SetSpcTransactionModeParams {
+            pub fn builder() -> SetSpcTransactionModeParamsBuilder {
+                SetSpcTransactionModeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSpcTransactionModeParamsBuilder {
+            mode: Option<SetSpcTransactionModeMode>,
+        }
+        impl SetSpcTransactionModeParamsBuilder {
+            pub fn mode(mut self, mode: impl Into<SetSpcTransactionModeMode>) -> Self {
+                self.mode = Some(mode.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSpcTransactionModeParams, String> {
+                Ok(SetSpcTransactionModeParams {
+                    mode: self.mode.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mode))
+                    })?,
+                })
+            }
+        }
+        impl SetSpcTransactionModeParams {
+            pub const IDENTIFIER: &'static str = "Page.setSPCTransactionMode";
+        }
+        impl chromiumoxide_types::Method for SetSpcTransactionModeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSpcTransactionModeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets the Secure Payment Confirmation transaction mode.\nhttps://w3c.github.io/secure-payment-confirmation/#sctn-automation-set-spc-transaction-mode\n[setSPCTransactionMode](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setSPCTransactionMode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSpcTransactionModeReturns {}
+        impl chromiumoxide_types::Command for SetSpcTransactionModeParams {
+            type Response = SetSpcTransactionModeReturns;
+        }
+        #[doc = "Extensions for Custom Handlers API:\nhttps://html.spec.whatwg.org/multipage/system-state.html#rph-automation\n[setRPHRegistrationMode](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setRPHRegistrationMode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetRphRegistrationModeParams {
+            #[serde(rename = "mode")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub mode: SetRphRegistrationModeMode,
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SetRphRegistrationModeMode {
+            #[serde(rename = "none")]
+            None,
+            #[serde(rename = "autoAccept")]
+            AutoAccept,
+            #[serde(rename = "autoReject")]
+            AutoReject,
+        }
+        impl AsRef<str> for SetRphRegistrationModeMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SetRphRegistrationModeMode::None => "none",
+                    SetRphRegistrationModeMode::AutoAccept => "autoAccept",
+                    SetRphRegistrationModeMode::AutoReject => "autoReject",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SetRphRegistrationModeMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "none" | "None" => Ok(SetRphRegistrationModeMode::None),
+                    "autoAccept" | "AutoAccept" | "autoaccept" => {
+                        Ok(SetRphRegistrationModeMode::AutoAccept)
+                    }
+                    "autoReject" | "AutoReject" | "autoreject" => {
+                        Ok(SetRphRegistrationModeMode::AutoReject)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl SetRphRegistrationModeParams {
+            pub fn new(mode: impl Into<SetRphRegistrationModeMode>) -> Self {
+                Self { mode: mode.into() }
+            }
+        }
+        impl SetRphRegistrationModeParams {
+            pub fn builder() -> SetRphRegistrationModeParamsBuilder {
+                SetRphRegistrationModeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetRphRegistrationModeParamsBuilder {
+            mode: Option<SetRphRegistrationModeMode>,
+        }
+        impl SetRphRegistrationModeParamsBuilder {
+            pub fn mode(mut self, mode: impl Into<SetRphRegistrationModeMode>) -> Self {
+                self.mode = Some(mode.into());
+                self
+            }
+            pub fn build(self) -> Result<SetRphRegistrationModeParams, String> {
+                Ok(SetRphRegistrationModeParams {
+                    mode: self.mode.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(mode))
+                    })?,
+                })
+            }
+        }
+        impl SetRphRegistrationModeParams {
+            pub const IDENTIFIER: &'static str = "Page.setRPHRegistrationMode";
+        }
+        impl chromiumoxide_types::Method for SetRphRegistrationModeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetRphRegistrationModeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Extensions for Custom Handlers API:\nhttps://html.spec.whatwg.org/multipage/system-state.html#rph-automation\n[setRPHRegistrationMode](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setRPHRegistrationMode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetRphRegistrationModeReturns {}
+        impl chromiumoxide_types::Command for SetRphRegistrationModeParams {
+            type Response = SetRphRegistrationModeReturns;
+        }
+        #[doc = "Generates a report for testing.\n[generateTestReport](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-generateTestReport)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GenerateTestReportParams {
+            #[doc = "Message to be displayed in the report."]
+            #[serde(rename = "message")]
+            pub message: String,
+            #[doc = "Specifies the endpoint group to deliver the report to."]
+            #[serde(rename = "group")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub group: Option<String>,
+        }
+        impl GenerateTestReportParams {
+            pub fn new(message: impl Into<String>) -> Self {
+                Self {
+                    message: message.into(),
+                    group: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GenerateTestReportParams {
+            fn from(url: T) -> Self {
+                GenerateTestReportParams::new(url)
+            }
+        }
+        impl GenerateTestReportParams {
+            pub fn builder() -> GenerateTestReportParamsBuilder {
+                GenerateTestReportParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GenerateTestReportParamsBuilder {
+            message: Option<String>,
+            group: Option<String>,
+        }
+        impl GenerateTestReportParamsBuilder {
+            pub fn message(mut self, message: impl Into<String>) -> Self {
+                self.message = Some(message.into());
+                self
+            }
+            pub fn group(mut self, group: impl Into<String>) -> Self {
+                self.group = Some(group.into());
+                self
+            }
+            pub fn build(self) -> Result<GenerateTestReportParams, String> {
+                Ok(GenerateTestReportParams {
+                    message: self.message.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(message))
+                    })?,
+                    group: self.group,
+                })
+            }
+        }
+        impl GenerateTestReportParams {
+            pub const IDENTIFIER: &'static str = "Page.generateTestReport";
+        }
+        impl chromiumoxide_types::Method for GenerateTestReportParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GenerateTestReportParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Generates a report for testing.\n[generateTestReport](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-generateTestReport)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GenerateTestReportReturns {}
+        impl chromiumoxide_types::Command for GenerateTestReportParams {
+            type Response = GenerateTestReportReturns;
+        }
+        #[doc = "Pauses page execution. Can be resumed using generic Runtime.runIfWaitingForDebugger.\n[waitForDebugger](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-waitForDebugger)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct WaitForDebuggerParams {}
+        impl WaitForDebuggerParams {
+            pub const IDENTIFIER: &'static str = "Page.waitForDebugger";
+        }
+        impl chromiumoxide_types::Method for WaitForDebuggerParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for WaitForDebuggerParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Pauses page execution. Can be resumed using generic Runtime.runIfWaitingForDebugger.\n[waitForDebugger](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-waitForDebugger)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct WaitForDebuggerReturns {}
+        impl chromiumoxide_types::Command for WaitForDebuggerParams {
+            type Response = WaitForDebuggerReturns;
+        }
+        #[doc = "Intercept file chooser requests and transfer control to protocol clients.\nWhen file chooser interception is enabled, native file chooser dialog is not shown.\nInstead, a protocol event `Page.fileChooserOpened` is emitted.\n[setInterceptFileChooserDialog](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setInterceptFileChooserDialog)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetInterceptFileChooserDialogParams {
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+            #[doc = "If true, cancels the dialog by emitting relevant events (if any)\nin addition to not showing it if the interception is enabled\n(default: false)."]
+            #[serde(rename = "cancel")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub cancel: Option<bool>,
+        }
+        impl SetInterceptFileChooserDialogParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                    cancel: None,
+                }
+            }
+        }
+        impl SetInterceptFileChooserDialogParams {
+            pub fn builder() -> SetInterceptFileChooserDialogParamsBuilder {
+                SetInterceptFileChooserDialogParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetInterceptFileChooserDialogParamsBuilder {
+            enabled: Option<bool>,
+            cancel: Option<bool>,
+        }
+        impl SetInterceptFileChooserDialogParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn cancel(mut self, cancel: impl Into<bool>) -> Self {
+                self.cancel = Some(cancel.into());
+                self
+            }
+            pub fn build(self) -> Result<SetInterceptFileChooserDialogParams, String> {
+                Ok(SetInterceptFileChooserDialogParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                    cancel: self.cancel,
+                })
+            }
+        }
+        impl SetInterceptFileChooserDialogParams {
+            pub const IDENTIFIER: &'static str = "Page.setInterceptFileChooserDialog";
+        }
+        impl chromiumoxide_types::Method for SetInterceptFileChooserDialogParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetInterceptFileChooserDialogParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Intercept file chooser requests and transfer control to protocol clients.\nWhen file chooser interception is enabled, native file chooser dialog is not shown.\nInstead, a protocol event `Page.fileChooserOpened` is emitted.\n[setInterceptFileChooserDialog](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setInterceptFileChooserDialog)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetInterceptFileChooserDialogReturns {}
+        impl chromiumoxide_types::Command for SetInterceptFileChooserDialogParams {
+            type Response = SetInterceptFileChooserDialogReturns;
+        }
+        #[doc = "Enable/disable prerendering manually.\n\nThis command is a short-term solution for https://crbug.com/1440085.\nSee https://docs.google.com/document/d/12HVmFxYj5Jc-eJr5OmWsa2bqTJsbgGLKI6ZIyx0_wpA\nfor more details.\n\nTODO(https://crbug.com/1440085): Remove this once Puppeteer supports tab targets.\n[setPrerenderingAllowed](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setPrerenderingAllowed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetPrerenderingAllowedParams {
+            #[serde(rename = "isAllowed")]
+            pub is_allowed: bool,
+        }
+        impl SetPrerenderingAllowedParams {
+            pub fn new(is_allowed: impl Into<bool>) -> Self {
+                Self {
+                    is_allowed: is_allowed.into(),
+                }
+            }
+        }
+        impl SetPrerenderingAllowedParams {
+            pub fn builder() -> SetPrerenderingAllowedParamsBuilder {
+                SetPrerenderingAllowedParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetPrerenderingAllowedParamsBuilder {
+            is_allowed: Option<bool>,
+        }
+        impl SetPrerenderingAllowedParamsBuilder {
+            pub fn is_allowed(mut self, is_allowed: impl Into<bool>) -> Self {
+                self.is_allowed = Some(is_allowed.into());
+                self
+            }
+            pub fn build(self) -> Result<SetPrerenderingAllowedParams, String> {
+                Ok(SetPrerenderingAllowedParams {
+                    is_allowed: self.is_allowed.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_allowed))
+                    })?,
+                })
+            }
+        }
+        impl SetPrerenderingAllowedParams {
+            pub const IDENTIFIER: &'static str = "Page.setPrerenderingAllowed";
+        }
+        impl chromiumoxide_types::Method for SetPrerenderingAllowedParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetPrerenderingAllowedParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enable/disable prerendering manually.\n\nThis command is a short-term solution for https://crbug.com/1440085.\nSee https://docs.google.com/document/d/12HVmFxYj5Jc-eJr5OmWsa2bqTJsbgGLKI6ZIyx0_wpA\nfor more details.\n\nTODO(https://crbug.com/1440085): Remove this once Puppeteer supports tab targets.\n[setPrerenderingAllowed](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-setPrerenderingAllowed)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetPrerenderingAllowedReturns {}
+        impl chromiumoxide_types::Command for SetPrerenderingAllowedParams {
+            type Response = SetPrerenderingAllowedReturns;
+        }
+        #[doc = "Get the annotated page content for the main frame.\nThis is an experimental command that is subject to change.\n[getAnnotatedPageContent](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getAnnotatedPageContent)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetAnnotatedPageContentParams {
+            #[doc = "Whether to include actionable information. Defaults to true."]
+            #[serde(rename = "includeActionableInformation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub include_actionable_information: Option<bool>,
+        }
+        impl GetAnnotatedPageContentParams {
+            pub fn builder() -> GetAnnotatedPageContentParamsBuilder {
+                GetAnnotatedPageContentParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAnnotatedPageContentParamsBuilder {
+            include_actionable_information: Option<bool>,
+        }
+        impl GetAnnotatedPageContentParamsBuilder {
+            pub fn include_actionable_information(
+                mut self,
+                include_actionable_information: impl Into<bool>,
+            ) -> Self {
+                self.include_actionable_information = Some(include_actionable_information.into());
+                self
+            }
+            pub fn build(self) -> GetAnnotatedPageContentParams {
+                GetAnnotatedPageContentParams {
+                    include_actionable_information: self.include_actionable_information,
+                }
+            }
+        }
+        impl GetAnnotatedPageContentParams {
+            pub const IDENTIFIER: &'static str = "Page.getAnnotatedPageContent";
+        }
+        impl chromiumoxide_types::Method for GetAnnotatedPageContentParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetAnnotatedPageContentParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Get the annotated page content for the main frame.\nThis is an experimental command that is subject to change.\n[getAnnotatedPageContent](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-getAnnotatedPageContent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAnnotatedPageContentReturns {
+            #[doc = "The annotated page content as a base64 encoded protobuf.\nThe format is defined by the `AnnotatedPageContent` message in\ncomponents/optimization_guide/proto/features/common_quality_data.proto"]
+            #[serde(rename = "content")]
+            pub content: chromiumoxide_types::Binary,
+        }
+        impl GetAnnotatedPageContentReturns {
+            pub fn new(content: impl Into<chromiumoxide_types::Binary>) -> Self {
+                Self {
+                    content: content.into(),
+                }
+            }
+        }
+        impl GetAnnotatedPageContentReturns {
+            pub fn builder() -> GetAnnotatedPageContentReturnsBuilder {
+                GetAnnotatedPageContentReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAnnotatedPageContentReturnsBuilder {
+            content: Option<chromiumoxide_types::Binary>,
+        }
+        impl GetAnnotatedPageContentReturnsBuilder {
+            pub fn content(mut self, content: impl Into<chromiumoxide_types::Binary>) -> Self {
+                self.content = Some(content.into());
+                self
+            }
+            pub fn build(self) -> Result<GetAnnotatedPageContentReturns, String> {
+                Ok(GetAnnotatedPageContentReturns {
+                    content: self.content.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(content))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetAnnotatedPageContentParams {
+            type Response = GetAnnotatedPageContentReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDomContentEventFired {
+            #[serde(rename = "timestamp")]
+            pub timestamp: super::network::MonotonicTime,
+        }
+        impl EventDomContentEventFired {
+            pub const IDENTIFIER: &'static str = "Page.domContentEventFired";
+        }
+        impl chromiumoxide_types::Method for EventDomContentEventFired {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDomContentEventFired {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Emitted only when `page.interceptFileChooser` is enabled.\n[fileChooserOpened](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-fileChooserOpened)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventFileChooserOpened {
+            #[doc = "Id of the frame containing input node."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "Input mode."]
+            #[serde(rename = "mode")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub mode: FileChooserOpenedMode,
+            #[doc = "Input node id. Only present for file choosers opened via an `<input type=\"file\">` element."]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+        }
+        #[doc = "Input mode."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum FileChooserOpenedMode {
+            #[serde(rename = "selectSingle")]
+            SelectSingle,
+            #[serde(rename = "selectMultiple")]
+            SelectMultiple,
+        }
+        impl AsRef<str> for FileChooserOpenedMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    FileChooserOpenedMode::SelectSingle => "selectSingle",
+                    FileChooserOpenedMode::SelectMultiple => "selectMultiple",
+                }
+            }
+        }
+        impl ::std::str::FromStr for FileChooserOpenedMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "selectSingle" | "SelectSingle" | "selectsingle" => {
+                        Ok(FileChooserOpenedMode::SelectSingle)
+                    }
+                    "selectMultiple" | "SelectMultiple" | "selectmultiple" => {
+                        Ok(FileChooserOpenedMode::SelectMultiple)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EventFileChooserOpened {
+            pub const IDENTIFIER: &'static str = "Page.fileChooserOpened";
+        }
+        impl chromiumoxide_types::Method for EventFileChooserOpened {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFileChooserOpened {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when frame has been attached to its parent.\n[frameAttached](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-frameAttached)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventFrameAttached {
+            #[doc = "Id of the frame that has been attached."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "Parent frame identifier."]
+            #[serde(rename = "parentFrameId")]
+            pub parent_frame_id: FrameId,
+            #[doc = "JavaScript stack trace of when frame was attached, only set if frame initiated from script."]
+            #[serde(rename = "stack")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stack: Option<super::super::js_protocol::runtime::StackTrace>,
+        }
+        impl EventFrameAttached {
+            pub const IDENTIFIER: &'static str = "Page.frameAttached";
+        }
+        impl chromiumoxide_types::Method for EventFrameAttached {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFrameAttached {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when frame has been detached from its parent.\n[frameDetached](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-frameDetached)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventFrameDetached {
+            #[doc = "Id of the frame that has been detached."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[serde(rename = "reason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub reason: FrameDetachedReason,
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum FrameDetachedReason {
+            #[doc = "The frame is removed from the DOM."]
+            #[serde(rename = "remove")]
+            Remove,
+            #[doc = "The frame is being swapped out in favor of an out-of-process iframe.\nA new frame target will be created (see Target.attachedToTarget)."]
+            #[serde(rename = "swap")]
+            Swap,
+        }
+        impl AsRef<str> for FrameDetachedReason {
+            fn as_ref(&self) -> &str {
+                match self {
+                    FrameDetachedReason::Remove => "remove",
+                    FrameDetachedReason::Swap => "swap",
+                }
+            }
+        }
+        impl ::std::str::FromStr for FrameDetachedReason {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "remove" | "Remove" => Ok(FrameDetachedReason::Remove),
+                    "swap" | "Swap" => Ok(FrameDetachedReason::Swap),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EventFrameDetached {
+            pub const IDENTIFIER: &'static str = "Page.frameDetached";
+        }
+        impl chromiumoxide_types::Method for EventFrameDetached {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFrameDetached {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired before frame subtree is detached. Emitted before any frame of the\nsubtree is actually detached.\n[frameSubtreeWillBeDetached](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-frameSubtreeWillBeDetached)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventFrameSubtreeWillBeDetached {
+            #[doc = "Id of the frame that is the root of the subtree that will be detached."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+        }
+        impl EventFrameSubtreeWillBeDetached {
+            pub const IDENTIFIER: &'static str = "Page.frameSubtreeWillBeDetached";
+        }
+        impl chromiumoxide_types::Method for EventFrameSubtreeWillBeDetached {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFrameSubtreeWillBeDetached {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired once navigation of the frame has completed. Frame is now associated with the new loader.\n[frameNavigated](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-frameNavigated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventFrameNavigated {
+            #[doc = "Frame object."]
+            #[serde(rename = "frame")]
+            pub frame: Frame,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: NavigationType,
+        }
+        impl EventFrameNavigated {
+            pub const IDENTIFIER: &'static str = "Page.frameNavigated";
+        }
+        impl chromiumoxide_types::Method for EventFrameNavigated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFrameNavigated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when opening document to write to.\n[documentOpened](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-documentOpened)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDocumentOpened {
+            #[doc = "Frame object."]
+            #[serde(rename = "frame")]
+            pub frame: Frame,
+        }
+        impl EventDocumentOpened {
+            pub const IDENTIFIER: &'static str = "Page.documentOpened";
+        }
+        impl chromiumoxide_types::Method for EventDocumentOpened {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDocumentOpened {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventFrameResized {}
+        impl EventFrameResized {
+            pub const IDENTIFIER: &'static str = "Page.frameResized";
+        }
+        impl chromiumoxide_types::Method for EventFrameResized {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFrameResized {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a navigation starts. This event is fired for both\nrenderer-initiated and browser-initiated navigations. For renderer-initiated\nnavigations, the event is fired after `frameRequestedNavigation`.\nNavigation may still be cancelled after the event is issued. Multiple events\ncan be fired for a single navigation, for example, when a same-document\nnavigation becomes a cross-document navigation (such as in the case of a\nframeset).\n[frameStartedNavigating](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-frameStartedNavigating)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventFrameStartedNavigating {
+            #[doc = "ID of the frame that is being navigated."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "The URL the navigation started with. The final URL can be different."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Loader identifier. Even though it is present in case of same-document\nnavigation, the previously committed loaderId would not change unless\nthe navigation changes from a same-document to a cross-document\nnavigation."]
+            #[serde(rename = "loaderId")]
+            pub loader_id: super::network::LoaderId,
+            #[serde(rename = "navigationType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub navigation_type: FrameStartedNavigatingNavigationType,
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum FrameStartedNavigatingNavigationType {
+            #[serde(rename = "reload")]
+            Reload,
+            #[serde(rename = "reloadBypassingCache")]
+            ReloadBypassingCache,
+            #[serde(rename = "restore")]
+            Restore,
+            #[serde(rename = "restoreWithPost")]
+            RestoreWithPost,
+            #[serde(rename = "historySameDocument")]
+            HistorySameDocument,
+            #[serde(rename = "historyDifferentDocument")]
+            HistoryDifferentDocument,
+            #[serde(rename = "sameDocument")]
+            SameDocument,
+            #[serde(rename = "differentDocument")]
+            DifferentDocument,
+        }
+        impl AsRef<str> for FrameStartedNavigatingNavigationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    FrameStartedNavigatingNavigationType::Reload => "reload",
+                    FrameStartedNavigatingNavigationType::ReloadBypassingCache => {
+                        "reloadBypassingCache"
+                    }
+                    FrameStartedNavigatingNavigationType::Restore => "restore",
+                    FrameStartedNavigatingNavigationType::RestoreWithPost => "restoreWithPost",
+                    FrameStartedNavigatingNavigationType::HistorySameDocument => {
+                        "historySameDocument"
+                    }
+                    FrameStartedNavigatingNavigationType::HistoryDifferentDocument => {
+                        "historyDifferentDocument"
+                    }
+                    FrameStartedNavigatingNavigationType::SameDocument => "sameDocument",
+                    FrameStartedNavigatingNavigationType::DifferentDocument => "differentDocument",
+                }
+            }
+        }
+        impl ::std::str::FromStr for FrameStartedNavigatingNavigationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "reload" | "Reload" => Ok(FrameStartedNavigatingNavigationType::Reload),
+                    "reloadBypassingCache" | "ReloadBypassingCache" | "reloadbypassingcache" => {
+                        Ok(FrameStartedNavigatingNavigationType::ReloadBypassingCache)
+                    }
+                    "restore" | "Restore" => Ok(FrameStartedNavigatingNavigationType::Restore),
+                    "restoreWithPost" | "RestoreWithPost" | "restorewithpost" => {
+                        Ok(FrameStartedNavigatingNavigationType::RestoreWithPost)
+                    }
+                    "historySameDocument" | "HistorySameDocument" | "historysamedocument" => {
+                        Ok(FrameStartedNavigatingNavigationType::HistorySameDocument)
+                    }
+                    "historyDifferentDocument"
+                    | "HistoryDifferentDocument"
+                    | "historydifferentdocument" => {
+                        Ok(FrameStartedNavigatingNavigationType::HistoryDifferentDocument)
+                    }
+                    "sameDocument" | "SameDocument" | "samedocument" => {
+                        Ok(FrameStartedNavigatingNavigationType::SameDocument)
+                    }
+                    "differentDocument" | "DifferentDocument" | "differentdocument" => {
+                        Ok(FrameStartedNavigatingNavigationType::DifferentDocument)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EventFrameStartedNavigating {
+            pub const IDENTIFIER: &'static str = "Page.frameStartedNavigating";
+        }
+        impl chromiumoxide_types::Method for EventFrameStartedNavigating {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFrameStartedNavigating {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a renderer-initiated navigation is requested.\nNavigation may still be cancelled after the event is issued.\n[frameRequestedNavigation](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-frameRequestedNavigation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventFrameRequestedNavigation {
+            #[doc = "Id of the frame that is being navigated."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "The reason for the navigation."]
+            #[serde(rename = "reason")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub reason: ClientNavigationReason,
+            #[doc = "The destination URL for the requested navigation."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "The disposition for the navigation."]
+            #[serde(rename = "disposition")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub disposition: ClientNavigationDisposition,
+        }
+        impl EventFrameRequestedNavigation {
+            pub const IDENTIFIER: &'static str = "Page.frameRequestedNavigation";
+        }
+        impl chromiumoxide_types::Method for EventFrameRequestedNavigation {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFrameRequestedNavigation {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when frame has started loading.\n[frameStartedLoading](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-frameStartedLoading)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventFrameStartedLoading {
+            #[doc = "Id of the frame that has started loading."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+        }
+        impl EventFrameStartedLoading {
+            pub const IDENTIFIER: &'static str = "Page.frameStartedLoading";
+        }
+        impl chromiumoxide_types::Method for EventFrameStartedLoading {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFrameStartedLoading {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when frame has stopped loading.\n[frameStoppedLoading](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-frameStoppedLoading)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventFrameStoppedLoading {
+            #[doc = "Id of the frame that has stopped loading."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+        }
+        impl EventFrameStoppedLoading {
+            pub const IDENTIFIER: &'static str = "Page.frameStoppedLoading";
+        }
+        impl chromiumoxide_types::Method for EventFrameStoppedLoading {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventFrameStoppedLoading {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when interstitial page was hidden\n[interstitialHidden](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-interstitialHidden)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventInterstitialHidden {}
+        impl EventInterstitialHidden {
+            pub const IDENTIFIER: &'static str = "Page.interstitialHidden";
+        }
+        impl chromiumoxide_types::Method for EventInterstitialHidden {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventInterstitialHidden {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when interstitial page was shown\n[interstitialShown](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-interstitialShown)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventInterstitialShown {}
+        impl EventInterstitialShown {
+            pub const IDENTIFIER: &'static str = "Page.interstitialShown";
+        }
+        impl chromiumoxide_types::Method for EventInterstitialShown {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventInterstitialShown {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) has been\nclosed.\n[javascriptDialogClosed](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-javascriptDialogClosed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventJavascriptDialogClosed {
+            #[doc = "Frame id."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "Whether dialog was confirmed."]
+            #[serde(rename = "result")]
+            pub result: bool,
+            #[doc = "User input in case of prompt."]
+            #[serde(rename = "userInput")]
+            pub user_input: String,
+        }
+        impl EventJavascriptDialogClosed {
+            pub const IDENTIFIER: &'static str = "Page.javascriptDialogClosed";
+        }
+        impl chromiumoxide_types::Method for EventJavascriptDialogClosed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventJavascriptDialogClosed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) is about to\nopen.\n[javascriptDialogOpening](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-javascriptDialogOpening)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventJavascriptDialogOpening {
+            #[doc = "Frame url."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Frame id."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "Message that will be displayed by the dialog."]
+            #[serde(rename = "message")]
+            pub message: String,
+            #[doc = "Dialog type."]
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: DialogType,
+            #[doc = "True iff browser is capable showing or acting on the given dialog. When browser has no\ndialog handler for given target, calling alert while Page domain is engaged will stall\nthe page execution. Execution can be resumed via calling Page.handleJavaScriptDialog."]
+            #[serde(rename = "hasBrowserHandler")]
+            pub has_browser_handler: bool,
+            #[doc = "Default dialog prompt."]
+            #[serde(rename = "defaultPrompt")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub default_prompt: Option<String>,
+        }
+        impl EventJavascriptDialogOpening {
+            pub const IDENTIFIER: &'static str = "Page.javascriptDialogOpening";
+        }
+        impl chromiumoxide_types::Method for EventJavascriptDialogOpening {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventJavascriptDialogOpening {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired for lifecycle events (navigation, load, paint, etc) in the current\ntarget (including local frames).\n[lifecycleEvent](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-lifecycleEvent)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventLifecycleEvent {
+            #[doc = "Id of the frame."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "Loader identifier. Empty string if the request is fetched from worker."]
+            #[serde(rename = "loaderId")]
+            pub loader_id: super::network::LoaderId,
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "timestamp")]
+            pub timestamp: super::network::MonotonicTime,
+        }
+        impl EventLifecycleEvent {
+            pub const IDENTIFIER: &'static str = "Page.lifecycleEvent";
+        }
+        impl chromiumoxide_types::Method for EventLifecycleEvent {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventLifecycleEvent {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired for failed bfcache history navigations if BackForwardCache feature is enabled. Do\nnot assume any ordering with the Page.frameNavigated event. This event is fired only for\nmain-frame history navigation where the document changes (non-same-document navigations),\nwhen bfcache navigation fails.\n[backForwardCacheNotUsed](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-backForwardCacheNotUsed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventBackForwardCacheNotUsed {
+            #[doc = "The loader id for the associated navigation."]
+            #[serde(rename = "loaderId")]
+            pub loader_id: super::network::LoaderId,
+            #[doc = "The frame id of the associated frame."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "Array of reasons why the page could not be cached. This must not be empty."]
+            #[serde(rename = "notRestoredExplanations")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub not_restored_explanations: Vec<BackForwardCacheNotRestoredExplanation>,
+            #[doc = "Tree structure of reasons why the page could not be cached for each frame."]
+            #[serde(rename = "notRestoredExplanationsTree")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub not_restored_explanations_tree: Option<BackForwardCacheNotRestoredExplanationTree>,
+        }
+        impl EventBackForwardCacheNotUsed {
+            pub const IDENTIFIER: &'static str = "Page.backForwardCacheNotUsed";
+        }
+        impl chromiumoxide_types::Method for EventBackForwardCacheNotUsed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventBackForwardCacheNotUsed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventLoadEventFired {
+            #[serde(rename = "timestamp")]
+            pub timestamp: super::network::MonotonicTime,
+        }
+        impl EventLoadEventFired {
+            pub const IDENTIFIER: &'static str = "Page.loadEventFired";
+        }
+        impl chromiumoxide_types::Method for EventLoadEventFired {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventLoadEventFired {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when same-document navigation happens, e.g. due to history API usage or anchor navigation.\n[navigatedWithinDocument](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-navigatedWithinDocument)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventNavigatedWithinDocument {
+            #[doc = "Id of the frame."]
+            #[serde(rename = "frameId")]
+            pub frame_id: FrameId,
+            #[doc = "Frame's new url."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Navigation type"]
+            #[serde(rename = "navigationType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub navigation_type: NavigatedWithinDocumentNavigationType,
+        }
+        #[doc = "Navigation type"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum NavigatedWithinDocumentNavigationType {
+            #[doc = "Navigation due to fragment navigation."]
+            #[serde(rename = "fragment")]
+            Fragment,
+            #[doc = "Navigation due to history API usage."]
+            #[serde(rename = "historyApi")]
+            HistoryApi,
+            #[doc = "Navigation due to other reasons."]
+            #[serde(rename = "other")]
+            Other,
+        }
+        impl AsRef<str> for NavigatedWithinDocumentNavigationType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    NavigatedWithinDocumentNavigationType::Fragment => "fragment",
+                    NavigatedWithinDocumentNavigationType::HistoryApi => "historyApi",
+                    NavigatedWithinDocumentNavigationType::Other => "other",
+                }
+            }
+        }
+        impl ::std::str::FromStr for NavigatedWithinDocumentNavigationType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "fragment" | "Fragment" => Ok(NavigatedWithinDocumentNavigationType::Fragment),
+                    "historyApi" | "HistoryApi" | "historyapi" => {
+                        Ok(NavigatedWithinDocumentNavigationType::HistoryApi)
+                    }
+                    "other" | "Other" => Ok(NavigatedWithinDocumentNavigationType::Other),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EventNavigatedWithinDocument {
+            pub const IDENTIFIER: &'static str = "Page.navigatedWithinDocument";
+        }
+        impl chromiumoxide_types::Method for EventNavigatedWithinDocument {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventNavigatedWithinDocument {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Compressed image data requested by the `startScreencast`.\n[screencastFrame](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-screencastFrame)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventScreencastFrame {
+            #[doc = "Base64-encoded compressed image."]
+            #[serde(rename = "data")]
+            pub data: chromiumoxide_types::Binary,
+            #[doc = "Screencast frame metadata."]
+            #[serde(rename = "metadata")]
+            pub metadata: ScreencastFrameMetadata,
+            #[doc = "Frame number."]
+            #[serde(rename = "sessionId")]
+            pub session_id: i64,
+        }
+        impl EventScreencastFrame {
+            pub const IDENTIFIER: &'static str = "Page.screencastFrame";
+        }
+        impl chromiumoxide_types::Method for EventScreencastFrame {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventScreencastFrame {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when the page with currently enabled screencast was shown or hidden `.\n[screencastVisibilityChanged](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-screencastVisibilityChanged)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventScreencastVisibilityChanged {
+            #[doc = "True if the page is visible."]
+            #[serde(rename = "visible")]
+            pub visible: bool,
+        }
+        impl EventScreencastVisibilityChanged {
+            pub const IDENTIFIER: &'static str = "Page.screencastVisibilityChanged";
+        }
+        impl chromiumoxide_types::Method for EventScreencastVisibilityChanged {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventScreencastVisibilityChanged {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a new window is going to be opened, via window.open(), link click, form submission,\netc.\n[windowOpen](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-windowOpen)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWindowOpen {
+            #[doc = "The URL for the new window."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Window name."]
+            #[serde(rename = "windowName")]
+            pub window_name: String,
+            #[doc = "An array of enabled window features."]
+            #[serde(rename = "windowFeatures")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub window_features: Vec<String>,
+            #[doc = "Whether or not it was triggered by user gesture."]
+            #[serde(rename = "userGesture")]
+            pub user_gesture: bool,
+        }
+        impl EventWindowOpen {
+            pub const IDENTIFIER: &'static str = "Page.windowOpen";
+        }
+        impl chromiumoxide_types::Method for EventWindowOpen {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWindowOpen {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued for every compilation cache generated.\n[compilationCacheProduced](https://chromedevtools.github.io/devtools-protocol/tot/Page/#event-compilationCacheProduced)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventCompilationCacheProduced {
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Base64-encoded data"]
+            #[serde(rename = "data")]
+            pub data: chromiumoxide_types::Binary,
+        }
+        impl EventCompilationCacheProduced {
+            pub const IDENTIFIER: &'static str = "Page.compilationCacheProduced";
+        }
+        impl chromiumoxide_types::Method for EventCompilationCacheProduced {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventCompilationCacheProduced {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod performance {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Run-time execution metric.\n[Metric](https://chromedevtools.github.io/devtools-protocol/tot/Performance/#type-Metric)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Metric {
+            #[doc = "Metric name."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Metric value."]
+            #[serde(rename = "value")]
+            pub value: f64,
+        }
+        impl Metric {
+            pub fn new(name: impl Into<String>, value: impl Into<f64>) -> Self {
+                Self {
+                    name: name.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl Metric {
+            pub fn builder() -> MetricBuilder {
+                MetricBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct MetricBuilder {
+            name: Option<String>,
+            value: Option<f64>,
+        }
+        impl MetricBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<f64>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<Metric, String> {
+                Ok(Metric {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl Metric {
+            pub const IDENTIFIER: &'static str = "Performance.Metric";
+        }
+        #[doc = "Disable collecting and reporting metrics.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Performance/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Performance.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disable collecting and reporting metrics.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Performance/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enable collecting and reporting metrics.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Performance/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[doc = "Time domain to use for collecting and reporting duration metrics."]
+            #[serde(rename = "timeDomain")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub time_domain: Option<EnableTimeDomain>,
+        }
+        #[doc = "Time domain to use for collecting and reporting duration metrics."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum EnableTimeDomain {
+            #[doc = "Use monotonically increasing abstract time (default)."]
+            #[serde(rename = "timeTicks")]
+            TimeTicks,
+            #[doc = "Use thread running time."]
+            #[serde(rename = "threadTicks")]
+            ThreadTicks,
+        }
+        impl AsRef<str> for EnableTimeDomain {
+            fn as_ref(&self) -> &str {
+                match self {
+                    EnableTimeDomain::TimeTicks => "timeTicks",
+                    EnableTimeDomain::ThreadTicks => "threadTicks",
+                }
+            }
+        }
+        impl ::std::str::FromStr for EnableTimeDomain {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "timeTicks" | "TimeTicks" | "timeticks" => Ok(EnableTimeDomain::TimeTicks),
+                    "threadTicks" | "ThreadTicks" | "threadticks" => {
+                        Ok(EnableTimeDomain::ThreadTicks)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            time_domain: Option<EnableTimeDomain>,
+        }
+        impl EnableParamsBuilder {
+            pub fn time_domain(mut self, time_domain: impl Into<EnableTimeDomain>) -> Self {
+                self.time_domain = Some(time_domain.into());
+                self
+            }
+            pub fn build(self) -> EnableParams {
+                EnableParams {
+                    time_domain: self.time_domain,
+                }
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Performance.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enable collecting and reporting metrics.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Performance/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Retrieve current values of run-time metrics.\n[getMetrics](https://chromedevtools.github.io/devtools-protocol/tot/Performance/#method-getMetrics)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetMetricsParams {}
+        impl GetMetricsParams {
+            pub const IDENTIFIER: &'static str = "Performance.getMetrics";
+        }
+        impl chromiumoxide_types::Method for GetMetricsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetMetricsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Retrieve current values of run-time metrics.\n[getMetrics](https://chromedevtools.github.io/devtools-protocol/tot/Performance/#method-getMetrics)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetMetricsReturns {
+            #[doc = "Current values for run-time metrics."]
+            #[serde(rename = "metrics")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub metrics: Vec<Metric>,
+        }
+        impl GetMetricsReturns {
+            pub fn new(metrics: Vec<Metric>) -> Self {
+                Self { metrics }
+            }
+        }
+        impl GetMetricsReturns {
+            pub fn builder() -> GetMetricsReturnsBuilder {
+                GetMetricsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetMetricsReturnsBuilder {
+            metrics: Option<Vec<Metric>>,
+        }
+        impl GetMetricsReturnsBuilder {
+            pub fn metric(mut self, metric: impl Into<Metric>) -> Self {
+                let v = self.metrics.get_or_insert(Vec::new());
+                v.push(metric.into());
+                self
+            }
+            pub fn metrics<I, S>(mut self, metrics: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Metric>,
+            {
+                let v = self.metrics.get_or_insert(Vec::new());
+                for val in metrics {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetMetricsReturns, String> {
+                Ok(GetMetricsReturns {
+                    metrics: self.metrics.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(metrics))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetMetricsParams {
+            type Response = GetMetricsReturns;
+        }
+        #[doc = "Current values of the metrics.\n[metrics](https://chromedevtools.github.io/devtools-protocol/tot/Performance/#event-metrics)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventMetrics {
+            #[doc = "Current values of the metrics."]
+            #[serde(rename = "metrics")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub metrics: Vec<Metric>,
+            #[doc = "Timestamp title."]
+            #[serde(rename = "title")]
+            pub title: String,
+        }
+        impl EventMetrics {
+            pub const IDENTIFIER: &'static str = "Performance.metrics";
+        }
+        impl chromiumoxide_types::Method for EventMetrics {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventMetrics {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "Reporting of performance timeline events, as specified in\nhttps://w3c.github.io/performance-timeline/#dom-performanceobserver."]
+    pub mod performance_timeline {
+        use serde::{Deserialize, Serialize};
+        #[doc = "See https://github.com/WICG/LargestContentfulPaint and largest_contentful_paint.idl\n[LargestContentfulPaint](https://chromedevtools.github.io/devtools-protocol/tot/PerformanceTimeline/#type-LargestContentfulPaint)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LargestContentfulPaint {
+            #[serde(rename = "renderTime")]
+            pub render_time: super::network::TimeSinceEpoch,
+            #[serde(rename = "loadTime")]
+            pub load_time: super::network::TimeSinceEpoch,
+            #[doc = "The number of pixels being painted."]
+            #[serde(rename = "size")]
+            pub size: f64,
+            #[doc = "The id attribute of the element, if available."]
+            #[serde(rename = "elementId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub element_id: Option<String>,
+            #[doc = "The URL of the image (may be trimmed)."]
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<super::dom::BackendNodeId>,
+        }
+        impl LargestContentfulPaint {
+            pub fn new(
+                render_time: impl Into<super::network::TimeSinceEpoch>,
+                load_time: impl Into<super::network::TimeSinceEpoch>,
+                size: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    render_time: render_time.into(),
+                    load_time: load_time.into(),
+                    size: size.into(),
+                    element_id: None,
+                    url: None,
+                    node_id: None,
+                }
+            }
+        }
+        impl LargestContentfulPaint {
+            pub fn builder() -> LargestContentfulPaintBuilder {
+                LargestContentfulPaintBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LargestContentfulPaintBuilder {
+            render_time: Option<super::network::TimeSinceEpoch>,
+            load_time: Option<super::network::TimeSinceEpoch>,
+            size: Option<f64>,
+            element_id: Option<String>,
+            url: Option<String>,
+            node_id: Option<super::dom::BackendNodeId>,
+        }
+        impl LargestContentfulPaintBuilder {
+            pub fn render_time(
+                mut self,
+                render_time: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.render_time = Some(render_time.into());
+                self
+            }
+            pub fn load_time(
+                mut self,
+                load_time: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.load_time = Some(load_time.into());
+                self
+            }
+            pub fn size(mut self, size: impl Into<f64>) -> Self {
+                self.size = Some(size.into());
+                self
+            }
+            pub fn element_id(mut self, element_id: impl Into<String>) -> Self {
+                self.element_id = Some(element_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::BackendNodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<LargestContentfulPaint, String> {
+                Ok(LargestContentfulPaint {
+                    render_time: self.render_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(render_time))
+                    })?,
+                    load_time: self.load_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(load_time))
+                    })?,
+                    size: self.size.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(size))
+                    })?,
+                    element_id: self.element_id,
+                    url: self.url,
+                    node_id: self.node_id,
+                })
+            }
+        }
+        impl LargestContentfulPaint {
+            pub const IDENTIFIER: &'static str = "PerformanceTimeline.LargestContentfulPaint";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LayoutShiftAttribution {
+            #[serde(rename = "previousRect")]
+            pub previous_rect: super::dom::Rect,
+            #[serde(rename = "currentRect")]
+            pub current_rect: super::dom::Rect,
+            #[serde(rename = "nodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub node_id: Option<super::dom::BackendNodeId>,
+        }
+        impl LayoutShiftAttribution {
+            pub fn new(
+                previous_rect: impl Into<super::dom::Rect>,
+                current_rect: impl Into<super::dom::Rect>,
+            ) -> Self {
+                Self {
+                    previous_rect: previous_rect.into(),
+                    current_rect: current_rect.into(),
+                    node_id: None,
+                }
+            }
+        }
+        impl LayoutShiftAttribution {
+            pub fn builder() -> LayoutShiftAttributionBuilder {
+                LayoutShiftAttributionBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LayoutShiftAttributionBuilder {
+            previous_rect: Option<super::dom::Rect>,
+            current_rect: Option<super::dom::Rect>,
+            node_id: Option<super::dom::BackendNodeId>,
+        }
+        impl LayoutShiftAttributionBuilder {
+            pub fn previous_rect(mut self, previous_rect: impl Into<super::dom::Rect>) -> Self {
+                self.previous_rect = Some(previous_rect.into());
+                self
+            }
+            pub fn current_rect(mut self, current_rect: impl Into<super::dom::Rect>) -> Self {
+                self.current_rect = Some(current_rect.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::BackendNodeId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn build(self) -> Result<LayoutShiftAttribution, String> {
+                Ok(LayoutShiftAttribution {
+                    previous_rect: self.previous_rect.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(previous_rect))
+                    })?,
+                    current_rect: self.current_rect.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(current_rect))
+                    })?,
+                    node_id: self.node_id,
+                })
+            }
+        }
+        impl LayoutShiftAttribution {
+            pub const IDENTIFIER: &'static str = "PerformanceTimeline.LayoutShiftAttribution";
+        }
+        #[doc = "See https://wicg.github.io/layout-instability/#sec-layout-shift and layout_shift.idl\n[LayoutShift](https://chromedevtools.github.io/devtools-protocol/tot/PerformanceTimeline/#type-LayoutShift)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct LayoutShift {
+            #[doc = "Score increment produced by this event."]
+            #[serde(rename = "value")]
+            pub value: f64,
+            #[serde(rename = "hadRecentInput")]
+            pub had_recent_input: bool,
+            #[serde(rename = "lastInputTime")]
+            pub last_input_time: super::network::TimeSinceEpoch,
+            #[serde(rename = "sources")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub sources: Vec<LayoutShiftAttribution>,
+        }
+        impl LayoutShift {
+            pub fn new(
+                value: impl Into<f64>,
+                had_recent_input: impl Into<bool>,
+                last_input_time: impl Into<super::network::TimeSinceEpoch>,
+                sources: Vec<LayoutShiftAttribution>,
+            ) -> Self {
+                Self {
+                    value: value.into(),
+                    had_recent_input: had_recent_input.into(),
+                    last_input_time: last_input_time.into(),
+                    sources,
+                }
+            }
+        }
+        impl LayoutShift {
+            pub fn builder() -> LayoutShiftBuilder {
+                LayoutShiftBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct LayoutShiftBuilder {
+            value: Option<f64>,
+            had_recent_input: Option<bool>,
+            last_input_time: Option<super::network::TimeSinceEpoch>,
+            sources: Option<Vec<LayoutShiftAttribution>>,
+        }
+        impl LayoutShiftBuilder {
+            pub fn value(mut self, value: impl Into<f64>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn had_recent_input(mut self, had_recent_input: impl Into<bool>) -> Self {
+                self.had_recent_input = Some(had_recent_input.into());
+                self
+            }
+            pub fn last_input_time(
+                mut self,
+                last_input_time: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.last_input_time = Some(last_input_time.into());
+                self
+            }
+            pub fn source(mut self, source: impl Into<LayoutShiftAttribution>) -> Self {
+                let v = self.sources.get_or_insert(Vec::new());
+                v.push(source.into());
+                self
+            }
+            pub fn sources<I, S>(mut self, sources: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<LayoutShiftAttribution>,
+            {
+                let v = self.sources.get_or_insert(Vec::new());
+                for val in sources {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<LayoutShift, String> {
+                Ok(LayoutShift {
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    had_recent_input: self.had_recent_input.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(had_recent_input)
+                        )
+                    })?,
+                    last_input_time: self.last_input_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(last_input_time))
+                    })?,
+                    sources: self.sources.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(sources))
+                    })?,
+                })
+            }
+        }
+        impl LayoutShift {
+            pub const IDENTIFIER: &'static str = "PerformanceTimeline.LayoutShift";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TimelineEvent {
+            #[doc = "Identifies the frame that this event is related to. Empty for non-frame targets."]
+            #[serde(rename = "frameId")]
+            pub frame_id: super::page::FrameId,
+            #[doc = "The event type, as specified in https://w3c.github.io/performance-timeline/#dom-performanceentry-entrytype\nThis determines which of the optional \"details\" fields is present."]
+            #[serde(rename = "type")]
+            pub r#type: String,
+            #[doc = "Name may be empty depending on the type."]
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "Time in seconds since Epoch, monotonically increasing within document lifetime."]
+            #[serde(rename = "time")]
+            pub time: super::network::TimeSinceEpoch,
+            #[doc = "Event duration, if applicable."]
+            #[serde(rename = "duration")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub duration: Option<f64>,
+            #[serde(rename = "lcpDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub lcp_details: Option<LargestContentfulPaint>,
+            #[serde(rename = "layoutShiftDetails")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub layout_shift_details: Option<LayoutShift>,
+        }
+        impl TimelineEvent {
+            pub fn new(
+                frame_id: impl Into<super::page::FrameId>,
+                r#type: impl Into<String>,
+                name: impl Into<String>,
+                time: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                Self {
+                    frame_id: frame_id.into(),
+                    r#type: r#type.into(),
+                    name: name.into(),
+                    time: time.into(),
+                    duration: None,
+                    lcp_details: None,
+                    layout_shift_details: None,
+                }
+            }
+        }
+        impl TimelineEvent {
+            pub fn builder() -> TimelineEventBuilder {
+                TimelineEventBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TimelineEventBuilder {
+            frame_id: Option<super::page::FrameId>,
+            r#type: Option<String>,
+            name: Option<String>,
+            time: Option<super::network::TimeSinceEpoch>,
+            duration: Option<f64>,
+            lcp_details: Option<LargestContentfulPaint>,
+            layout_shift_details: Option<LayoutShift>,
+        }
+        impl TimelineEventBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn time(mut self, time: impl Into<super::network::TimeSinceEpoch>) -> Self {
+                self.time = Some(time.into());
+                self
+            }
+            pub fn duration(mut self, duration: impl Into<f64>) -> Self {
+                self.duration = Some(duration.into());
+                self
+            }
+            pub fn lcp_details(mut self, lcp_details: impl Into<LargestContentfulPaint>) -> Self {
+                self.lcp_details = Some(lcp_details.into());
+                self
+            }
+            pub fn layout_shift_details(
+                mut self,
+                layout_shift_details: impl Into<LayoutShift>,
+            ) -> Self {
+                self.layout_shift_details = Some(layout_shift_details.into());
+                self
+            }
+            pub fn build(self) -> Result<TimelineEvent, String> {
+                Ok(TimelineEvent {
+                    frame_id: self.frame_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(frame_id))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    time: self.time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(time))
+                    })?,
+                    duration: self.duration,
+                    lcp_details: self.lcp_details,
+                    layout_shift_details: self.layout_shift_details,
+                })
+            }
+        }
+        impl TimelineEvent {
+            pub const IDENTIFIER: &'static str = "PerformanceTimeline.TimelineEvent";
+        }
+        #[doc = "Previously buffered events would be reported before method returns.\nSee also: timelineEventAdded\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/PerformanceTimeline/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[doc = "The types of event to report, as specified in\nhttps://w3c.github.io/performance-timeline/#dom-performanceentry-entrytype\nThe specified filter overrides any previous filters, passing empty\nfilter disables recording.\nNote that not all types exposed to the web platform are currently supported."]
+            #[serde(rename = "eventTypes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub event_types: Vec<String>,
+        }
+        impl EnableParams {
+            pub fn new(event_types: Vec<String>) -> Self {
+                Self { event_types }
+            }
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            event_types: Option<Vec<String>>,
+        }
+        impl EnableParamsBuilder {
+            pub fn event_type(mut self, event_type: impl Into<String>) -> Self {
+                let v = self.event_types.get_or_insert(Vec::new());
+                v.push(event_type.into());
+                self
+            }
+            pub fn event_types<I, S>(mut self, event_types: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.event_types.get_or_insert(Vec::new());
+                for val in event_types {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<EnableParams, String> {
+                Ok(EnableParams {
+                    event_types: self.event_types.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(event_types))
+                    })?,
+                })
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "PerformanceTimeline.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Previously buffered events would be reported before method returns.\nSee also: timelineEventAdded\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/PerformanceTimeline/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Sent when a performance timeline event is added. See reportPerformanceTimeline method.\n[timelineEventAdded](https://chromedevtools.github.io/devtools-protocol/tot/PerformanceTimeline/#event-timelineEventAdded)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventTimelineEventAdded {
+            #[serde(rename = "event")]
+            pub event: TimelineEvent,
+        }
+        impl EventTimelineEventAdded {
+            pub const IDENTIFIER: &'static str = "PerformanceTimeline.timelineEventAdded";
+        }
+        impl chromiumoxide_types::Method for EventTimelineEventAdded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventTimelineEventAdded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod preload {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Unique id\n[RuleSetId](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#type-RuleSetId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct RuleSetId(String);
+        impl RuleSetId {
+            pub fn new(val: impl Into<String>) -> Self {
+                RuleSetId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for RuleSetId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<RuleSetId> for String {
+            fn from(el: RuleSetId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for RuleSetId {
+            fn from(expr: String) -> Self {
+                RuleSetId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for RuleSetId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl RuleSetId {
+            pub const IDENTIFIER: &'static str = "Preload.RuleSetId";
+        }
+        #[doc = "Corresponds to SpeculationRuleSet\n[RuleSet](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#type-RuleSet)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RuleSet {
+            #[serde(rename = "id")]
+            pub id: RuleSetId,
+            #[doc = "Identifies a document which the rule set is associated with."]
+            #[serde(rename = "loaderId")]
+            pub loader_id: super::network::LoaderId,
+            #[doc = "Source text of JSON representing the rule set. If it comes from\n`<script>` tag, it is the textContent of the node. Note that it is\na JSON for valid case.\n\nSee also:\n- https://wicg.github.io/nav-speculation/speculation-rules.html\n- https://github.com/WICG/nav-speculation/blob/main/triggers.md"]
+            #[serde(rename = "sourceText")]
+            pub source_text: String,
+            #[doc = "A speculation rule set is either added through an inline\n`<script>` tag or through an external resource via the\n'Speculation-Rules' HTTP header. For the first case, we include\nthe BackendNodeId of the relevant `<script>` tag. For the second\ncase, we include the external URL where the rule set was loaded\nfrom, and also RequestId if Network domain is enabled.\n\nSee also:\n- https://wicg.github.io/nav-speculation/speculation-rules.html#speculation-rules-script\n- https://wicg.github.io/nav-speculation/speculation-rules.html#speculation-rules-header"]
+            #[serde(rename = "backendNodeId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backend_node_id: Option<super::dom::BackendNodeId>,
+            #[serde(rename = "url")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub url: Option<String>,
+            #[serde(rename = "requestId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub request_id: Option<super::network::RequestId>,
+            #[doc = "Error information\n`errorMessage` is null iff `errorType` is null."]
+            #[serde(rename = "errorType")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub error_type: Option<RuleSetErrorType>,
+            #[doc = "For more details, see:\nhttps://github.com/WICG/nav-speculation/blob/main/speculation-rules-tags.md"]
+            #[serde(rename = "tag")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub tag: Option<String>,
+        }
+        impl RuleSet {
+            pub fn new(
+                id: impl Into<RuleSetId>,
+                loader_id: impl Into<super::network::LoaderId>,
+                source_text: impl Into<String>,
+            ) -> Self {
+                Self {
+                    id: id.into(),
+                    loader_id: loader_id.into(),
+                    source_text: source_text.into(),
+                    backend_node_id: None,
+                    url: None,
+                    request_id: None,
+                    error_type: None,
+                    tag: None,
+                }
+            }
+        }
+        impl RuleSet {
+            pub fn builder() -> RuleSetBuilder {
+                RuleSetBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RuleSetBuilder {
+            id: Option<RuleSetId>,
+            loader_id: Option<super::network::LoaderId>,
+            source_text: Option<String>,
+            backend_node_id: Option<super::dom::BackendNodeId>,
+            url: Option<String>,
+            request_id: Option<super::network::RequestId>,
+            error_type: Option<RuleSetErrorType>,
+            tag: Option<String>,
+        }
+        impl RuleSetBuilder {
+            pub fn id(mut self, id: impl Into<RuleSetId>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn loader_id(mut self, loader_id: impl Into<super::network::LoaderId>) -> Self {
+                self.loader_id = Some(loader_id.into());
+                self
+            }
+            pub fn source_text(mut self, source_text: impl Into<String>) -> Self {
+                self.source_text = Some(source_text.into());
+                self
+            }
+            pub fn backend_node_id(
+                mut self,
+                backend_node_id: impl Into<super::dom::BackendNodeId>,
+            ) -> Self {
+                self.backend_node_id = Some(backend_node_id.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn request_id(mut self, request_id: impl Into<super::network::RequestId>) -> Self {
+                self.request_id = Some(request_id.into());
+                self
+            }
+            pub fn error_type(mut self, error_type: impl Into<RuleSetErrorType>) -> Self {
+                self.error_type = Some(error_type.into());
+                self
+            }
+            pub fn tag(mut self, tag: impl Into<String>) -> Self {
+                self.tag = Some(tag.into());
+                self
+            }
+            pub fn build(self) -> Result<RuleSet, String> {
+                Ok(RuleSet {
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    loader_id: self.loader_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(loader_id))
+                    })?,
+                    source_text: self.source_text.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source_text))
+                    })?,
+                    backend_node_id: self.backend_node_id,
+                    url: self.url,
+                    request_id: self.request_id,
+                    error_type: self.error_type,
+                    tag: self.tag,
+                })
+            }
+        }
+        impl RuleSet {
+            pub const IDENTIFIER: &'static str = "Preload.RuleSet";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum RuleSetErrorType {
+            #[serde(rename = "SourceIsNotJsonObject")]
+            SourceIsNotJsonObject,
+            #[serde(rename = "InvalidRulesSkipped")]
+            InvalidRulesSkipped,
+            #[serde(rename = "InvalidRulesetLevelTag")]
+            InvalidRulesetLevelTag,
+        }
+        impl AsRef<str> for RuleSetErrorType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    RuleSetErrorType::SourceIsNotJsonObject => "SourceIsNotJsonObject",
+                    RuleSetErrorType::InvalidRulesSkipped => "InvalidRulesSkipped",
+                    RuleSetErrorType::InvalidRulesetLevelTag => "InvalidRulesetLevelTag",
+                }
+            }
+        }
+        impl ::std::str::FromStr for RuleSetErrorType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "SourceIsNotJsonObject" | "sourceisnotjsonobject" => {
+                        Ok(RuleSetErrorType::SourceIsNotJsonObject)
+                    }
+                    "InvalidRulesSkipped" | "invalidrulesskipped" => {
+                        Ok(RuleSetErrorType::InvalidRulesSkipped)
+                    }
+                    "InvalidRulesetLevelTag" | "invalidrulesetleveltag" => {
+                        Ok(RuleSetErrorType::InvalidRulesetLevelTag)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "The type of preloading attempted. It corresponds to\nmojom::SpeculationAction (although PrefetchWithSubresources is omitted as it\nisn't being used by clients)."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SpeculationAction {
+            #[serde(rename = "Prefetch")]
+            Prefetch,
+            #[serde(rename = "Prerender")]
+            Prerender,
+            #[serde(rename = "PrerenderUntilScript")]
+            PrerenderUntilScript,
+        }
+        impl AsRef<str> for SpeculationAction {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SpeculationAction::Prefetch => "Prefetch",
+                    SpeculationAction::Prerender => "Prerender",
+                    SpeculationAction::PrerenderUntilScript => "PrerenderUntilScript",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SpeculationAction {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Prefetch" | "prefetch" => Ok(SpeculationAction::Prefetch),
+                    "Prerender" | "prerender" => Ok(SpeculationAction::Prerender),
+                    "PrerenderUntilScript" | "prerenderuntilscript" => {
+                        Ok(SpeculationAction::PrerenderUntilScript)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Corresponds to mojom::SpeculationTargetHint.\nSee https://github.com/WICG/nav-speculation/blob/main/triggers.md#window-name-targeting-hints"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SpeculationTargetHint {
+            #[serde(rename = "Blank")]
+            Blank,
+            #[serde(rename = "Self")]
+            KSelf,
+        }
+        impl AsRef<str> for SpeculationTargetHint {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SpeculationTargetHint::Blank => "Blank",
+                    SpeculationTargetHint::KSelf => "Self",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SpeculationTargetHint {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Blank" | "blank" => Ok(SpeculationTargetHint::Blank),
+                    "Self" | "KSelf" | "self" => Ok(SpeculationTargetHint::KSelf),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "A key that identifies a preloading attempt.\n\nThe url used is the url specified by the trigger (i.e. the initial URL), and\nnot the final url that is navigated to. For example, prerendering allows\nsame-origin main frame navigations during the attempt, but the attempt is\nstill keyed with the initial URL.\n[PreloadingAttemptKey](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#type-PreloadingAttemptKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PreloadingAttemptKey {
+            #[serde(rename = "loaderId")]
+            pub loader_id: super::network::LoaderId,
+            #[serde(rename = "action")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub action: SpeculationAction,
+            #[serde(rename = "url")]
+            pub url: String,
+            #[serde(rename = "targetHint")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub target_hint: Option<SpeculationTargetHint>,
+        }
+        impl PreloadingAttemptKey {
+            pub fn new(
+                loader_id: impl Into<super::network::LoaderId>,
+                action: impl Into<SpeculationAction>,
+                url: impl Into<String>,
+            ) -> Self {
+                Self {
+                    loader_id: loader_id.into(),
+                    action: action.into(),
+                    url: url.into(),
+                    target_hint: None,
+                }
+            }
+        }
+        impl PreloadingAttemptKey {
+            pub fn builder() -> PreloadingAttemptKeyBuilder {
+                PreloadingAttemptKeyBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PreloadingAttemptKeyBuilder {
+            loader_id: Option<super::network::LoaderId>,
+            action: Option<SpeculationAction>,
+            url: Option<String>,
+            target_hint: Option<SpeculationTargetHint>,
+        }
+        impl PreloadingAttemptKeyBuilder {
+            pub fn loader_id(mut self, loader_id: impl Into<super::network::LoaderId>) -> Self {
+                self.loader_id = Some(loader_id.into());
+                self
+            }
+            pub fn action(mut self, action: impl Into<SpeculationAction>) -> Self {
+                self.action = Some(action.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn target_hint(mut self, target_hint: impl Into<SpeculationTargetHint>) -> Self {
+                self.target_hint = Some(target_hint.into());
+                self
+            }
+            pub fn build(self) -> Result<PreloadingAttemptKey, String> {
+                Ok(PreloadingAttemptKey {
+                    loader_id: self.loader_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(loader_id))
+                    })?,
+                    action: self.action.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(action))
+                    })?,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    target_hint: self.target_hint,
+                })
+            }
+        }
+        impl PreloadingAttemptKey {
+            pub const IDENTIFIER: &'static str = "Preload.PreloadingAttemptKey";
+        }
+        #[doc = "Lists sources for a preloading attempt, specifically the ids of rule sets\nthat had a speculation rule that triggered the attempt, and the\nBackendNodeIds of <a href> or <area href> elements that triggered the\nattempt (in the case of attempts triggered by a document rule). It is\npossible for multiple rule sets and links to trigger a single attempt.\n[PreloadingAttemptSource](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#type-PreloadingAttemptSource)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PreloadingAttemptSource {
+            #[serde(rename = "key")]
+            pub key: PreloadingAttemptKey,
+            #[serde(rename = "ruleSetIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub rule_set_ids: Vec<RuleSetId>,
+            #[serde(rename = "nodeIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub node_ids: Vec<super::dom::BackendNodeId>,
+        }
+        impl PreloadingAttemptSource {
+            pub fn new(
+                key: impl Into<PreloadingAttemptKey>,
+                rule_set_ids: Vec<RuleSetId>,
+                node_ids: Vec<super::dom::BackendNodeId>,
+            ) -> Self {
+                Self {
+                    key: key.into(),
+                    rule_set_ids,
+                    node_ids,
+                }
+            }
+        }
+        impl PreloadingAttemptSource {
+            pub fn builder() -> PreloadingAttemptSourceBuilder {
+                PreloadingAttemptSourceBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PreloadingAttemptSourceBuilder {
+            key: Option<PreloadingAttemptKey>,
+            rule_set_ids: Option<Vec<RuleSetId>>,
+            node_ids: Option<Vec<super::dom::BackendNodeId>>,
+        }
+        impl PreloadingAttemptSourceBuilder {
+            pub fn key(mut self, key: impl Into<PreloadingAttemptKey>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn rule_set_id(mut self, rule_set_id: impl Into<RuleSetId>) -> Self {
+                let v = self.rule_set_ids.get_or_insert(Vec::new());
+                v.push(rule_set_id.into());
+                self
+            }
+            pub fn rule_set_ids<I, S>(mut self, rule_set_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<RuleSetId>,
+            {
+                let v = self.rule_set_ids.get_or_insert(Vec::new());
+                for val in rule_set_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<super::dom::BackendNodeId>) -> Self {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                v.push(node_id.into());
+                self
+            }
+            pub fn node_ids<I, S>(mut self, node_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::dom::BackendNodeId>,
+            {
+                let v = self.node_ids.get_or_insert(Vec::new());
+                for val in node_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<PreloadingAttemptSource, String> {
+                Ok(PreloadingAttemptSource {
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    rule_set_ids: self.rule_set_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rule_set_ids))
+                    })?,
+                    node_ids: self.node_ids.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_ids))
+                    })?,
+                })
+            }
+        }
+        impl PreloadingAttemptSource {
+            pub const IDENTIFIER: &'static str = "Preload.PreloadingAttemptSource";
+        }
+        #[doc = "Chrome manages different types of preloads together using a\nconcept of preloading pipeline. For example, if a site uses a\nSpeculationRules for prerender, Chrome first starts a prefetch and\nthen upgrades it to prerender.\n\nCDP events for them are emitted separately but they share\n`PreloadPipelineId`.\n[PreloadPipelineId](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#type-PreloadPipelineId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct PreloadPipelineId(String);
+        impl PreloadPipelineId {
+            pub fn new(val: impl Into<String>) -> Self {
+                PreloadPipelineId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for PreloadPipelineId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<PreloadPipelineId> for String {
+            fn from(el: PreloadPipelineId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for PreloadPipelineId {
+            fn from(expr: String) -> Self {
+                PreloadPipelineId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for PreloadPipelineId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl PreloadPipelineId {
+            pub const IDENTIFIER: &'static str = "Preload.PreloadPipelineId";
+        }
+        #[doc = "List of FinalStatus reasons for Prerender2."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PrerenderFinalStatus {
+            #[serde(rename = "Activated")]
+            Activated,
+            #[serde(rename = "Destroyed")]
+            Destroyed,
+            #[serde(rename = "LowEndDevice")]
+            LowEndDevice,
+            #[serde(rename = "InvalidSchemeRedirect")]
+            InvalidSchemeRedirect,
+            #[serde(rename = "InvalidSchemeNavigation")]
+            InvalidSchemeNavigation,
+            #[serde(rename = "NavigationRequestBlockedByCsp")]
+            NavigationRequestBlockedByCsp,
+            #[serde(rename = "MojoBinderPolicy")]
+            MojoBinderPolicy,
+            #[serde(rename = "RendererProcessCrashed")]
+            RendererProcessCrashed,
+            #[serde(rename = "RendererProcessKilled")]
+            RendererProcessKilled,
+            #[serde(rename = "Download")]
+            Download,
+            #[serde(rename = "TriggerDestroyed")]
+            TriggerDestroyed,
+            #[serde(rename = "NavigationNotCommitted")]
+            NavigationNotCommitted,
+            #[serde(rename = "NavigationBadHttpStatus")]
+            NavigationBadHttpStatus,
+            #[serde(rename = "ClientCertRequested")]
+            ClientCertRequested,
+            #[serde(rename = "NavigationRequestNetworkError")]
+            NavigationRequestNetworkError,
+            #[serde(rename = "CancelAllHostsForTesting")]
+            CancelAllHostsForTesting,
+            #[serde(rename = "DidFailLoad")]
+            DidFailLoad,
+            #[serde(rename = "Stop")]
+            Stop,
+            #[serde(rename = "SslCertificateError")]
+            SslCertificateError,
+            #[serde(rename = "LoginAuthRequested")]
+            LoginAuthRequested,
+            #[serde(rename = "UaChangeRequiresReload")]
+            UaChangeRequiresReload,
+            #[serde(rename = "BlockedByClient")]
+            BlockedByClient,
+            #[serde(rename = "AudioOutputDeviceRequested")]
+            AudioOutputDeviceRequested,
+            #[serde(rename = "MixedContent")]
+            MixedContent,
+            #[serde(rename = "TriggerBackgrounded")]
+            TriggerBackgrounded,
+            #[serde(rename = "MemoryLimitExceeded")]
+            MemoryLimitExceeded,
+            #[serde(rename = "DataSaverEnabled")]
+            DataSaverEnabled,
+            #[serde(rename = "TriggerUrlHasEffectiveUrl")]
+            TriggerUrlHasEffectiveUrl,
+            #[serde(rename = "ActivatedBeforeStarted")]
+            ActivatedBeforeStarted,
+            #[serde(rename = "InactivePageRestriction")]
+            InactivePageRestriction,
+            #[serde(rename = "StartFailed")]
+            StartFailed,
+            #[serde(rename = "TimeoutBackgrounded")]
+            TimeoutBackgrounded,
+            #[serde(rename = "CrossSiteRedirectInInitialNavigation")]
+            CrossSiteRedirectInInitialNavigation,
+            #[serde(rename = "CrossSiteNavigationInInitialNavigation")]
+            CrossSiteNavigationInInitialNavigation,
+            #[serde(rename = "SameSiteCrossOriginRedirectNotOptInInInitialNavigation")]
+            SameSiteCrossOriginRedirectNotOptInInInitialNavigation,
+            #[serde(rename = "SameSiteCrossOriginNavigationNotOptInInInitialNavigation")]
+            SameSiteCrossOriginNavigationNotOptInInInitialNavigation,
+            #[serde(rename = "ActivationNavigationParameterMismatch")]
+            ActivationNavigationParameterMismatch,
+            #[serde(rename = "ActivatedInBackground")]
+            ActivatedInBackground,
+            #[serde(rename = "EmbedderHostDisallowed")]
+            EmbedderHostDisallowed,
+            #[serde(rename = "ActivationNavigationDestroyedBeforeSuccess")]
+            ActivationNavigationDestroyedBeforeSuccess,
+            #[serde(rename = "TabClosedByUserGesture")]
+            TabClosedByUserGesture,
+            #[serde(rename = "TabClosedWithoutUserGesture")]
+            TabClosedWithoutUserGesture,
+            #[serde(rename = "PrimaryMainFrameRendererProcessCrashed")]
+            PrimaryMainFrameRendererProcessCrashed,
+            #[serde(rename = "PrimaryMainFrameRendererProcessKilled")]
+            PrimaryMainFrameRendererProcessKilled,
+            #[serde(rename = "ActivationFramePolicyNotCompatible")]
+            ActivationFramePolicyNotCompatible,
+            #[serde(rename = "PreloadingDisabled")]
+            PreloadingDisabled,
+            #[serde(rename = "BatterySaverEnabled")]
+            BatterySaverEnabled,
+            #[serde(rename = "ActivatedDuringMainFrameNavigation")]
+            ActivatedDuringMainFrameNavigation,
+            #[serde(rename = "PreloadingUnsupportedByWebContents")]
+            PreloadingUnsupportedByWebContents,
+            #[serde(rename = "CrossSiteRedirectInMainFrameNavigation")]
+            CrossSiteRedirectInMainFrameNavigation,
+            #[serde(rename = "CrossSiteNavigationInMainFrameNavigation")]
+            CrossSiteNavigationInMainFrameNavigation,
+            #[serde(rename = "SameSiteCrossOriginRedirectNotOptInInMainFrameNavigation")]
+            SameSiteCrossOriginRedirectNotOptInInMainFrameNavigation,
+            #[serde(rename = "SameSiteCrossOriginNavigationNotOptInInMainFrameNavigation")]
+            SameSiteCrossOriginNavigationNotOptInInMainFrameNavigation,
+            #[serde(rename = "MemoryPressureOnTrigger")]
+            MemoryPressureOnTrigger,
+            #[serde(rename = "MemoryPressureAfterTriggered")]
+            MemoryPressureAfterTriggered,
+            #[serde(rename = "PrerenderingDisabledByDevTools")]
+            PrerenderingDisabledByDevTools,
+            #[serde(rename = "SpeculationRuleRemoved")]
+            SpeculationRuleRemoved,
+            #[serde(rename = "ActivatedWithAuxiliaryBrowsingContexts")]
+            ActivatedWithAuxiliaryBrowsingContexts,
+            #[serde(rename = "MaxNumOfRunningEagerPrerendersExceeded")]
+            MaxNumOfRunningEagerPrerendersExceeded,
+            #[serde(rename = "MaxNumOfRunningNonEagerPrerendersExceeded")]
+            MaxNumOfRunningNonEagerPrerendersExceeded,
+            #[serde(rename = "MaxNumOfRunningEmbedderPrerendersExceeded")]
+            MaxNumOfRunningEmbedderPrerendersExceeded,
+            #[serde(rename = "PrerenderingUrlHasEffectiveUrl")]
+            PrerenderingUrlHasEffectiveUrl,
+            #[serde(rename = "RedirectedPrerenderingUrlHasEffectiveUrl")]
+            RedirectedPrerenderingUrlHasEffectiveUrl,
+            #[serde(rename = "ActivationUrlHasEffectiveUrl")]
+            ActivationUrlHasEffectiveUrl,
+            #[serde(rename = "JavaScriptInterfaceAdded")]
+            JavaScriptInterfaceAdded,
+            #[serde(rename = "JavaScriptInterfaceRemoved")]
+            JavaScriptInterfaceRemoved,
+            #[serde(rename = "AllPrerenderingCanceled")]
+            AllPrerenderingCanceled,
+            #[serde(rename = "WindowClosed")]
+            WindowClosed,
+            #[serde(rename = "SlowNetwork")]
+            SlowNetwork,
+            #[serde(rename = "OtherPrerenderedPageActivated")]
+            OtherPrerenderedPageActivated,
+            #[serde(rename = "V8OptimizerDisabled")]
+            V8OptimizerDisabled,
+            #[serde(rename = "PrerenderFailedDuringPrefetch")]
+            PrerenderFailedDuringPrefetch,
+            #[serde(rename = "BrowsingDataRemoved")]
+            BrowsingDataRemoved,
+            #[serde(rename = "PrerenderHostReused")]
+            PrerenderHostReused,
+        }
+        impl AsRef<str> for PrerenderFinalStatus {
+            fn as_ref(&self) -> &str {
+                match self { PrerenderFinalStatus :: Activated => "Activated" , PrerenderFinalStatus :: Destroyed => "Destroyed" , PrerenderFinalStatus :: LowEndDevice => "LowEndDevice" , PrerenderFinalStatus :: InvalidSchemeRedirect => "InvalidSchemeRedirect" , PrerenderFinalStatus :: InvalidSchemeNavigation => "InvalidSchemeNavigation" , PrerenderFinalStatus :: NavigationRequestBlockedByCsp => "NavigationRequestBlockedByCsp" , PrerenderFinalStatus :: MojoBinderPolicy => "MojoBinderPolicy" , PrerenderFinalStatus :: RendererProcessCrashed => "RendererProcessCrashed" , PrerenderFinalStatus :: RendererProcessKilled => "RendererProcessKilled" , PrerenderFinalStatus :: Download => "Download" , PrerenderFinalStatus :: TriggerDestroyed => "TriggerDestroyed" , PrerenderFinalStatus :: NavigationNotCommitted => "NavigationNotCommitted" , PrerenderFinalStatus :: NavigationBadHttpStatus => "NavigationBadHttpStatus" , PrerenderFinalStatus :: ClientCertRequested => "ClientCertRequested" , PrerenderFinalStatus :: NavigationRequestNetworkError => "NavigationRequestNetworkError" , PrerenderFinalStatus :: CancelAllHostsForTesting => "CancelAllHostsForTesting" , PrerenderFinalStatus :: DidFailLoad => "DidFailLoad" , PrerenderFinalStatus :: Stop => "Stop" , PrerenderFinalStatus :: SslCertificateError => "SslCertificateError" , PrerenderFinalStatus :: LoginAuthRequested => "LoginAuthRequested" , PrerenderFinalStatus :: UaChangeRequiresReload => "UaChangeRequiresReload" , PrerenderFinalStatus :: BlockedByClient => "BlockedByClient" , PrerenderFinalStatus :: AudioOutputDeviceRequested => "AudioOutputDeviceRequested" , PrerenderFinalStatus :: MixedContent => "MixedContent" , PrerenderFinalStatus :: TriggerBackgrounded => "TriggerBackgrounded" , PrerenderFinalStatus :: MemoryLimitExceeded => "MemoryLimitExceeded" , PrerenderFinalStatus :: DataSaverEnabled => "DataSaverEnabled" , PrerenderFinalStatus :: TriggerUrlHasEffectiveUrl => "TriggerUrlHasEffectiveUrl" , PrerenderFinalStatus :: ActivatedBeforeStarted => "ActivatedBeforeStarted" , PrerenderFinalStatus :: InactivePageRestriction => "InactivePageRestriction" , PrerenderFinalStatus :: StartFailed => "StartFailed" , PrerenderFinalStatus :: TimeoutBackgrounded => "TimeoutBackgrounded" , PrerenderFinalStatus :: CrossSiteRedirectInInitialNavigation => "CrossSiteRedirectInInitialNavigation" , PrerenderFinalStatus :: CrossSiteNavigationInInitialNavigation => "CrossSiteNavigationInInitialNavigation" , PrerenderFinalStatus :: SameSiteCrossOriginRedirectNotOptInInInitialNavigation => "SameSiteCrossOriginRedirectNotOptInInInitialNavigation" , PrerenderFinalStatus :: SameSiteCrossOriginNavigationNotOptInInInitialNavigation => "SameSiteCrossOriginNavigationNotOptInInInitialNavigation" , PrerenderFinalStatus :: ActivationNavigationParameterMismatch => "ActivationNavigationParameterMismatch" , PrerenderFinalStatus :: ActivatedInBackground => "ActivatedInBackground" , PrerenderFinalStatus :: EmbedderHostDisallowed => "EmbedderHostDisallowed" , PrerenderFinalStatus :: ActivationNavigationDestroyedBeforeSuccess => "ActivationNavigationDestroyedBeforeSuccess" , PrerenderFinalStatus :: TabClosedByUserGesture => "TabClosedByUserGesture" , PrerenderFinalStatus :: TabClosedWithoutUserGesture => "TabClosedWithoutUserGesture" , PrerenderFinalStatus :: PrimaryMainFrameRendererProcessCrashed => "PrimaryMainFrameRendererProcessCrashed" , PrerenderFinalStatus :: PrimaryMainFrameRendererProcessKilled => "PrimaryMainFrameRendererProcessKilled" , PrerenderFinalStatus :: ActivationFramePolicyNotCompatible => "ActivationFramePolicyNotCompatible" , PrerenderFinalStatus :: PreloadingDisabled => "PreloadingDisabled" , PrerenderFinalStatus :: BatterySaverEnabled => "BatterySaverEnabled" , PrerenderFinalStatus :: ActivatedDuringMainFrameNavigation => "ActivatedDuringMainFrameNavigation" , PrerenderFinalStatus :: PreloadingUnsupportedByWebContents => "PreloadingUnsupportedByWebContents" , PrerenderFinalStatus :: CrossSiteRedirectInMainFrameNavigation => "CrossSiteRedirectInMainFrameNavigation" , PrerenderFinalStatus :: CrossSiteNavigationInMainFrameNavigation => "CrossSiteNavigationInMainFrameNavigation" , PrerenderFinalStatus :: SameSiteCrossOriginRedirectNotOptInInMainFrameNavigation => "SameSiteCrossOriginRedirectNotOptInInMainFrameNavigation" , PrerenderFinalStatus :: SameSiteCrossOriginNavigationNotOptInInMainFrameNavigation => "SameSiteCrossOriginNavigationNotOptInInMainFrameNavigation" , PrerenderFinalStatus :: MemoryPressureOnTrigger => "MemoryPressureOnTrigger" , PrerenderFinalStatus :: MemoryPressureAfterTriggered => "MemoryPressureAfterTriggered" , PrerenderFinalStatus :: PrerenderingDisabledByDevTools => "PrerenderingDisabledByDevTools" , PrerenderFinalStatus :: SpeculationRuleRemoved => "SpeculationRuleRemoved" , PrerenderFinalStatus :: ActivatedWithAuxiliaryBrowsingContexts => "ActivatedWithAuxiliaryBrowsingContexts" , PrerenderFinalStatus :: MaxNumOfRunningEagerPrerendersExceeded => "MaxNumOfRunningEagerPrerendersExceeded" , PrerenderFinalStatus :: MaxNumOfRunningNonEagerPrerendersExceeded => "MaxNumOfRunningNonEagerPrerendersExceeded" , PrerenderFinalStatus :: MaxNumOfRunningEmbedderPrerendersExceeded => "MaxNumOfRunningEmbedderPrerendersExceeded" , PrerenderFinalStatus :: PrerenderingUrlHasEffectiveUrl => "PrerenderingUrlHasEffectiveUrl" , PrerenderFinalStatus :: RedirectedPrerenderingUrlHasEffectiveUrl => "RedirectedPrerenderingUrlHasEffectiveUrl" , PrerenderFinalStatus :: ActivationUrlHasEffectiveUrl => "ActivationUrlHasEffectiveUrl" , PrerenderFinalStatus :: JavaScriptInterfaceAdded => "JavaScriptInterfaceAdded" , PrerenderFinalStatus :: JavaScriptInterfaceRemoved => "JavaScriptInterfaceRemoved" , PrerenderFinalStatus :: AllPrerenderingCanceled => "AllPrerenderingCanceled" , PrerenderFinalStatus :: WindowClosed => "WindowClosed" , PrerenderFinalStatus :: SlowNetwork => "SlowNetwork" , PrerenderFinalStatus :: OtherPrerenderedPageActivated => "OtherPrerenderedPageActivated" , PrerenderFinalStatus :: V8OptimizerDisabled => "V8OptimizerDisabled" , PrerenderFinalStatus :: PrerenderFailedDuringPrefetch => "PrerenderFailedDuringPrefetch" , PrerenderFinalStatus :: BrowsingDataRemoved => "BrowsingDataRemoved" , PrerenderFinalStatus :: PrerenderHostReused => "PrerenderHostReused" }
+            }
+        }
+        impl ::std::str::FromStr for PrerenderFinalStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s { "Activated" | "activated" => Ok (PrerenderFinalStatus :: Activated) , "Destroyed" | "destroyed" => Ok (PrerenderFinalStatus :: Destroyed) , "LowEndDevice" | "lowenddevice" => Ok (PrerenderFinalStatus :: LowEndDevice) , "InvalidSchemeRedirect" | "invalidschemeredirect" => Ok (PrerenderFinalStatus :: InvalidSchemeRedirect) , "InvalidSchemeNavigation" | "invalidschemenavigation" => Ok (PrerenderFinalStatus :: InvalidSchemeNavigation) , "NavigationRequestBlockedByCsp" | "navigationrequestblockedbycsp" => Ok (PrerenderFinalStatus :: NavigationRequestBlockedByCsp) , "MojoBinderPolicy" | "mojobinderpolicy" => Ok (PrerenderFinalStatus :: MojoBinderPolicy) , "RendererProcessCrashed" | "rendererprocesscrashed" => Ok (PrerenderFinalStatus :: RendererProcessCrashed) , "RendererProcessKilled" | "rendererprocesskilled" => Ok (PrerenderFinalStatus :: RendererProcessKilled) , "Download" | "download" => Ok (PrerenderFinalStatus :: Download) , "TriggerDestroyed" | "triggerdestroyed" => Ok (PrerenderFinalStatus :: TriggerDestroyed) , "NavigationNotCommitted" | "navigationnotcommitted" => Ok (PrerenderFinalStatus :: NavigationNotCommitted) , "NavigationBadHttpStatus" | "navigationbadhttpstatus" => Ok (PrerenderFinalStatus :: NavigationBadHttpStatus) , "ClientCertRequested" | "clientcertrequested" => Ok (PrerenderFinalStatus :: ClientCertRequested) , "NavigationRequestNetworkError" | "navigationrequestnetworkerror" => Ok (PrerenderFinalStatus :: NavigationRequestNetworkError) , "CancelAllHostsForTesting" | "cancelallhostsfortesting" => Ok (PrerenderFinalStatus :: CancelAllHostsForTesting) , "DidFailLoad" | "didfailload" => Ok (PrerenderFinalStatus :: DidFailLoad) , "Stop" | "stop" => Ok (PrerenderFinalStatus :: Stop) , "SslCertificateError" | "sslcertificateerror" => Ok (PrerenderFinalStatus :: SslCertificateError) , "LoginAuthRequested" | "loginauthrequested" => Ok (PrerenderFinalStatus :: LoginAuthRequested) , "UaChangeRequiresReload" | "uachangerequiresreload" => Ok (PrerenderFinalStatus :: UaChangeRequiresReload) , "BlockedByClient" | "blockedbyclient" => Ok (PrerenderFinalStatus :: BlockedByClient) , "AudioOutputDeviceRequested" | "audiooutputdevicerequested" => Ok (PrerenderFinalStatus :: AudioOutputDeviceRequested) , "MixedContent" | "mixedcontent" => Ok (PrerenderFinalStatus :: MixedContent) , "TriggerBackgrounded" | "triggerbackgrounded" => Ok (PrerenderFinalStatus :: TriggerBackgrounded) , "MemoryLimitExceeded" | "memorylimitexceeded" => Ok (PrerenderFinalStatus :: MemoryLimitExceeded) , "DataSaverEnabled" | "datasaverenabled" => Ok (PrerenderFinalStatus :: DataSaverEnabled) , "TriggerUrlHasEffectiveUrl" | "triggerurlhaseffectiveurl" => Ok (PrerenderFinalStatus :: TriggerUrlHasEffectiveUrl) , "ActivatedBeforeStarted" | "activatedbeforestarted" => Ok (PrerenderFinalStatus :: ActivatedBeforeStarted) , "InactivePageRestriction" | "inactivepagerestriction" => Ok (PrerenderFinalStatus :: InactivePageRestriction) , "StartFailed" | "startfailed" => Ok (PrerenderFinalStatus :: StartFailed) , "TimeoutBackgrounded" | "timeoutbackgrounded" => Ok (PrerenderFinalStatus :: TimeoutBackgrounded) , "CrossSiteRedirectInInitialNavigation" | "crosssiteredirectininitialnavigation" => Ok (PrerenderFinalStatus :: CrossSiteRedirectInInitialNavigation) , "CrossSiteNavigationInInitialNavigation" | "crosssitenavigationininitialnavigation" => Ok (PrerenderFinalStatus :: CrossSiteNavigationInInitialNavigation) , "SameSiteCrossOriginRedirectNotOptInInInitialNavigation" | "samesitecrossoriginredirectnotoptinininitialnavigation" => Ok (PrerenderFinalStatus :: SameSiteCrossOriginRedirectNotOptInInInitialNavigation) , "SameSiteCrossOriginNavigationNotOptInInInitialNavigation" | "samesitecrossoriginnavigationnotoptinininitialnavigation" => Ok (PrerenderFinalStatus :: SameSiteCrossOriginNavigationNotOptInInInitialNavigation) , "ActivationNavigationParameterMismatch" | "activationnavigationparametermismatch" => Ok (PrerenderFinalStatus :: ActivationNavigationParameterMismatch) , "ActivatedInBackground" | "activatedinbackground" => Ok (PrerenderFinalStatus :: ActivatedInBackground) , "EmbedderHostDisallowed" | "embedderhostdisallowed" => Ok (PrerenderFinalStatus :: EmbedderHostDisallowed) , "ActivationNavigationDestroyedBeforeSuccess" | "activationnavigationdestroyedbeforesuccess" => Ok (PrerenderFinalStatus :: ActivationNavigationDestroyedBeforeSuccess) , "TabClosedByUserGesture" | "tabclosedbyusergesture" => Ok (PrerenderFinalStatus :: TabClosedByUserGesture) , "TabClosedWithoutUserGesture" | "tabclosedwithoutusergesture" => Ok (PrerenderFinalStatus :: TabClosedWithoutUserGesture) , "PrimaryMainFrameRendererProcessCrashed" | "primarymainframerendererprocesscrashed" => Ok (PrerenderFinalStatus :: PrimaryMainFrameRendererProcessCrashed) , "PrimaryMainFrameRendererProcessKilled" | "primarymainframerendererprocesskilled" => Ok (PrerenderFinalStatus :: PrimaryMainFrameRendererProcessKilled) , "ActivationFramePolicyNotCompatible" | "activationframepolicynotcompatible" => Ok (PrerenderFinalStatus :: ActivationFramePolicyNotCompatible) , "PreloadingDisabled" | "preloadingdisabled" => Ok (PrerenderFinalStatus :: PreloadingDisabled) , "BatterySaverEnabled" | "batterysaverenabled" => Ok (PrerenderFinalStatus :: BatterySaverEnabled) , "ActivatedDuringMainFrameNavigation" | "activatedduringmainframenavigation" => Ok (PrerenderFinalStatus :: ActivatedDuringMainFrameNavigation) , "PreloadingUnsupportedByWebContents" | "preloadingunsupportedbywebcontents" => Ok (PrerenderFinalStatus :: PreloadingUnsupportedByWebContents) , "CrossSiteRedirectInMainFrameNavigation" | "crosssiteredirectinmainframenavigation" => Ok (PrerenderFinalStatus :: CrossSiteRedirectInMainFrameNavigation) , "CrossSiteNavigationInMainFrameNavigation" | "crosssitenavigationinmainframenavigation" => Ok (PrerenderFinalStatus :: CrossSiteNavigationInMainFrameNavigation) , "SameSiteCrossOriginRedirectNotOptInInMainFrameNavigation" | "samesitecrossoriginredirectnotoptininmainframenavigation" => Ok (PrerenderFinalStatus :: SameSiteCrossOriginRedirectNotOptInInMainFrameNavigation) , "SameSiteCrossOriginNavigationNotOptInInMainFrameNavigation" | "samesitecrossoriginnavigationnotoptininmainframenavigation" => Ok (PrerenderFinalStatus :: SameSiteCrossOriginNavigationNotOptInInMainFrameNavigation) , "MemoryPressureOnTrigger" | "memorypressureontrigger" => Ok (PrerenderFinalStatus :: MemoryPressureOnTrigger) , "MemoryPressureAfterTriggered" | "memorypressureaftertriggered" => Ok (PrerenderFinalStatus :: MemoryPressureAfterTriggered) , "PrerenderingDisabledByDevTools" | "prerenderingdisabledbydevtools" => Ok (PrerenderFinalStatus :: PrerenderingDisabledByDevTools) , "SpeculationRuleRemoved" | "speculationruleremoved" => Ok (PrerenderFinalStatus :: SpeculationRuleRemoved) , "ActivatedWithAuxiliaryBrowsingContexts" | "activatedwithauxiliarybrowsingcontexts" => Ok (PrerenderFinalStatus :: ActivatedWithAuxiliaryBrowsingContexts) , "MaxNumOfRunningEagerPrerendersExceeded" | "maxnumofrunningeagerprerendersexceeded" => Ok (PrerenderFinalStatus :: MaxNumOfRunningEagerPrerendersExceeded) , "MaxNumOfRunningNonEagerPrerendersExceeded" | "maxnumofrunningnoneagerprerendersexceeded" => Ok (PrerenderFinalStatus :: MaxNumOfRunningNonEagerPrerendersExceeded) , "MaxNumOfRunningEmbedderPrerendersExceeded" | "maxnumofrunningembedderprerendersexceeded" => Ok (PrerenderFinalStatus :: MaxNumOfRunningEmbedderPrerendersExceeded) , "PrerenderingUrlHasEffectiveUrl" | "prerenderingurlhaseffectiveurl" => Ok (PrerenderFinalStatus :: PrerenderingUrlHasEffectiveUrl) , "RedirectedPrerenderingUrlHasEffectiveUrl" | "redirectedprerenderingurlhaseffectiveurl" => Ok (PrerenderFinalStatus :: RedirectedPrerenderingUrlHasEffectiveUrl) , "ActivationUrlHasEffectiveUrl" | "activationurlhaseffectiveurl" => Ok (PrerenderFinalStatus :: ActivationUrlHasEffectiveUrl) , "JavaScriptInterfaceAdded" | "javascriptinterfaceadded" => Ok (PrerenderFinalStatus :: JavaScriptInterfaceAdded) , "JavaScriptInterfaceRemoved" | "javascriptinterfaceremoved" => Ok (PrerenderFinalStatus :: JavaScriptInterfaceRemoved) , "AllPrerenderingCanceled" | "allprerenderingcanceled" => Ok (PrerenderFinalStatus :: AllPrerenderingCanceled) , "WindowClosed" | "windowclosed" => Ok (PrerenderFinalStatus :: WindowClosed) , "SlowNetwork" | "slownetwork" => Ok (PrerenderFinalStatus :: SlowNetwork) , "OtherPrerenderedPageActivated" | "otherprerenderedpageactivated" => Ok (PrerenderFinalStatus :: OtherPrerenderedPageActivated) , "V8OptimizerDisabled" | "v8optimizerdisabled" => Ok (PrerenderFinalStatus :: V8OptimizerDisabled) , "PrerenderFailedDuringPrefetch" | "prerenderfailedduringprefetch" => Ok (PrerenderFinalStatus :: PrerenderFailedDuringPrefetch) , "BrowsingDataRemoved" | "browsingdataremoved" => Ok (PrerenderFinalStatus :: BrowsingDataRemoved) , "PrerenderHostReused" | "prerenderhostreused" => Ok (PrerenderFinalStatus :: PrerenderHostReused) , _ => Err (s . to_string ()) }
+            }
+        }
+        #[doc = "Preloading status values, see also PreloadingTriggeringOutcome. This\nstatus is shared by prefetchStatusUpdated and prerenderStatusUpdated."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PreloadingStatus {
+            #[serde(rename = "Pending")]
+            Pending,
+            #[serde(rename = "Running")]
+            Running,
+            #[serde(rename = "Ready")]
+            Ready,
+            #[serde(rename = "Success")]
+            Success,
+            #[serde(rename = "Failure")]
+            Failure,
+            #[doc = "PreloadingTriggeringOutcome which not used by prefetch nor prerender."]
+            #[serde(rename = "NotSupported")]
+            NotSupported,
+        }
+        impl AsRef<str> for PreloadingStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PreloadingStatus::Pending => "Pending",
+                    PreloadingStatus::Running => "Running",
+                    PreloadingStatus::Ready => "Ready",
+                    PreloadingStatus::Success => "Success",
+                    PreloadingStatus::Failure => "Failure",
+                    PreloadingStatus::NotSupported => "NotSupported",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PreloadingStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "Pending" | "pending" => Ok(PreloadingStatus::Pending),
+                    "Running" | "running" => Ok(PreloadingStatus::Running),
+                    "Ready" | "ready" => Ok(PreloadingStatus::Ready),
+                    "Success" | "success" => Ok(PreloadingStatus::Success),
+                    "Failure" | "failure" => Ok(PreloadingStatus::Failure),
+                    "NotSupported" | "notsupported" => Ok(PreloadingStatus::NotSupported),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "TODO(https://crbug.com/1384419): revisit the list of PrefetchStatus and\nfilter out the ones that aren't necessary to the developers."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum PrefetchStatus {
+            #[doc = "Prefetch is not disabled by PrefetchHeldback."]
+            #[serde(rename = "PrefetchAllowed")]
+            PrefetchAllowed,
+            #[serde(rename = "PrefetchFailedIneligibleRedirect")]
+            PrefetchFailedIneligibleRedirect,
+            #[serde(rename = "PrefetchFailedInvalidRedirect")]
+            PrefetchFailedInvalidRedirect,
+            #[serde(rename = "PrefetchFailedMIMENotSupported")]
+            PrefetchFailedMimeNotSupported,
+            #[serde(rename = "PrefetchFailedNetError")]
+            PrefetchFailedNetError,
+            #[serde(rename = "PrefetchFailedNon2XX")]
+            PrefetchFailedNon2Xx,
+            #[serde(rename = "PrefetchEvictedAfterBrowsingDataRemoved")]
+            PrefetchEvictedAfterBrowsingDataRemoved,
+            #[serde(rename = "PrefetchEvictedAfterCandidateRemoved")]
+            PrefetchEvictedAfterCandidateRemoved,
+            #[serde(rename = "PrefetchEvictedForNewerPrefetch")]
+            PrefetchEvictedForNewerPrefetch,
+            #[serde(rename = "PrefetchHeldback")]
+            PrefetchHeldback,
+            #[doc = "A previous prefetch to the origin got a HTTP 503 response with an\nRetry-After header that has no elapsed yet."]
+            #[serde(rename = "PrefetchIneligibleRetryAfter")]
+            PrefetchIneligibleRetryAfter,
+            #[serde(rename = "PrefetchIsPrivacyDecoy")]
+            PrefetchIsPrivacyDecoy,
+            #[serde(rename = "PrefetchIsStale")]
+            PrefetchIsStale,
+            #[serde(rename = "PrefetchNotEligibleBrowserContextOffTheRecord")]
+            PrefetchNotEligibleBrowserContextOffTheRecord,
+            #[serde(rename = "PrefetchNotEligibleDataSaverEnabled")]
+            PrefetchNotEligibleDataSaverEnabled,
+            #[serde(rename = "PrefetchNotEligibleExistingProxy")]
+            PrefetchNotEligibleExistingProxy,
+            #[serde(rename = "PrefetchNotEligibleHostIsNonUnique")]
+            PrefetchNotEligibleHostIsNonUnique,
+            #[serde(rename = "PrefetchNotEligibleNonDefaultStoragePartition")]
+            PrefetchNotEligibleNonDefaultStoragePartition,
+            #[serde(rename = "PrefetchNotEligibleSameSiteCrossOriginPrefetchRequiredProxy")]
+            PrefetchNotEligibleSameSiteCrossOriginPrefetchRequiredProxy,
+            #[serde(rename = "PrefetchNotEligibleSchemeIsNotHttps")]
+            PrefetchNotEligibleSchemeIsNotHttps,
+            #[serde(rename = "PrefetchNotEligibleUserHasCookies")]
+            PrefetchNotEligibleUserHasCookies,
+            #[serde(rename = "PrefetchNotEligibleUserHasServiceWorker")]
+            PrefetchNotEligibleUserHasServiceWorker,
+            #[serde(rename = "PrefetchNotEligibleUserHasServiceWorkerNoFetchHandler")]
+            PrefetchNotEligibleUserHasServiceWorkerNoFetchHandler,
+            #[serde(rename = "PrefetchNotEligibleRedirectFromServiceWorker")]
+            PrefetchNotEligibleRedirectFromServiceWorker,
+            #[serde(rename = "PrefetchNotEligibleRedirectToServiceWorker")]
+            PrefetchNotEligibleRedirectToServiceWorker,
+            #[serde(rename = "PrefetchNotEligibleBatterySaverEnabled")]
+            PrefetchNotEligibleBatterySaverEnabled,
+            #[serde(rename = "PrefetchNotEligiblePreloadingDisabled")]
+            PrefetchNotEligiblePreloadingDisabled,
+            #[serde(rename = "PrefetchNotFinishedInTime")]
+            PrefetchNotFinishedInTime,
+            #[serde(rename = "PrefetchNotStarted")]
+            PrefetchNotStarted,
+            #[serde(rename = "PrefetchNotUsedCookiesChanged")]
+            PrefetchNotUsedCookiesChanged,
+            #[serde(rename = "PrefetchProxyNotAvailable")]
+            PrefetchProxyNotAvailable,
+            #[doc = "The response of the prefetch is used for the next navigation. This is\nthe final successful state."]
+            #[serde(rename = "PrefetchResponseUsed")]
+            PrefetchResponseUsed,
+            #[doc = "The prefetch finished successfully but was never used."]
+            #[serde(rename = "PrefetchSuccessfulButNotUsed")]
+            PrefetchSuccessfulButNotUsed,
+            #[serde(rename = "PrefetchNotUsedProbeFailed")]
+            PrefetchNotUsedProbeFailed,
+        }
+        impl AsRef<str> for PrefetchStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    PrefetchStatus::PrefetchAllowed => "PrefetchAllowed",
+                    PrefetchStatus::PrefetchFailedIneligibleRedirect => {
+                        "PrefetchFailedIneligibleRedirect"
+                    }
+                    PrefetchStatus::PrefetchFailedInvalidRedirect => {
+                        "PrefetchFailedInvalidRedirect"
+                    }
+                    PrefetchStatus::PrefetchFailedMimeNotSupported => {
+                        "PrefetchFailedMIMENotSupported"
+                    }
+                    PrefetchStatus::PrefetchFailedNetError => "PrefetchFailedNetError",
+                    PrefetchStatus::PrefetchFailedNon2Xx => "PrefetchFailedNon2XX",
+                    PrefetchStatus::PrefetchEvictedAfterBrowsingDataRemoved => {
+                        "PrefetchEvictedAfterBrowsingDataRemoved"
+                    }
+                    PrefetchStatus::PrefetchEvictedAfterCandidateRemoved => {
+                        "PrefetchEvictedAfterCandidateRemoved"
+                    }
+                    PrefetchStatus::PrefetchEvictedForNewerPrefetch => {
+                        "PrefetchEvictedForNewerPrefetch"
+                    }
+                    PrefetchStatus::PrefetchHeldback => "PrefetchHeldback",
+                    PrefetchStatus::PrefetchIneligibleRetryAfter => "PrefetchIneligibleRetryAfter",
+                    PrefetchStatus::PrefetchIsPrivacyDecoy => "PrefetchIsPrivacyDecoy",
+                    PrefetchStatus::PrefetchIsStale => "PrefetchIsStale",
+                    PrefetchStatus::PrefetchNotEligibleBrowserContextOffTheRecord => {
+                        "PrefetchNotEligibleBrowserContextOffTheRecord"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleDataSaverEnabled => {
+                        "PrefetchNotEligibleDataSaverEnabled"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleExistingProxy => {
+                        "PrefetchNotEligibleExistingProxy"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleHostIsNonUnique => {
+                        "PrefetchNotEligibleHostIsNonUnique"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleNonDefaultStoragePartition => {
+                        "PrefetchNotEligibleNonDefaultStoragePartition"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleSameSiteCrossOriginPrefetchRequiredProxy => {
+                        "PrefetchNotEligibleSameSiteCrossOriginPrefetchRequiredProxy"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleSchemeIsNotHttps => {
+                        "PrefetchNotEligibleSchemeIsNotHttps"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleUserHasCookies => {
+                        "PrefetchNotEligibleUserHasCookies"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleUserHasServiceWorker => {
+                        "PrefetchNotEligibleUserHasServiceWorker"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleUserHasServiceWorkerNoFetchHandler => {
+                        "PrefetchNotEligibleUserHasServiceWorkerNoFetchHandler"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleRedirectFromServiceWorker => {
+                        "PrefetchNotEligibleRedirectFromServiceWorker"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleRedirectToServiceWorker => {
+                        "PrefetchNotEligibleRedirectToServiceWorker"
+                    }
+                    PrefetchStatus::PrefetchNotEligibleBatterySaverEnabled => {
+                        "PrefetchNotEligibleBatterySaverEnabled"
+                    }
+                    PrefetchStatus::PrefetchNotEligiblePreloadingDisabled => {
+                        "PrefetchNotEligiblePreloadingDisabled"
+                    }
+                    PrefetchStatus::PrefetchNotFinishedInTime => "PrefetchNotFinishedInTime",
+                    PrefetchStatus::PrefetchNotStarted => "PrefetchNotStarted",
+                    PrefetchStatus::PrefetchNotUsedCookiesChanged => {
+                        "PrefetchNotUsedCookiesChanged"
+                    }
+                    PrefetchStatus::PrefetchProxyNotAvailable => "PrefetchProxyNotAvailable",
+                    PrefetchStatus::PrefetchResponseUsed => "PrefetchResponseUsed",
+                    PrefetchStatus::PrefetchSuccessfulButNotUsed => "PrefetchSuccessfulButNotUsed",
+                    PrefetchStatus::PrefetchNotUsedProbeFailed => "PrefetchNotUsedProbeFailed",
+                }
+            }
+        }
+        impl ::std::str::FromStr for PrefetchStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "PrefetchAllowed" | "prefetchallowed" => Ok(PrefetchStatus::PrefetchAllowed),
+                    "PrefetchFailedIneligibleRedirect" | "prefetchfailedineligibleredirect" => {
+                        Ok(PrefetchStatus::PrefetchFailedIneligibleRedirect)
+                    }
+                    "PrefetchFailedInvalidRedirect" | "prefetchfailedinvalidredirect" => {
+                        Ok(PrefetchStatus::PrefetchFailedInvalidRedirect)
+                    }
+                    "PrefetchFailedMIMENotSupported"
+                    | "PrefetchFailedMimeNotSupported"
+                    | "prefetchfailedmimenotsupported" => {
+                        Ok(PrefetchStatus::PrefetchFailedMimeNotSupported)
+                    }
+                    "PrefetchFailedNetError" | "prefetchfailedneterror" => {
+                        Ok(PrefetchStatus::PrefetchFailedNetError)
+                    }
+                    "PrefetchFailedNon2XX" | "PrefetchFailedNon2Xx" | "prefetchfailednon2xx" => {
+                        Ok(PrefetchStatus::PrefetchFailedNon2Xx)
+                    }
+                    "PrefetchEvictedAfterBrowsingDataRemoved"
+                    | "prefetchevictedafterbrowsingdataremoved" => {
+                        Ok(PrefetchStatus::PrefetchEvictedAfterBrowsingDataRemoved)
+                    }
+                    "PrefetchEvictedAfterCandidateRemoved"
+                    | "prefetchevictedaftercandidateremoved" => {
+                        Ok(PrefetchStatus::PrefetchEvictedAfterCandidateRemoved)
+                    }
+                    "PrefetchEvictedForNewerPrefetch" | "prefetchevictedfornewerprefetch" => {
+                        Ok(PrefetchStatus::PrefetchEvictedForNewerPrefetch)
+                    }
+                    "PrefetchHeldback" | "prefetchheldback" => Ok(PrefetchStatus::PrefetchHeldback),
+                    "PrefetchIneligibleRetryAfter" | "prefetchineligibleretryafter" => {
+                        Ok(PrefetchStatus::PrefetchIneligibleRetryAfter)
+                    }
+                    "PrefetchIsPrivacyDecoy" | "prefetchisprivacydecoy" => {
+                        Ok(PrefetchStatus::PrefetchIsPrivacyDecoy)
+                    }
+                    "PrefetchIsStale" | "prefetchisstale" => Ok(PrefetchStatus::PrefetchIsStale),
+                    "PrefetchNotEligibleBrowserContextOffTheRecord"
+                    | "prefetchnoteligiblebrowsercontextofftherecord" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleBrowserContextOffTheRecord)
+                    }
+                    "PrefetchNotEligibleDataSaverEnabled"
+                    | "prefetchnoteligibledatasaverenabled" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleDataSaverEnabled)
+                    }
+                    "PrefetchNotEligibleExistingProxy" | "prefetchnoteligibleexistingproxy" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleExistingProxy)
+                    }
+                    "PrefetchNotEligibleHostIsNonUnique" | "prefetchnoteligiblehostisnonunique" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleHostIsNonUnique)
+                    }
+                    "PrefetchNotEligibleNonDefaultStoragePartition"
+                    | "prefetchnoteligiblenondefaultstoragepartition" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleNonDefaultStoragePartition)
+                    }
+                    "PrefetchNotEligibleSameSiteCrossOriginPrefetchRequiredProxy"
+                    | "prefetchnoteligiblesamesitecrossoriginprefetchrequiredproxy" => Ok(
+                        PrefetchStatus::PrefetchNotEligibleSameSiteCrossOriginPrefetchRequiredProxy,
+                    ),
+                    "PrefetchNotEligibleSchemeIsNotHttps"
+                    | "prefetchnoteligibleschemeisnothttps" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleSchemeIsNotHttps)
+                    }
+                    "PrefetchNotEligibleUserHasCookies" | "prefetchnoteligibleuserhascookies" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleUserHasCookies)
+                    }
+                    "PrefetchNotEligibleUserHasServiceWorker"
+                    | "prefetchnoteligibleuserhasserviceworker" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleUserHasServiceWorker)
+                    }
+                    "PrefetchNotEligibleUserHasServiceWorkerNoFetchHandler"
+                    | "prefetchnoteligibleuserhasserviceworkernofetchhandler" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleUserHasServiceWorkerNoFetchHandler)
+                    }
+                    "PrefetchNotEligibleRedirectFromServiceWorker"
+                    | "prefetchnoteligibleredirectfromserviceworker" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleRedirectFromServiceWorker)
+                    }
+                    "PrefetchNotEligibleRedirectToServiceWorker"
+                    | "prefetchnoteligibleredirecttoserviceworker" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleRedirectToServiceWorker)
+                    }
+                    "PrefetchNotEligibleBatterySaverEnabled"
+                    | "prefetchnoteligiblebatterysaverenabled" => {
+                        Ok(PrefetchStatus::PrefetchNotEligibleBatterySaverEnabled)
+                    }
+                    "PrefetchNotEligiblePreloadingDisabled"
+                    | "prefetchnoteligiblepreloadingdisabled" => {
+                        Ok(PrefetchStatus::PrefetchNotEligiblePreloadingDisabled)
+                    }
+                    "PrefetchNotFinishedInTime" | "prefetchnotfinishedintime" => {
+                        Ok(PrefetchStatus::PrefetchNotFinishedInTime)
+                    }
+                    "PrefetchNotStarted" | "prefetchnotstarted" => {
+                        Ok(PrefetchStatus::PrefetchNotStarted)
+                    }
+                    "PrefetchNotUsedCookiesChanged" | "prefetchnotusedcookieschanged" => {
+                        Ok(PrefetchStatus::PrefetchNotUsedCookiesChanged)
+                    }
+                    "PrefetchProxyNotAvailable" | "prefetchproxynotavailable" => {
+                        Ok(PrefetchStatus::PrefetchProxyNotAvailable)
+                    }
+                    "PrefetchResponseUsed" | "prefetchresponseused" => {
+                        Ok(PrefetchStatus::PrefetchResponseUsed)
+                    }
+                    "PrefetchSuccessfulButNotUsed" | "prefetchsuccessfulbutnotused" => {
+                        Ok(PrefetchStatus::PrefetchSuccessfulButNotUsed)
+                    }
+                    "PrefetchNotUsedProbeFailed" | "prefetchnotusedprobefailed" => {
+                        Ok(PrefetchStatus::PrefetchNotUsedProbeFailed)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Information of headers to be displayed when the header mismatch occurred.\n[PrerenderMismatchedHeaders](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#type-PrerenderMismatchedHeaders)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct PrerenderMismatchedHeaders {
+            #[serde(rename = "headerName")]
+            pub header_name: String,
+            #[serde(rename = "initialValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub initial_value: Option<String>,
+            #[serde(rename = "activationValue")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub activation_value: Option<String>,
+        }
+        impl PrerenderMismatchedHeaders {
+            pub fn new(header_name: impl Into<String>) -> Self {
+                Self {
+                    header_name: header_name.into(),
+                    initial_value: None,
+                    activation_value: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for PrerenderMismatchedHeaders {
+            fn from(url: T) -> Self {
+                PrerenderMismatchedHeaders::new(url)
+            }
+        }
+        impl PrerenderMismatchedHeaders {
+            pub fn builder() -> PrerenderMismatchedHeadersBuilder {
+                PrerenderMismatchedHeadersBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct PrerenderMismatchedHeadersBuilder {
+            header_name: Option<String>,
+            initial_value: Option<String>,
+            activation_value: Option<String>,
+        }
+        impl PrerenderMismatchedHeadersBuilder {
+            pub fn header_name(mut self, header_name: impl Into<String>) -> Self {
+                self.header_name = Some(header_name.into());
+                self
+            }
+            pub fn initial_value(mut self, initial_value: impl Into<String>) -> Self {
+                self.initial_value = Some(initial_value.into());
+                self
+            }
+            pub fn activation_value(mut self, activation_value: impl Into<String>) -> Self {
+                self.activation_value = Some(activation_value.into());
+                self
+            }
+            pub fn build(self) -> Result<PrerenderMismatchedHeaders, String> {
+                Ok(PrerenderMismatchedHeaders {
+                    header_name: self.header_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(header_name))
+                    })?,
+                    initial_value: self.initial_value,
+                    activation_value: self.activation_value,
+                })
+            }
+        }
+        impl PrerenderMismatchedHeaders {
+            pub const IDENTIFIER: &'static str = "Preload.PrerenderMismatchedHeaders";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Preload.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Preload.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Upsert. Currently, it is only emitted when a rule set added.\n[ruleSetUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#event-ruleSetUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventRuleSetUpdated {
+            #[serde(rename = "ruleSet")]
+            pub rule_set: RuleSet,
+        }
+        impl EventRuleSetUpdated {
+            pub const IDENTIFIER: &'static str = "Preload.ruleSetUpdated";
+        }
+        impl chromiumoxide_types::Method for EventRuleSetUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventRuleSetUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventRuleSetRemoved {
+            #[serde(rename = "id")]
+            pub id: RuleSetId,
+        }
+        impl EventRuleSetRemoved {
+            pub const IDENTIFIER: &'static str = "Preload.ruleSetRemoved";
+        }
+        impl chromiumoxide_types::Method for EventRuleSetRemoved {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventRuleSetRemoved {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a preload enabled state is updated.\n[preloadEnabledStateUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#event-preloadEnabledStateUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPreloadEnabledStateUpdated {
+            #[serde(rename = "disabledByPreference")]
+            pub disabled_by_preference: bool,
+            #[serde(rename = "disabledByDataSaver")]
+            pub disabled_by_data_saver: bool,
+            #[serde(rename = "disabledByBatterySaver")]
+            pub disabled_by_battery_saver: bool,
+            #[serde(rename = "disabledByHoldbackPrefetchSpeculationRules")]
+            pub disabled_by_holdback_prefetch_speculation_rules: bool,
+            #[serde(rename = "disabledByHoldbackPrerenderSpeculationRules")]
+            pub disabled_by_holdback_prerender_speculation_rules: bool,
+        }
+        impl EventPreloadEnabledStateUpdated {
+            pub const IDENTIFIER: &'static str = "Preload.preloadEnabledStateUpdated";
+        }
+        impl chromiumoxide_types::Method for EventPreloadEnabledStateUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPreloadEnabledStateUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a prefetch attempt is updated.\n[prefetchStatusUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#event-prefetchStatusUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPrefetchStatusUpdated {
+            #[serde(rename = "key")]
+            pub key: PreloadingAttemptKey,
+            #[serde(rename = "pipelineId")]
+            pub pipeline_id: PreloadPipelineId,
+            #[doc = "The frame id of the frame initiating prefetch."]
+            #[serde(rename = "initiatingFrameId")]
+            pub initiating_frame_id: super::page::FrameId,
+            #[serde(rename = "prefetchUrl")]
+            pub prefetch_url: String,
+            #[serde(rename = "status")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub status: PreloadingStatus,
+            #[serde(rename = "prefetchStatus")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub prefetch_status: PrefetchStatus,
+            #[serde(rename = "requestId")]
+            pub request_id: super::network::RequestId,
+        }
+        impl EventPrefetchStatusUpdated {
+            pub const IDENTIFIER: &'static str = "Preload.prefetchStatusUpdated";
+        }
+        impl chromiumoxide_types::Method for EventPrefetchStatusUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPrefetchStatusUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fired when a prerender attempt is updated.\n[prerenderStatusUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#event-prerenderStatusUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPrerenderStatusUpdated {
+            #[serde(rename = "key")]
+            pub key: PreloadingAttemptKey,
+            #[serde(rename = "pipelineId")]
+            pub pipeline_id: PreloadPipelineId,
+            #[serde(rename = "status")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub status: PreloadingStatus,
+            #[serde(rename = "prerenderStatus")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub prerender_status: Option<PrerenderFinalStatus>,
+            #[doc = "This is used to give users more information about the name of Mojo interface\nthat is incompatible with prerender and has caused the cancellation of the attempt."]
+            #[serde(rename = "disallowedMojoInterface")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub disallowed_mojo_interface: Option<String>,
+            #[serde(rename = "mismatchedHeaders")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub mismatched_headers: Option<Vec<PrerenderMismatchedHeaders>>,
+        }
+        impl EventPrerenderStatusUpdated {
+            pub const IDENTIFIER: &'static str = "Preload.prerenderStatusUpdated";
+        }
+        impl chromiumoxide_types::Method for EventPrerenderStatusUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPrerenderStatusUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Send a list of sources for all preloading attempts in a document.\n[preloadingAttemptSourcesUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Preload/#event-preloadingAttemptSourcesUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventPreloadingAttemptSourcesUpdated {
+            #[serde(rename = "loaderId")]
+            pub loader_id: super::network::LoaderId,
+            #[serde(rename = "preloadingAttemptSources")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub preloading_attempt_sources: Vec<PreloadingAttemptSource>,
+        }
+        impl EventPreloadingAttemptSourcesUpdated {
+            pub const IDENTIFIER: &'static str = "Preload.preloadingAttemptSourcesUpdated";
+        }
+        impl chromiumoxide_types::Method for EventPreloadingAttemptSourcesUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventPreloadingAttemptSourcesUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod security {
+        use serde::{Deserialize, Serialize};
+        #[doc = "An internal certificate ID value.\n[CertificateId](https://chromedevtools.github.io/devtools-protocol/tot/Security/#type-CertificateId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Copy, Hash)]
+        pub struct CertificateId(i64);
+        impl CertificateId {
+            pub fn new(val: impl Into<i64>) -> Self {
+                CertificateId(val.into())
+            }
+            pub fn inner(&self) -> &i64 {
+                &self.0
+            }
+        }
+        impl CertificateId {
+            pub const IDENTIFIER: &'static str = "Security.CertificateId";
+        }
+        #[doc = "A description of mixed content (HTTP resources on HTTPS pages), as defined by\nhttps://www.w3.org/TR/mixed-content/#categories"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum MixedContentType {
+            #[serde(rename = "blockable")]
+            Blockable,
+            #[serde(rename = "optionally-blockable")]
+            OptionallyBlockable,
+            #[serde(rename = "none")]
+            None,
+        }
+        impl AsRef<str> for MixedContentType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    MixedContentType::Blockable => "blockable",
+                    MixedContentType::OptionallyBlockable => "optionally-blockable",
+                    MixedContentType::None => "none",
+                }
+            }
+        }
+        impl ::std::str::FromStr for MixedContentType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "blockable" | "Blockable" => Ok(MixedContentType::Blockable),
+                    "optionally-blockable" | "OptionallyBlockable" => {
+                        Ok(MixedContentType::OptionallyBlockable)
+                    }
+                    "none" | "None" => Ok(MixedContentType::None),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "The security level of a page or resource."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SecurityState {
+            #[serde(rename = "unknown")]
+            Unknown,
+            #[serde(rename = "neutral")]
+            Neutral,
+            #[serde(rename = "insecure")]
+            Insecure,
+            #[serde(rename = "secure")]
+            Secure,
+            #[serde(rename = "info")]
+            Info,
+            #[serde(rename = "insecure-broken")]
+            InsecureBroken,
+        }
+        impl AsRef<str> for SecurityState {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SecurityState::Unknown => "unknown",
+                    SecurityState::Neutral => "neutral",
+                    SecurityState::Insecure => "insecure",
+                    SecurityState::Secure => "secure",
+                    SecurityState::Info => "info",
+                    SecurityState::InsecureBroken => "insecure-broken",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SecurityState {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "unknown" | "Unknown" => Ok(SecurityState::Unknown),
+                    "neutral" | "Neutral" => Ok(SecurityState::Neutral),
+                    "insecure" | "Insecure" => Ok(SecurityState::Insecure),
+                    "secure" | "Secure" => Ok(SecurityState::Secure),
+                    "info" | "Info" => Ok(SecurityState::Info),
+                    "insecure-broken" | "InsecureBroken" => Ok(SecurityState::InsecureBroken),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Details about the security state of the page certificate.\n[CertificateSecurityState](https://chromedevtools.github.io/devtools-protocol/tot/Security/#type-CertificateSecurityState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CertificateSecurityState {
+            #[doc = "Protocol name (e.g. \"TLS 1.2\" or \"QUIC\")."]
+            #[serde(rename = "protocol")]
+            pub protocol: String,
+            #[doc = "Key Exchange used by the connection, or the empty string if not applicable."]
+            #[serde(rename = "keyExchange")]
+            pub key_exchange: String,
+            #[doc = "(EC)DH group used by the connection, if applicable."]
+            #[serde(rename = "keyExchangeGroup")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub key_exchange_group: Option<String>,
+            #[doc = "Cipher name."]
+            #[serde(rename = "cipher")]
+            pub cipher: String,
+            #[doc = "TLS MAC. Note that AEAD ciphers do not have separate MACs."]
+            #[serde(rename = "mac")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub mac: Option<String>,
+            #[doc = "Page certificate."]
+            #[serde(rename = "certificate")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub certificate: Vec<String>,
+            #[doc = "Certificate subject name."]
+            #[serde(rename = "subjectName")]
+            pub subject_name: String,
+            #[doc = "Name of the issuing CA."]
+            #[serde(rename = "issuer")]
+            pub issuer: String,
+            #[doc = "Certificate valid from date."]
+            #[serde(rename = "validFrom")]
+            pub valid_from: super::network::TimeSinceEpoch,
+            #[doc = "Certificate valid to (expiration) date"]
+            #[serde(rename = "validTo")]
+            pub valid_to: super::network::TimeSinceEpoch,
+            #[doc = "The highest priority network error code, if the certificate has an error."]
+            #[serde(rename = "certificateNetworkError")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub certificate_network_error: Option<String>,
+            #[doc = "True if the certificate uses a weak signature algorithm."]
+            #[serde(rename = "certificateHasWeakSignature")]
+            pub certificate_has_weak_signature: bool,
+            #[doc = "True if the certificate has a SHA1 signature in the chain."]
+            #[serde(rename = "certificateHasSha1Signature")]
+            pub certificate_has_sha1_signature: bool,
+            #[doc = "True if modern SSL"]
+            #[serde(rename = "modernSSL")]
+            pub modern_ssl: bool,
+            #[doc = "True if the connection is using an obsolete SSL protocol."]
+            #[serde(rename = "obsoleteSslProtocol")]
+            pub obsolete_ssl_protocol: bool,
+            #[doc = "True if the connection is using an obsolete SSL key exchange."]
+            #[serde(rename = "obsoleteSslKeyExchange")]
+            pub obsolete_ssl_key_exchange: bool,
+            #[doc = "True if the connection is using an obsolete SSL cipher."]
+            #[serde(rename = "obsoleteSslCipher")]
+            pub obsolete_ssl_cipher: bool,
+            #[doc = "True if the connection is using an obsolete SSL signature."]
+            #[serde(rename = "obsoleteSslSignature")]
+            pub obsolete_ssl_signature: bool,
+        }
+        impl CertificateSecurityState {
+            pub fn builder() -> CertificateSecurityStateBuilder {
+                CertificateSecurityStateBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CertificateSecurityStateBuilder {
+            protocol: Option<String>,
+            key_exchange: Option<String>,
+            key_exchange_group: Option<String>,
+            cipher: Option<String>,
+            mac: Option<String>,
+            certificate: Option<Vec<String>>,
+            subject_name: Option<String>,
+            issuer: Option<String>,
+            valid_from: Option<super::network::TimeSinceEpoch>,
+            valid_to: Option<super::network::TimeSinceEpoch>,
+            certificate_network_error: Option<String>,
+            certificate_has_weak_signature: Option<bool>,
+            certificate_has_sha1_signature: Option<bool>,
+            modern_ssl: Option<bool>,
+            obsolete_ssl_protocol: Option<bool>,
+            obsolete_ssl_key_exchange: Option<bool>,
+            obsolete_ssl_cipher: Option<bool>,
+            obsolete_ssl_signature: Option<bool>,
+        }
+        impl CertificateSecurityStateBuilder {
+            pub fn protocol(mut self, protocol: impl Into<String>) -> Self {
+                self.protocol = Some(protocol.into());
+                self
+            }
+            pub fn key_exchange(mut self, key_exchange: impl Into<String>) -> Self {
+                self.key_exchange = Some(key_exchange.into());
+                self
+            }
+            pub fn key_exchange_group(mut self, key_exchange_group: impl Into<String>) -> Self {
+                self.key_exchange_group = Some(key_exchange_group.into());
+                self
+            }
+            pub fn cipher(mut self, cipher: impl Into<String>) -> Self {
+                self.cipher = Some(cipher.into());
+                self
+            }
+            pub fn mac(mut self, mac: impl Into<String>) -> Self {
+                self.mac = Some(mac.into());
+                self
+            }
+            pub fn certificate(mut self, certificate: impl Into<String>) -> Self {
+                let v = self.certificate.get_or_insert(Vec::new());
+                v.push(certificate.into());
+                self
+            }
+            pub fn certificates<I, S>(mut self, certificates: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.certificate.get_or_insert(Vec::new());
+                for val in certificates {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn subject_name(mut self, subject_name: impl Into<String>) -> Self {
+                self.subject_name = Some(subject_name.into());
+                self
+            }
+            pub fn issuer(mut self, issuer: impl Into<String>) -> Self {
+                self.issuer = Some(issuer.into());
+                self
+            }
+            pub fn valid_from(
+                mut self,
+                valid_from: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.valid_from = Some(valid_from.into());
+                self
+            }
+            pub fn valid_to(mut self, valid_to: impl Into<super::network::TimeSinceEpoch>) -> Self {
+                self.valid_to = Some(valid_to.into());
+                self
+            }
+            pub fn certificate_network_error(
+                mut self,
+                certificate_network_error: impl Into<String>,
+            ) -> Self {
+                self.certificate_network_error = Some(certificate_network_error.into());
+                self
+            }
+            pub fn certificate_has_weak_signature(
+                mut self,
+                certificate_has_weak_signature: impl Into<bool>,
+            ) -> Self {
+                self.certificate_has_weak_signature = Some(certificate_has_weak_signature.into());
+                self
+            }
+            pub fn certificate_has_sha1_signature(
+                mut self,
+                certificate_has_sha1_signature: impl Into<bool>,
+            ) -> Self {
+                self.certificate_has_sha1_signature = Some(certificate_has_sha1_signature.into());
+                self
+            }
+            pub fn modern_ssl(mut self, modern_ssl: impl Into<bool>) -> Self {
+                self.modern_ssl = Some(modern_ssl.into());
+                self
+            }
+            pub fn obsolete_ssl_protocol(mut self, obsolete_ssl_protocol: impl Into<bool>) -> Self {
+                self.obsolete_ssl_protocol = Some(obsolete_ssl_protocol.into());
+                self
+            }
+            pub fn obsolete_ssl_key_exchange(
+                mut self,
+                obsolete_ssl_key_exchange: impl Into<bool>,
+            ) -> Self {
+                self.obsolete_ssl_key_exchange = Some(obsolete_ssl_key_exchange.into());
+                self
+            }
+            pub fn obsolete_ssl_cipher(mut self, obsolete_ssl_cipher: impl Into<bool>) -> Self {
+                self.obsolete_ssl_cipher = Some(obsolete_ssl_cipher.into());
+                self
+            }
+            pub fn obsolete_ssl_signature(
+                mut self,
+                obsolete_ssl_signature: impl Into<bool>,
+            ) -> Self {
+                self.obsolete_ssl_signature = Some(obsolete_ssl_signature.into());
+                self
+            }
+            pub fn build(self) -> Result<CertificateSecurityState, String> {
+                Ok(CertificateSecurityState {
+                    protocol: self.protocol.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(protocol))
+                    })?,
+                    key_exchange: self.key_exchange.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_exchange))
+                    })?,
+                    key_exchange_group: self.key_exchange_group,
+                    cipher: self.cipher.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cipher))
+                    })?,
+                    mac: self.mac,
+                    certificate: self.certificate.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(certificate))
+                    })?,
+                    subject_name: self.subject_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(subject_name))
+                    })?,
+                    issuer: self.issuer.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(issuer))
+                    })?,
+                    valid_from: self.valid_from.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(valid_from))
+                    })?,
+                    valid_to: self.valid_to.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(valid_to))
+                    })?,
+                    certificate_network_error: self.certificate_network_error,
+                    certificate_has_weak_signature: self
+                        .certificate_has_weak_signature
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(certificate_has_weak_signature)
+                            )
+                        })?,
+                    certificate_has_sha1_signature: self
+                        .certificate_has_sha1_signature
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(certificate_has_sha1_signature)
+                            )
+                        })?,
+                    modern_ssl: self.modern_ssl.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(modern_ssl))
+                    })?,
+                    obsolete_ssl_protocol: self.obsolete_ssl_protocol.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(obsolete_ssl_protocol)
+                        )
+                    })?,
+                    obsolete_ssl_key_exchange: self.obsolete_ssl_key_exchange.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(obsolete_ssl_key_exchange)
+                        )
+                    })?,
+                    obsolete_ssl_cipher: self.obsolete_ssl_cipher.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(obsolete_ssl_cipher)
+                        )
+                    })?,
+                    obsolete_ssl_signature: self.obsolete_ssl_signature.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(obsolete_ssl_signature)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl CertificateSecurityState {
+            pub const IDENTIFIER: &'static str = "Security.CertificateSecurityState";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SafetyTipStatus {
+            #[serde(rename = "badReputation")]
+            BadReputation,
+            #[serde(rename = "lookalike")]
+            Lookalike,
+        }
+        impl AsRef<str> for SafetyTipStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SafetyTipStatus::BadReputation => "badReputation",
+                    SafetyTipStatus::Lookalike => "lookalike",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SafetyTipStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "badReputation" | "BadReputation" | "badreputation" => {
+                        Ok(SafetyTipStatus::BadReputation)
+                    }
+                    "lookalike" | "Lookalike" => Ok(SafetyTipStatus::Lookalike),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SafetyTipInfo {
+            #[doc = "Describes whether the page triggers any safety tips or reputation warnings. Default is unknown."]
+            #[serde(rename = "safetyTipStatus")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub safety_tip_status: SafetyTipStatus,
+            #[doc = "The URL the safety tip suggested (\"Did you mean?\"). Only filled in for lookalike matches."]
+            #[serde(rename = "safeUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub safe_url: Option<String>,
+        }
+        impl SafetyTipInfo {
+            pub fn new(safety_tip_status: impl Into<SafetyTipStatus>) -> Self {
+                Self {
+                    safety_tip_status: safety_tip_status.into(),
+                    safe_url: None,
+                }
+            }
+        }
+        impl SafetyTipInfo {
+            pub fn builder() -> SafetyTipInfoBuilder {
+                SafetyTipInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SafetyTipInfoBuilder {
+            safety_tip_status: Option<SafetyTipStatus>,
+            safe_url: Option<String>,
+        }
+        impl SafetyTipInfoBuilder {
+            pub fn safety_tip_status(
+                mut self,
+                safety_tip_status: impl Into<SafetyTipStatus>,
+            ) -> Self {
+                self.safety_tip_status = Some(safety_tip_status.into());
+                self
+            }
+            pub fn safe_url(mut self, safe_url: impl Into<String>) -> Self {
+                self.safe_url = Some(safe_url.into());
+                self
+            }
+            pub fn build(self) -> Result<SafetyTipInfo, String> {
+                Ok(SafetyTipInfo {
+                    safety_tip_status: self.safety_tip_status.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(safety_tip_status)
+                        )
+                    })?,
+                    safe_url: self.safe_url,
+                })
+            }
+        }
+        impl SafetyTipInfo {
+            pub const IDENTIFIER: &'static str = "Security.SafetyTipInfo";
+        }
+        #[doc = "Security state information about the page.\n[VisibleSecurityState](https://chromedevtools.github.io/devtools-protocol/tot/Security/#type-VisibleSecurityState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct VisibleSecurityState {
+            #[doc = "The security level of the page."]
+            #[serde(rename = "securityState")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub security_state: SecurityState,
+            #[doc = "Security state details about the page certificate."]
+            #[serde(rename = "certificateSecurityState")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub certificate_security_state: Option<CertificateSecurityState>,
+            #[doc = "The type of Safety Tip triggered on the page. Note that this field will be set even if the Safety Tip UI was not actually shown."]
+            #[serde(rename = "safetyTipInfo")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub safety_tip_info: Option<SafetyTipInfo>,
+            #[doc = "Array of security state issues ids."]
+            #[serde(rename = "securityStateIssueIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub security_state_issue_ids: Vec<String>,
+        }
+        impl VisibleSecurityState {
+            pub fn new(
+                security_state: impl Into<SecurityState>,
+                security_state_issue_ids: Vec<String>,
+            ) -> Self {
+                Self {
+                    security_state: security_state.into(),
+                    security_state_issue_ids,
+                    certificate_security_state: None,
+                    safety_tip_info: None,
+                }
+            }
+        }
+        impl VisibleSecurityState {
+            pub fn builder() -> VisibleSecurityStateBuilder {
+                VisibleSecurityStateBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct VisibleSecurityStateBuilder {
+            security_state: Option<SecurityState>,
+            certificate_security_state: Option<CertificateSecurityState>,
+            safety_tip_info: Option<SafetyTipInfo>,
+            security_state_issue_ids: Option<Vec<String>>,
+        }
+        impl VisibleSecurityStateBuilder {
+            pub fn security_state(mut self, security_state: impl Into<SecurityState>) -> Self {
+                self.security_state = Some(security_state.into());
+                self
+            }
+            pub fn certificate_security_state(
+                mut self,
+                certificate_security_state: impl Into<CertificateSecurityState>,
+            ) -> Self {
+                self.certificate_security_state = Some(certificate_security_state.into());
+                self
+            }
+            pub fn safety_tip_info(mut self, safety_tip_info: impl Into<SafetyTipInfo>) -> Self {
+                self.safety_tip_info = Some(safety_tip_info.into());
+                self
+            }
+            pub fn security_state_issue_id(
+                mut self,
+                security_state_issue_id: impl Into<String>,
+            ) -> Self {
+                let v = self.security_state_issue_ids.get_or_insert(Vec::new());
+                v.push(security_state_issue_id.into());
+                self
+            }
+            pub fn security_state_issue_ids<I, S>(mut self, security_state_issue_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.security_state_issue_ids.get_or_insert(Vec::new());
+                for val in security_state_issue_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<VisibleSecurityState, String> {
+                Ok(VisibleSecurityState {
+                    security_state: self.security_state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(security_state))
+                    })?,
+                    certificate_security_state: self.certificate_security_state,
+                    safety_tip_info: self.safety_tip_info,
+                    security_state_issue_ids: self.security_state_issue_ids.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(security_state_issue_ids)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl VisibleSecurityState {
+            pub const IDENTIFIER: &'static str = "Security.VisibleSecurityState";
+        }
+        #[doc = "An explanation of an factor contributing to the security state.\n[SecurityStateExplanation](https://chromedevtools.github.io/devtools-protocol/tot/Security/#type-SecurityStateExplanation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SecurityStateExplanation {
+            #[doc = "Security state representing the severity of the factor being explained."]
+            #[serde(rename = "securityState")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub security_state: SecurityState,
+            #[doc = "Title describing the type of factor."]
+            #[serde(rename = "title")]
+            pub title: String,
+            #[doc = "Short phrase describing the type of factor."]
+            #[serde(rename = "summary")]
+            pub summary: String,
+            #[doc = "Full text explanation of the factor."]
+            #[serde(rename = "description")]
+            pub description: String,
+            #[doc = "The type of mixed content described by the explanation."]
+            #[serde(rename = "mixedContentType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub mixed_content_type: MixedContentType,
+            #[doc = "Page certificate."]
+            #[serde(rename = "certificate")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub certificate: Vec<String>,
+            #[doc = "Recommendations to fix any issues."]
+            #[serde(rename = "recommendations")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub recommendations: Option<Vec<String>>,
+        }
+        impl SecurityStateExplanation {
+            pub fn builder() -> SecurityStateExplanationBuilder {
+                SecurityStateExplanationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SecurityStateExplanationBuilder {
+            security_state: Option<SecurityState>,
+            title: Option<String>,
+            summary: Option<String>,
+            description: Option<String>,
+            mixed_content_type: Option<MixedContentType>,
+            certificate: Option<Vec<String>>,
+            recommendations: Option<Vec<String>>,
+        }
+        impl SecurityStateExplanationBuilder {
+            pub fn security_state(mut self, security_state: impl Into<SecurityState>) -> Self {
+                self.security_state = Some(security_state.into());
+                self
+            }
+            pub fn title(mut self, title: impl Into<String>) -> Self {
+                self.title = Some(title.into());
+                self
+            }
+            pub fn summary(mut self, summary: impl Into<String>) -> Self {
+                self.summary = Some(summary.into());
+                self
+            }
+            pub fn description(mut self, description: impl Into<String>) -> Self {
+                self.description = Some(description.into());
+                self
+            }
+            pub fn mixed_content_type(
+                mut self,
+                mixed_content_type: impl Into<MixedContentType>,
+            ) -> Self {
+                self.mixed_content_type = Some(mixed_content_type.into());
+                self
+            }
+            pub fn certificate(mut self, certificate: impl Into<String>) -> Self {
+                let v = self.certificate.get_or_insert(Vec::new());
+                v.push(certificate.into());
+                self
+            }
+            pub fn certificates<I, S>(mut self, certificates: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.certificate.get_or_insert(Vec::new());
+                for val in certificates {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn recommendation(mut self, recommendation: impl Into<String>) -> Self {
+                let v = self.recommendations.get_or_insert(Vec::new());
+                v.push(recommendation.into());
+                self
+            }
+            pub fn recommendations<I, S>(mut self, recommendations: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.recommendations.get_or_insert(Vec::new());
+                for val in recommendations {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SecurityStateExplanation, String> {
+                Ok(SecurityStateExplanation {
+                    security_state: self.security_state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(security_state))
+                    })?,
+                    title: self.title.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(title))
+                    })?,
+                    summary: self.summary.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(summary))
+                    })?,
+                    description: self.description.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(description))
+                    })?,
+                    mixed_content_type: self.mixed_content_type.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(mixed_content_type)
+                        )
+                    })?,
+                    certificate: self.certificate.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(certificate))
+                    })?,
+                    recommendations: self.recommendations,
+                })
+            }
+        }
+        impl SecurityStateExplanation {
+            pub const IDENTIFIER: &'static str = "Security.SecurityStateExplanation";
+        }
+        #[doc = "The action to take when a certificate error occurs. continue will continue processing the\nrequest and cancel will cancel the request."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum CertificateErrorAction {
+            #[serde(rename = "continue")]
+            Continue,
+            #[serde(rename = "cancel")]
+            Cancel,
+        }
+        impl AsRef<str> for CertificateErrorAction {
+            fn as_ref(&self) -> &str {
+                match self {
+                    CertificateErrorAction::Continue => "continue",
+                    CertificateErrorAction::Cancel => "cancel",
+                }
+            }
+        }
+        impl ::std::str::FromStr for CertificateErrorAction {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "continue" | "Continue" => Ok(CertificateErrorAction::Continue),
+                    "cancel" | "Cancel" => Ok(CertificateErrorAction::Cancel),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Disables tracking security state changes.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Security/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "Security.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables tracking security state changes.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Security/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Enables tracking security state changes.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Security/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "Security.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables tracking security state changes.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Security/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Enable/disable whether all certificate errors should be ignored.\n[setIgnoreCertificateErrors](https://chromedevtools.github.io/devtools-protocol/tot/Security/#method-setIgnoreCertificateErrors)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetIgnoreCertificateErrorsParams {
+            #[doc = "If true, all certificate errors will be ignored."]
+            #[serde(rename = "ignore")]
+            pub ignore: bool,
+        }
+        impl SetIgnoreCertificateErrorsParams {
+            pub fn new(ignore: impl Into<bool>) -> Self {
+                Self {
+                    ignore: ignore.into(),
+                }
+            }
+        }
+        impl SetIgnoreCertificateErrorsParams {
+            pub fn builder() -> SetIgnoreCertificateErrorsParamsBuilder {
+                SetIgnoreCertificateErrorsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetIgnoreCertificateErrorsParamsBuilder {
+            ignore: Option<bool>,
+        }
+        impl SetIgnoreCertificateErrorsParamsBuilder {
+            pub fn ignore(mut self, ignore: impl Into<bool>) -> Self {
+                self.ignore = Some(ignore.into());
+                self
+            }
+            pub fn build(self) -> Result<SetIgnoreCertificateErrorsParams, String> {
+                Ok(SetIgnoreCertificateErrorsParams {
+                    ignore: self.ignore.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ignore))
+                    })?,
+                })
+            }
+        }
+        impl SetIgnoreCertificateErrorsParams {
+            pub const IDENTIFIER: &'static str = "Security.setIgnoreCertificateErrors";
+        }
+        impl chromiumoxide_types::Method for SetIgnoreCertificateErrorsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetIgnoreCertificateErrorsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enable/disable whether all certificate errors should be ignored.\n[setIgnoreCertificateErrors](https://chromedevtools.github.io/devtools-protocol/tot/Security/#method-setIgnoreCertificateErrors)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetIgnoreCertificateErrorsReturns {}
+        impl chromiumoxide_types::Command for SetIgnoreCertificateErrorsParams {
+            type Response = SetIgnoreCertificateErrorsReturns;
+        }
+        #[doc = "The security state of the page changed.\n[visibleSecurityStateChanged](https://chromedevtools.github.io/devtools-protocol/tot/Security/#event-visibleSecurityStateChanged)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventVisibleSecurityStateChanged {
+            #[doc = "Security state information about the page."]
+            #[serde(rename = "visibleSecurityState")]
+            pub visible_security_state: VisibleSecurityState,
+        }
+        impl EventVisibleSecurityStateChanged {
+            pub const IDENTIFIER: &'static str = "Security.visibleSecurityStateChanged";
+        }
+        impl chromiumoxide_types::Method for EventVisibleSecurityStateChanged {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventVisibleSecurityStateChanged {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod service_worker {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct RegistrationId(String);
+        impl RegistrationId {
+            pub fn new(val: impl Into<String>) -> Self {
+                RegistrationId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for RegistrationId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<RegistrationId> for String {
+            fn from(el: RegistrationId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for RegistrationId {
+            fn from(expr: String) -> Self {
+                RegistrationId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for RegistrationId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl RegistrationId {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.RegistrationID";
+        }
+        #[doc = "ServiceWorker registration.\n[ServiceWorkerRegistration](https://chromedevtools.github.io/devtools-protocol/tot/ServiceWorker/#type-ServiceWorkerRegistration)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ServiceWorkerRegistration {
+            #[serde(rename = "registrationId")]
+            pub registration_id: RegistrationId,
+            #[serde(rename = "scopeURL")]
+            pub scope_url: String,
+            #[serde(rename = "isDeleted")]
+            pub is_deleted: bool,
+        }
+        impl ServiceWorkerRegistration {
+            pub fn new(
+                registration_id: impl Into<RegistrationId>,
+                scope_url: impl Into<String>,
+                is_deleted: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    registration_id: registration_id.into(),
+                    scope_url: scope_url.into(),
+                    is_deleted: is_deleted.into(),
+                }
+            }
+        }
+        impl ServiceWorkerRegistration {
+            pub fn builder() -> ServiceWorkerRegistrationBuilder {
+                ServiceWorkerRegistrationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ServiceWorkerRegistrationBuilder {
+            registration_id: Option<RegistrationId>,
+            scope_url: Option<String>,
+            is_deleted: Option<bool>,
+        }
+        impl ServiceWorkerRegistrationBuilder {
+            pub fn registration_id(mut self, registration_id: impl Into<RegistrationId>) -> Self {
+                self.registration_id = Some(registration_id.into());
+                self
+            }
+            pub fn scope_url(mut self, scope_url: impl Into<String>) -> Self {
+                self.scope_url = Some(scope_url.into());
+                self
+            }
+            pub fn is_deleted(mut self, is_deleted: impl Into<bool>) -> Self {
+                self.is_deleted = Some(is_deleted.into());
+                self
+            }
+            pub fn build(self) -> Result<ServiceWorkerRegistration, String> {
+                Ok(ServiceWorkerRegistration {
+                    registration_id: self.registration_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(registration_id))
+                    })?,
+                    scope_url: self.scope_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scope_url))
+                    })?,
+                    is_deleted: self.is_deleted.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(is_deleted))
+                    })?,
+                })
+            }
+        }
+        impl ServiceWorkerRegistration {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.ServiceWorkerRegistration";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ServiceWorkerVersionRunningStatus {
+            #[serde(rename = "stopped")]
+            Stopped,
+            #[serde(rename = "starting")]
+            Starting,
+            #[serde(rename = "running")]
+            Running,
+            #[serde(rename = "stopping")]
+            Stopping,
+        }
+        impl AsRef<str> for ServiceWorkerVersionRunningStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ServiceWorkerVersionRunningStatus::Stopped => "stopped",
+                    ServiceWorkerVersionRunningStatus::Starting => "starting",
+                    ServiceWorkerVersionRunningStatus::Running => "running",
+                    ServiceWorkerVersionRunningStatus::Stopping => "stopping",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ServiceWorkerVersionRunningStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "stopped" | "Stopped" => Ok(ServiceWorkerVersionRunningStatus::Stopped),
+                    "starting" | "Starting" => Ok(ServiceWorkerVersionRunningStatus::Starting),
+                    "running" | "Running" => Ok(ServiceWorkerVersionRunningStatus::Running),
+                    "stopping" | "Stopping" => Ok(ServiceWorkerVersionRunningStatus::Stopping),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ServiceWorkerVersionStatus {
+            #[serde(rename = "new")]
+            New,
+            #[serde(rename = "installing")]
+            Installing,
+            #[serde(rename = "installed")]
+            Installed,
+            #[serde(rename = "activating")]
+            Activating,
+            #[serde(rename = "activated")]
+            Activated,
+            #[serde(rename = "redundant")]
+            Redundant,
+        }
+        impl AsRef<str> for ServiceWorkerVersionStatus {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ServiceWorkerVersionStatus::New => "new",
+                    ServiceWorkerVersionStatus::Installing => "installing",
+                    ServiceWorkerVersionStatus::Installed => "installed",
+                    ServiceWorkerVersionStatus::Activating => "activating",
+                    ServiceWorkerVersionStatus::Activated => "activated",
+                    ServiceWorkerVersionStatus::Redundant => "redundant",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ServiceWorkerVersionStatus {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "new" | "New" => Ok(ServiceWorkerVersionStatus::New),
+                    "installing" | "Installing" => Ok(ServiceWorkerVersionStatus::Installing),
+                    "installed" | "Installed" => Ok(ServiceWorkerVersionStatus::Installed),
+                    "activating" | "Activating" => Ok(ServiceWorkerVersionStatus::Activating),
+                    "activated" | "Activated" => Ok(ServiceWorkerVersionStatus::Activated),
+                    "redundant" | "Redundant" => Ok(ServiceWorkerVersionStatus::Redundant),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "ServiceWorker version.\n[ServiceWorkerVersion](https://chromedevtools.github.io/devtools-protocol/tot/ServiceWorker/#type-ServiceWorkerVersion)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ServiceWorkerVersion {
+            #[serde(rename = "versionId")]
+            pub version_id: String,
+            #[serde(rename = "registrationId")]
+            pub registration_id: RegistrationId,
+            #[serde(rename = "scriptURL")]
+            pub script_url: String,
+            #[serde(rename = "runningStatus")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub running_status: ServiceWorkerVersionRunningStatus,
+            #[serde(rename = "status")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub status: ServiceWorkerVersionStatus,
+            #[doc = "The Last-Modified header value of the main script."]
+            #[serde(rename = "scriptLastModified")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub script_last_modified: Option<f64>,
+            #[doc = "The time at which the response headers of the main script were received from the server.\nFor cached script it is the last time the cache entry was validated."]
+            #[serde(rename = "scriptResponseTime")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub script_response_time: Option<f64>,
+            #[serde(rename = "controlledClients")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub controlled_clients: Option<Vec<super::target::TargetId>>,
+            #[serde(rename = "targetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub target_id: Option<super::target::TargetId>,
+            #[serde(rename = "routerRules")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub router_rules: Option<String>,
+        }
+        impl ServiceWorkerVersion {
+            pub fn builder() -> ServiceWorkerVersionBuilder {
+                ServiceWorkerVersionBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ServiceWorkerVersionBuilder {
+            version_id: Option<String>,
+            registration_id: Option<RegistrationId>,
+            script_url: Option<String>,
+            running_status: Option<ServiceWorkerVersionRunningStatus>,
+            status: Option<ServiceWorkerVersionStatus>,
+            script_last_modified: Option<f64>,
+            script_response_time: Option<f64>,
+            controlled_clients: Option<Vec<super::target::TargetId>>,
+            target_id: Option<super::target::TargetId>,
+            router_rules: Option<String>,
+        }
+        impl ServiceWorkerVersionBuilder {
+            pub fn version_id(mut self, version_id: impl Into<String>) -> Self {
+                self.version_id = Some(version_id.into());
+                self
+            }
+            pub fn registration_id(mut self, registration_id: impl Into<RegistrationId>) -> Self {
+                self.registration_id = Some(registration_id.into());
+                self
+            }
+            pub fn script_url(mut self, script_url: impl Into<String>) -> Self {
+                self.script_url = Some(script_url.into());
+                self
+            }
+            pub fn running_status(
+                mut self,
+                running_status: impl Into<ServiceWorkerVersionRunningStatus>,
+            ) -> Self {
+                self.running_status = Some(running_status.into());
+                self
+            }
+            pub fn status(mut self, status: impl Into<ServiceWorkerVersionStatus>) -> Self {
+                self.status = Some(status.into());
+                self
+            }
+            pub fn script_last_modified(mut self, script_last_modified: impl Into<f64>) -> Self {
+                self.script_last_modified = Some(script_last_modified.into());
+                self
+            }
+            pub fn script_response_time(mut self, script_response_time: impl Into<f64>) -> Self {
+                self.script_response_time = Some(script_response_time.into());
+                self
+            }
+            pub fn controlled_client(
+                mut self,
+                controlled_client: impl Into<super::target::TargetId>,
+            ) -> Self {
+                let v = self.controlled_clients.get_or_insert(Vec::new());
+                v.push(controlled_client.into());
+                self
+            }
+            pub fn controlled_clients<I, S>(mut self, controlled_clients: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::target::TargetId>,
+            {
+                let v = self.controlled_clients.get_or_insert(Vec::new());
+                for val in controlled_clients {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn target_id(mut self, target_id: impl Into<super::target::TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn router_rules(mut self, router_rules: impl Into<String>) -> Self {
+                self.router_rules = Some(router_rules.into());
+                self
+            }
+            pub fn build(self) -> Result<ServiceWorkerVersion, String> {
+                Ok(ServiceWorkerVersion {
+                    version_id: self.version_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(version_id))
+                    })?,
+                    registration_id: self.registration_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(registration_id))
+                    })?,
+                    script_url: self.script_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(script_url))
+                    })?,
+                    running_status: self.running_status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(running_status))
+                    })?,
+                    status: self.status.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(status))
+                    })?,
+                    script_last_modified: self.script_last_modified,
+                    script_response_time: self.script_response_time,
+                    controlled_clients: self.controlled_clients,
+                    target_id: self.target_id,
+                    router_rules: self.router_rules,
+                })
+            }
+        }
+        impl ServiceWorkerVersion {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.ServiceWorkerVersion";
+        }
+        #[doc = "ServiceWorker error message.\n[ServiceWorkerErrorMessage](https://chromedevtools.github.io/devtools-protocol/tot/ServiceWorker/#type-ServiceWorkerErrorMessage)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ServiceWorkerErrorMessage {
+            #[serde(rename = "errorMessage")]
+            pub error_message: String,
+            #[serde(rename = "registrationId")]
+            pub registration_id: RegistrationId,
+            #[serde(rename = "versionId")]
+            pub version_id: String,
+            #[serde(rename = "sourceURL")]
+            pub source_url: String,
+            #[serde(rename = "lineNumber")]
+            pub line_number: i64,
+            #[serde(rename = "columnNumber")]
+            pub column_number: i64,
+        }
+        impl ServiceWorkerErrorMessage {
+            pub fn builder() -> ServiceWorkerErrorMessageBuilder {
+                ServiceWorkerErrorMessageBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ServiceWorkerErrorMessageBuilder {
+            error_message: Option<String>,
+            registration_id: Option<RegistrationId>,
+            version_id: Option<String>,
+            source_url: Option<String>,
+            line_number: Option<i64>,
+            column_number: Option<i64>,
+        }
+        impl ServiceWorkerErrorMessageBuilder {
+            pub fn error_message(mut self, error_message: impl Into<String>) -> Self {
+                self.error_message = Some(error_message.into());
+                self
+            }
+            pub fn registration_id(mut self, registration_id: impl Into<RegistrationId>) -> Self {
+                self.registration_id = Some(registration_id.into());
+                self
+            }
+            pub fn version_id(mut self, version_id: impl Into<String>) -> Self {
+                self.version_id = Some(version_id.into());
+                self
+            }
+            pub fn source_url(mut self, source_url: impl Into<String>) -> Self {
+                self.source_url = Some(source_url.into());
+                self
+            }
+            pub fn line_number(mut self, line_number: impl Into<i64>) -> Self {
+                self.line_number = Some(line_number.into());
+                self
+            }
+            pub fn column_number(mut self, column_number: impl Into<i64>) -> Self {
+                self.column_number = Some(column_number.into());
+                self
+            }
+            pub fn build(self) -> Result<ServiceWorkerErrorMessage, String> {
+                Ok(ServiceWorkerErrorMessage {
+                    error_message: self.error_message.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(error_message))
+                    })?,
+                    registration_id: self.registration_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(registration_id))
+                    })?,
+                    version_id: self.version_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(version_id))
+                    })?,
+                    source_url: self.source_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source_url))
+                    })?,
+                    line_number: self.line_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(line_number))
+                    })?,
+                    column_number: self.column_number.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(column_number))
+                    })?,
+                })
+            }
+        }
+        impl ServiceWorkerErrorMessage {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.ServiceWorkerErrorMessage";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeliverPushMessageParams {
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[serde(rename = "registrationId")]
+            pub registration_id: RegistrationId,
+            #[serde(rename = "data")]
+            pub data: String,
+        }
+        impl DeliverPushMessageParams {
+            pub fn new(
+                origin: impl Into<String>,
+                registration_id: impl Into<RegistrationId>,
+                data: impl Into<String>,
+            ) -> Self {
+                Self {
+                    origin: origin.into(),
+                    registration_id: registration_id.into(),
+                    data: data.into(),
+                }
+            }
+        }
+        impl DeliverPushMessageParams {
+            pub fn builder() -> DeliverPushMessageParamsBuilder {
+                DeliverPushMessageParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeliverPushMessageParamsBuilder {
+            origin: Option<String>,
+            registration_id: Option<RegistrationId>,
+            data: Option<String>,
+        }
+        impl DeliverPushMessageParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn registration_id(mut self, registration_id: impl Into<RegistrationId>) -> Self {
+                self.registration_id = Some(registration_id.into());
+                self
+            }
+            pub fn data(mut self, data: impl Into<String>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn build(self) -> Result<DeliverPushMessageParams, String> {
+                Ok(DeliverPushMessageParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    registration_id: self.registration_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(registration_id))
+                    })?,
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                })
+            }
+        }
+        impl DeliverPushMessageParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.deliverPushMessage";
+        }
+        impl chromiumoxide_types::Method for DeliverPushMessageParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DeliverPushMessageParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DeliverPushMessageReturns {}
+        impl chromiumoxide_types::Command for DeliverPushMessageParams {
+            type Response = DeliverPushMessageReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DispatchSyncEventParams {
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[serde(rename = "registrationId")]
+            pub registration_id: RegistrationId,
+            #[serde(rename = "tag")]
+            pub tag: String,
+            #[serde(rename = "lastChance")]
+            pub last_chance: bool,
+        }
+        impl DispatchSyncEventParams {
+            pub fn new(
+                origin: impl Into<String>,
+                registration_id: impl Into<RegistrationId>,
+                tag: impl Into<String>,
+                last_chance: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    origin: origin.into(),
+                    registration_id: registration_id.into(),
+                    tag: tag.into(),
+                    last_chance: last_chance.into(),
+                }
+            }
+        }
+        impl DispatchSyncEventParams {
+            pub fn builder() -> DispatchSyncEventParamsBuilder {
+                DispatchSyncEventParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DispatchSyncEventParamsBuilder {
+            origin: Option<String>,
+            registration_id: Option<RegistrationId>,
+            tag: Option<String>,
+            last_chance: Option<bool>,
+        }
+        impl DispatchSyncEventParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn registration_id(mut self, registration_id: impl Into<RegistrationId>) -> Self {
+                self.registration_id = Some(registration_id.into());
+                self
+            }
+            pub fn tag(mut self, tag: impl Into<String>) -> Self {
+                self.tag = Some(tag.into());
+                self
+            }
+            pub fn last_chance(mut self, last_chance: impl Into<bool>) -> Self {
+                self.last_chance = Some(last_chance.into());
+                self
+            }
+            pub fn build(self) -> Result<DispatchSyncEventParams, String> {
+                Ok(DispatchSyncEventParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    registration_id: self.registration_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(registration_id))
+                    })?,
+                    tag: self
+                        .tag
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(tag)))?,
+                    last_chance: self.last_chance.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(last_chance))
+                    })?,
+                })
+            }
+        }
+        impl DispatchSyncEventParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.dispatchSyncEvent";
+        }
+        impl chromiumoxide_types::Method for DispatchSyncEventParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DispatchSyncEventParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DispatchSyncEventReturns {}
+        impl chromiumoxide_types::Command for DispatchSyncEventParams {
+            type Response = DispatchSyncEventReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DispatchPeriodicSyncEventParams {
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[serde(rename = "registrationId")]
+            pub registration_id: RegistrationId,
+            #[serde(rename = "tag")]
+            pub tag: String,
+        }
+        impl DispatchPeriodicSyncEventParams {
+            pub fn new(
+                origin: impl Into<String>,
+                registration_id: impl Into<RegistrationId>,
+                tag: impl Into<String>,
+            ) -> Self {
+                Self {
+                    origin: origin.into(),
+                    registration_id: registration_id.into(),
+                    tag: tag.into(),
+                }
+            }
+        }
+        impl DispatchPeriodicSyncEventParams {
+            pub fn builder() -> DispatchPeriodicSyncEventParamsBuilder {
+                DispatchPeriodicSyncEventParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DispatchPeriodicSyncEventParamsBuilder {
+            origin: Option<String>,
+            registration_id: Option<RegistrationId>,
+            tag: Option<String>,
+        }
+        impl DispatchPeriodicSyncEventParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn registration_id(mut self, registration_id: impl Into<RegistrationId>) -> Self {
+                self.registration_id = Some(registration_id.into());
+                self
+            }
+            pub fn tag(mut self, tag: impl Into<String>) -> Self {
+                self.tag = Some(tag.into());
+                self
+            }
+            pub fn build(self) -> Result<DispatchPeriodicSyncEventParams, String> {
+                Ok(DispatchPeriodicSyncEventParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    registration_id: self.registration_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(registration_id))
+                    })?,
+                    tag: self
+                        .tag
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(tag)))?,
+                })
+            }
+        }
+        impl DispatchPeriodicSyncEventParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.dispatchPeriodicSyncEvent";
+        }
+        impl chromiumoxide_types::Method for DispatchPeriodicSyncEventParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DispatchPeriodicSyncEventParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DispatchPeriodicSyncEventReturns {}
+        impl chromiumoxide_types::Command for DispatchPeriodicSyncEventParams {
+            type Response = DispatchPeriodicSyncEventReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetForceUpdateOnPageLoadParams {
+            #[serde(rename = "forceUpdateOnPageLoad")]
+            pub force_update_on_page_load: bool,
+        }
+        impl SetForceUpdateOnPageLoadParams {
+            pub fn new(force_update_on_page_load: impl Into<bool>) -> Self {
+                Self {
+                    force_update_on_page_load: force_update_on_page_load.into(),
+                }
+            }
+        }
+        impl SetForceUpdateOnPageLoadParams {
+            pub fn builder() -> SetForceUpdateOnPageLoadParamsBuilder {
+                SetForceUpdateOnPageLoadParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetForceUpdateOnPageLoadParamsBuilder {
+            force_update_on_page_load: Option<bool>,
+        }
+        impl SetForceUpdateOnPageLoadParamsBuilder {
+            pub fn force_update_on_page_load(
+                mut self,
+                force_update_on_page_load: impl Into<bool>,
+            ) -> Self {
+                self.force_update_on_page_load = Some(force_update_on_page_load.into());
+                self
+            }
+            pub fn build(self) -> Result<SetForceUpdateOnPageLoadParams, String> {
+                Ok(SetForceUpdateOnPageLoadParams {
+                    force_update_on_page_load: self.force_update_on_page_load.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(force_update_on_page_load)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl SetForceUpdateOnPageLoadParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.setForceUpdateOnPageLoad";
+        }
+        impl chromiumoxide_types::Method for SetForceUpdateOnPageLoadParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetForceUpdateOnPageLoadParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetForceUpdateOnPageLoadReturns {}
+        impl chromiumoxide_types::Command for SetForceUpdateOnPageLoadParams {
+            type Response = SetForceUpdateOnPageLoadReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SkipWaitingParams {
+            #[serde(rename = "scopeURL")]
+            pub scope_url: String,
+        }
+        impl SkipWaitingParams {
+            pub fn new(scope_url: impl Into<String>) -> Self {
+                Self {
+                    scope_url: scope_url.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for SkipWaitingParams {
+            fn from(url: T) -> Self {
+                SkipWaitingParams::new(url)
+            }
+        }
+        impl SkipWaitingParams {
+            pub fn builder() -> SkipWaitingParamsBuilder {
+                SkipWaitingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SkipWaitingParamsBuilder {
+            scope_url: Option<String>,
+        }
+        impl SkipWaitingParamsBuilder {
+            pub fn scope_url(mut self, scope_url: impl Into<String>) -> Self {
+                self.scope_url = Some(scope_url.into());
+                self
+            }
+            pub fn build(self) -> Result<SkipWaitingParams, String> {
+                Ok(SkipWaitingParams {
+                    scope_url: self.scope_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scope_url))
+                    })?,
+                })
+            }
+        }
+        impl SkipWaitingParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.skipWaiting";
+        }
+        impl chromiumoxide_types::Method for SkipWaitingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SkipWaitingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SkipWaitingReturns {}
+        impl chromiumoxide_types::Command for SkipWaitingParams {
+            type Response = SkipWaitingReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StartWorkerParams {
+            #[serde(rename = "scopeURL")]
+            pub scope_url: String,
+        }
+        impl StartWorkerParams {
+            pub fn new(scope_url: impl Into<String>) -> Self {
+                Self {
+                    scope_url: scope_url.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for StartWorkerParams {
+            fn from(url: T) -> Self {
+                StartWorkerParams::new(url)
+            }
+        }
+        impl StartWorkerParams {
+            pub fn builder() -> StartWorkerParamsBuilder {
+                StartWorkerParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartWorkerParamsBuilder {
+            scope_url: Option<String>,
+        }
+        impl StartWorkerParamsBuilder {
+            pub fn scope_url(mut self, scope_url: impl Into<String>) -> Self {
+                self.scope_url = Some(scope_url.into());
+                self
+            }
+            pub fn build(self) -> Result<StartWorkerParams, String> {
+                Ok(StartWorkerParams {
+                    scope_url: self.scope_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scope_url))
+                    })?,
+                })
+            }
+        }
+        impl StartWorkerParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.startWorker";
+        }
+        impl chromiumoxide_types::Method for StartWorkerParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartWorkerParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartWorkerReturns {}
+        impl chromiumoxide_types::Command for StartWorkerParams {
+            type Response = StartWorkerReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopAllWorkersParams {}
+        impl StopAllWorkersParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.stopAllWorkers";
+        }
+        impl chromiumoxide_types::Method for StopAllWorkersParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopAllWorkersParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopAllWorkersReturns {}
+        impl chromiumoxide_types::Command for StopAllWorkersParams {
+            type Response = StopAllWorkersReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StopWorkerParams {
+            #[serde(rename = "versionId")]
+            pub version_id: String,
+        }
+        impl StopWorkerParams {
+            pub fn new(version_id: impl Into<String>) -> Self {
+                Self {
+                    version_id: version_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for StopWorkerParams {
+            fn from(url: T) -> Self {
+                StopWorkerParams::new(url)
+            }
+        }
+        impl StopWorkerParams {
+            pub fn builder() -> StopWorkerParamsBuilder {
+                StopWorkerParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StopWorkerParamsBuilder {
+            version_id: Option<String>,
+        }
+        impl StopWorkerParamsBuilder {
+            pub fn version_id(mut self, version_id: impl Into<String>) -> Self {
+                self.version_id = Some(version_id.into());
+                self
+            }
+            pub fn build(self) -> Result<StopWorkerParams, String> {
+                Ok(StopWorkerParams {
+                    version_id: self.version_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(version_id))
+                    })?,
+                })
+            }
+        }
+        impl StopWorkerParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.stopWorker";
+        }
+        impl chromiumoxide_types::Method for StopWorkerParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StopWorkerParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StopWorkerReturns {}
+        impl chromiumoxide_types::Command for StopWorkerParams {
+            type Response = StopWorkerReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UnregisterParams {
+            #[serde(rename = "scopeURL")]
+            pub scope_url: String,
+        }
+        impl UnregisterParams {
+            pub fn new(scope_url: impl Into<String>) -> Self {
+                Self {
+                    scope_url: scope_url.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for UnregisterParams {
+            fn from(url: T) -> Self {
+                UnregisterParams::new(url)
+            }
+        }
+        impl UnregisterParams {
+            pub fn builder() -> UnregisterParamsBuilder {
+                UnregisterParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UnregisterParamsBuilder {
+            scope_url: Option<String>,
+        }
+        impl UnregisterParamsBuilder {
+            pub fn scope_url(mut self, scope_url: impl Into<String>) -> Self {
+                self.scope_url = Some(scope_url.into());
+                self
+            }
+            pub fn build(self) -> Result<UnregisterParams, String> {
+                Ok(UnregisterParams {
+                    scope_url: self.scope_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scope_url))
+                    })?,
+                })
+            }
+        }
+        impl UnregisterParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.unregister";
+        }
+        impl chromiumoxide_types::Method for UnregisterParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for UnregisterParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UnregisterReturns {}
+        impl chromiumoxide_types::Command for UnregisterParams {
+            type Response = UnregisterReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UpdateRegistrationParams {
+            #[serde(rename = "scopeURL")]
+            pub scope_url: String,
+        }
+        impl UpdateRegistrationParams {
+            pub fn new(scope_url: impl Into<String>) -> Self {
+                Self {
+                    scope_url: scope_url.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for UpdateRegistrationParams {
+            fn from(url: T) -> Self {
+                UpdateRegistrationParams::new(url)
+            }
+        }
+        impl UpdateRegistrationParams {
+            pub fn builder() -> UpdateRegistrationParamsBuilder {
+                UpdateRegistrationParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UpdateRegistrationParamsBuilder {
+            scope_url: Option<String>,
+        }
+        impl UpdateRegistrationParamsBuilder {
+            pub fn scope_url(mut self, scope_url: impl Into<String>) -> Self {
+                self.scope_url = Some(scope_url.into());
+                self
+            }
+            pub fn build(self) -> Result<UpdateRegistrationParams, String> {
+                Ok(UpdateRegistrationParams {
+                    scope_url: self.scope_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scope_url))
+                    })?,
+                })
+            }
+        }
+        impl UpdateRegistrationParams {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.updateRegistration";
+        }
+        impl chromiumoxide_types::Method for UpdateRegistrationParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for UpdateRegistrationParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UpdateRegistrationReturns {}
+        impl chromiumoxide_types::Command for UpdateRegistrationParams {
+            type Response = UpdateRegistrationReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWorkerErrorReported {
+            #[serde(rename = "errorMessage")]
+            pub error_message: ServiceWorkerErrorMessage,
+        }
+        impl EventWorkerErrorReported {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.workerErrorReported";
+        }
+        impl chromiumoxide_types::Method for EventWorkerErrorReported {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWorkerErrorReported {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWorkerRegistrationUpdated {
+            #[serde(rename = "registrations")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub registrations: Vec<ServiceWorkerRegistration>,
+        }
+        impl EventWorkerRegistrationUpdated {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.workerRegistrationUpdated";
+        }
+        impl chromiumoxide_types::Method for EventWorkerRegistrationUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWorkerRegistrationUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventWorkerVersionUpdated {
+            #[serde(rename = "versions")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub versions: Vec<ServiceWorkerVersion>,
+        }
+        impl EventWorkerVersionUpdated {
+            pub const IDENTIFIER: &'static str = "ServiceWorker.workerVersionUpdated";
+        }
+        impl chromiumoxide_types::Method for EventWorkerVersionUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventWorkerVersionUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod storage {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct SerializedStorageKey(String);
+        impl SerializedStorageKey {
+            pub fn new(val: impl Into<String>) -> Self {
+                SerializedStorageKey(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for SerializedStorageKey {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<SerializedStorageKey> for String {
+            fn from(el: SerializedStorageKey) -> String {
+                el.0
+            }
+        }
+        impl From<String> for SerializedStorageKey {
+            fn from(expr: String) -> Self {
+                SerializedStorageKey(expr)
+            }
+        }
+        impl SerializedStorageKey {
+            pub const IDENTIFIER: &'static str = "Storage.SerializedStorageKey";
+        }
+        #[doc = "Enum of possible storage types."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum StorageType {
+            #[serde(rename = "cookies")]
+            Cookies,
+            #[serde(rename = "file_systems")]
+            FileSystems,
+            #[serde(rename = "indexeddb")]
+            Indexeddb,
+            #[serde(rename = "local_storage")]
+            LocalStorage,
+            #[serde(rename = "shader_cache")]
+            ShaderCache,
+            #[serde(rename = "websql")]
+            Websql,
+            #[serde(rename = "service_workers")]
+            ServiceWorkers,
+            #[serde(rename = "cache_storage")]
+            CacheStorage,
+            #[serde(rename = "interest_groups")]
+            InterestGroups,
+            #[serde(rename = "shared_storage")]
+            SharedStorage,
+            #[serde(rename = "storage_buckets")]
+            StorageBuckets,
+            #[serde(rename = "all")]
+            All,
+            #[serde(rename = "other")]
+            Other,
+        }
+        impl AsRef<str> for StorageType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    StorageType::Cookies => "cookies",
+                    StorageType::FileSystems => "file_systems",
+                    StorageType::Indexeddb => "indexeddb",
+                    StorageType::LocalStorage => "local_storage",
+                    StorageType::ShaderCache => "shader_cache",
+                    StorageType::Websql => "websql",
+                    StorageType::ServiceWorkers => "service_workers",
+                    StorageType::CacheStorage => "cache_storage",
+                    StorageType::InterestGroups => "interest_groups",
+                    StorageType::SharedStorage => "shared_storage",
+                    StorageType::StorageBuckets => "storage_buckets",
+                    StorageType::All => "all",
+                    StorageType::Other => "other",
+                }
+            }
+        }
+        impl ::std::str::FromStr for StorageType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "cookies" | "Cookies" => Ok(StorageType::Cookies),
+                    "file_systems" | "FileSystems" => Ok(StorageType::FileSystems),
+                    "indexeddb" | "Indexeddb" => Ok(StorageType::Indexeddb),
+                    "local_storage" | "LocalStorage" => Ok(StorageType::LocalStorage),
+                    "shader_cache" | "ShaderCache" => Ok(StorageType::ShaderCache),
+                    "websql" | "Websql" => Ok(StorageType::Websql),
+                    "service_workers" | "ServiceWorkers" => Ok(StorageType::ServiceWorkers),
+                    "cache_storage" | "CacheStorage" => Ok(StorageType::CacheStorage),
+                    "interest_groups" | "InterestGroups" => Ok(StorageType::InterestGroups),
+                    "shared_storage" | "SharedStorage" => Ok(StorageType::SharedStorage),
+                    "storage_buckets" | "StorageBuckets" => Ok(StorageType::StorageBuckets),
+                    "all" | "All" => Ok(StorageType::All),
+                    "other" | "Other" => Ok(StorageType::Other),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Usage for a storage type.\n[UsageForType](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#type-UsageForType)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UsageForType {
+            #[doc = "Name of storage type."]
+            #[serde(rename = "storageType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub storage_type: StorageType,
+            #[doc = "Storage usage (bytes)."]
+            #[serde(rename = "usage")]
+            pub usage: f64,
+        }
+        impl UsageForType {
+            pub fn new(storage_type: impl Into<StorageType>, usage: impl Into<f64>) -> Self {
+                Self {
+                    storage_type: storage_type.into(),
+                    usage: usage.into(),
+                }
+            }
+        }
+        impl UsageForType {
+            pub fn builder() -> UsageForTypeBuilder {
+                UsageForTypeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UsageForTypeBuilder {
+            storage_type: Option<StorageType>,
+            usage: Option<f64>,
+        }
+        impl UsageForTypeBuilder {
+            pub fn storage_type(mut self, storage_type: impl Into<StorageType>) -> Self {
+                self.storage_type = Some(storage_type.into());
+                self
+            }
+            pub fn usage(mut self, usage: impl Into<f64>) -> Self {
+                self.usage = Some(usage.into());
+                self
+            }
+            pub fn build(self) -> Result<UsageForType, String> {
+                Ok(UsageForType {
+                    storage_type: self.storage_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_type))
+                    })?,
+                    usage: self.usage.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(usage))
+                    })?,
+                })
+            }
+        }
+        impl UsageForType {
+            pub const IDENTIFIER: &'static str = "Storage.UsageForType";
+        }
+        #[doc = "Pair of issuer origin and number of available (signed, but not used) Trust\nTokens from that issuer.\n[TrustTokens](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#type-TrustTokens)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TrustTokens {
+            #[serde(rename = "issuerOrigin")]
+            pub issuer_origin: String,
+            #[serde(rename = "count")]
+            pub count: f64,
+        }
+        impl TrustTokens {
+            pub fn new(issuer_origin: impl Into<String>, count: impl Into<f64>) -> Self {
+                Self {
+                    issuer_origin: issuer_origin.into(),
+                    count: count.into(),
+                }
+            }
+        }
+        impl TrustTokens {
+            pub fn builder() -> TrustTokensBuilder {
+                TrustTokensBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TrustTokensBuilder {
+            issuer_origin: Option<String>,
+            count: Option<f64>,
+        }
+        impl TrustTokensBuilder {
+            pub fn issuer_origin(mut self, issuer_origin: impl Into<String>) -> Self {
+                self.issuer_origin = Some(issuer_origin.into());
+                self
+            }
+            pub fn count(mut self, count: impl Into<f64>) -> Self {
+                self.count = Some(count.into());
+                self
+            }
+            pub fn build(self) -> Result<TrustTokens, String> {
+                Ok(TrustTokens {
+                    issuer_origin: self.issuer_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(issuer_origin))
+                    })?,
+                    count: self.count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(count))
+                    })?,
+                })
+            }
+        }
+        impl TrustTokens {
+            pub const IDENTIFIER: &'static str = "Storage.TrustTokens";
+        }
+        #[doc = "Protected audience interest group auction identifier.\n[InterestGroupAuctionId](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#type-InterestGroupAuctionId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct InterestGroupAuctionId(String);
+        impl InterestGroupAuctionId {
+            pub fn new(val: impl Into<String>) -> Self {
+                InterestGroupAuctionId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for InterestGroupAuctionId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<InterestGroupAuctionId> for String {
+            fn from(el: InterestGroupAuctionId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for InterestGroupAuctionId {
+            fn from(expr: String) -> Self {
+                InterestGroupAuctionId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for InterestGroupAuctionId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl InterestGroupAuctionId {
+            pub const IDENTIFIER: &'static str = "Storage.InterestGroupAuctionId";
+        }
+        #[doc = "Enum of interest group access types."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum InterestGroupAccessType {
+            #[serde(rename = "join")]
+            Join,
+            #[serde(rename = "leave")]
+            Leave,
+            #[serde(rename = "update")]
+            Update,
+            #[serde(rename = "loaded")]
+            Loaded,
+            #[serde(rename = "bid")]
+            Bid,
+            #[serde(rename = "win")]
+            Win,
+            #[serde(rename = "additionalBid")]
+            AdditionalBid,
+            #[serde(rename = "additionalBidWin")]
+            AdditionalBidWin,
+            #[serde(rename = "topLevelBid")]
+            TopLevelBid,
+            #[serde(rename = "topLevelAdditionalBid")]
+            TopLevelAdditionalBid,
+            #[serde(rename = "clear")]
+            Clear,
+        }
+        impl AsRef<str> for InterestGroupAccessType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    InterestGroupAccessType::Join => "join",
+                    InterestGroupAccessType::Leave => "leave",
+                    InterestGroupAccessType::Update => "update",
+                    InterestGroupAccessType::Loaded => "loaded",
+                    InterestGroupAccessType::Bid => "bid",
+                    InterestGroupAccessType::Win => "win",
+                    InterestGroupAccessType::AdditionalBid => "additionalBid",
+                    InterestGroupAccessType::AdditionalBidWin => "additionalBidWin",
+                    InterestGroupAccessType::TopLevelBid => "topLevelBid",
+                    InterestGroupAccessType::TopLevelAdditionalBid => "topLevelAdditionalBid",
+                    InterestGroupAccessType::Clear => "clear",
+                }
+            }
+        }
+        impl ::std::str::FromStr for InterestGroupAccessType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "join" | "Join" => Ok(InterestGroupAccessType::Join),
+                    "leave" | "Leave" => Ok(InterestGroupAccessType::Leave),
+                    "update" | "Update" => Ok(InterestGroupAccessType::Update),
+                    "loaded" | "Loaded" => Ok(InterestGroupAccessType::Loaded),
+                    "bid" | "Bid" => Ok(InterestGroupAccessType::Bid),
+                    "win" | "Win" => Ok(InterestGroupAccessType::Win),
+                    "additionalBid" | "AdditionalBid" | "additionalbid" => {
+                        Ok(InterestGroupAccessType::AdditionalBid)
+                    }
+                    "additionalBidWin" | "AdditionalBidWin" | "additionalbidwin" => {
+                        Ok(InterestGroupAccessType::AdditionalBidWin)
+                    }
+                    "topLevelBid" | "TopLevelBid" | "toplevelbid" => {
+                        Ok(InterestGroupAccessType::TopLevelBid)
+                    }
+                    "topLevelAdditionalBid" | "TopLevelAdditionalBid" | "topleveladditionalbid" => {
+                        Ok(InterestGroupAccessType::TopLevelAdditionalBid)
+                    }
+                    "clear" | "Clear" => Ok(InterestGroupAccessType::Clear),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Enum of auction events."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum InterestGroupAuctionEventType {
+            #[serde(rename = "started")]
+            Started,
+            #[serde(rename = "configResolved")]
+            ConfigResolved,
+        }
+        impl AsRef<str> for InterestGroupAuctionEventType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    InterestGroupAuctionEventType::Started => "started",
+                    InterestGroupAuctionEventType::ConfigResolved => "configResolved",
+                }
+            }
+        }
+        impl ::std::str::FromStr for InterestGroupAuctionEventType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "started" | "Started" => Ok(InterestGroupAuctionEventType::Started),
+                    "configResolved" | "ConfigResolved" | "configresolved" => {
+                        Ok(InterestGroupAuctionEventType::ConfigResolved)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Enum of network fetches auctions can do."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum InterestGroupAuctionFetchType {
+            #[serde(rename = "bidderJs")]
+            BidderJs,
+            #[serde(rename = "bidderWasm")]
+            BidderWasm,
+            #[serde(rename = "sellerJs")]
+            SellerJs,
+            #[serde(rename = "bidderTrustedSignals")]
+            BidderTrustedSignals,
+            #[serde(rename = "sellerTrustedSignals")]
+            SellerTrustedSignals,
+        }
+        impl AsRef<str> for InterestGroupAuctionFetchType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    InterestGroupAuctionFetchType::BidderJs => "bidderJs",
+                    InterestGroupAuctionFetchType::BidderWasm => "bidderWasm",
+                    InterestGroupAuctionFetchType::SellerJs => "sellerJs",
+                    InterestGroupAuctionFetchType::BidderTrustedSignals => "bidderTrustedSignals",
+                    InterestGroupAuctionFetchType::SellerTrustedSignals => "sellerTrustedSignals",
+                }
+            }
+        }
+        impl ::std::str::FromStr for InterestGroupAuctionFetchType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "bidderJs" | "BidderJs" | "bidderjs" => {
+                        Ok(InterestGroupAuctionFetchType::BidderJs)
+                    }
+                    "bidderWasm" | "BidderWasm" | "bidderwasm" => {
+                        Ok(InterestGroupAuctionFetchType::BidderWasm)
+                    }
+                    "sellerJs" | "SellerJs" | "sellerjs" => {
+                        Ok(InterestGroupAuctionFetchType::SellerJs)
+                    }
+                    "bidderTrustedSignals" | "BidderTrustedSignals" | "biddertrustedsignals" => {
+                        Ok(InterestGroupAuctionFetchType::BidderTrustedSignals)
+                    }
+                    "sellerTrustedSignals" | "SellerTrustedSignals" | "sellertrustedsignals" => {
+                        Ok(InterestGroupAuctionFetchType::SellerTrustedSignals)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Enum of shared storage access scopes."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SharedStorageAccessScope {
+            #[serde(rename = "window")]
+            Window,
+            #[serde(rename = "sharedStorageWorklet")]
+            SharedStorageWorklet,
+            #[serde(rename = "protectedAudienceWorklet")]
+            ProtectedAudienceWorklet,
+            #[serde(rename = "header")]
+            Header,
+        }
+        impl AsRef<str> for SharedStorageAccessScope {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SharedStorageAccessScope::Window => "window",
+                    SharedStorageAccessScope::SharedStorageWorklet => "sharedStorageWorklet",
+                    SharedStorageAccessScope::ProtectedAudienceWorklet => {
+                        "protectedAudienceWorklet"
+                    }
+                    SharedStorageAccessScope::Header => "header",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SharedStorageAccessScope {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "window" | "Window" => Ok(SharedStorageAccessScope::Window),
+                    "sharedStorageWorklet" | "SharedStorageWorklet" | "sharedstorageworklet" => {
+                        Ok(SharedStorageAccessScope::SharedStorageWorklet)
+                    }
+                    "protectedAudienceWorklet"
+                    | "ProtectedAudienceWorklet"
+                    | "protectedaudienceworklet" => {
+                        Ok(SharedStorageAccessScope::ProtectedAudienceWorklet)
+                    }
+                    "header" | "Header" => Ok(SharedStorageAccessScope::Header),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Enum of shared storage access methods."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SharedStorageAccessMethod {
+            #[serde(rename = "addModule")]
+            AddModule,
+            #[serde(rename = "createWorklet")]
+            CreateWorklet,
+            #[serde(rename = "selectURL")]
+            SelectUrl,
+            #[serde(rename = "run")]
+            Run,
+            #[serde(rename = "batchUpdate")]
+            BatchUpdate,
+            #[serde(rename = "set")]
+            Set,
+            #[serde(rename = "append")]
+            Append,
+            #[serde(rename = "delete")]
+            Delete,
+            #[serde(rename = "clear")]
+            Clear,
+            #[serde(rename = "get")]
+            Get,
+            #[serde(rename = "keys")]
+            Keys,
+            #[serde(rename = "values")]
+            Values,
+            #[serde(rename = "entries")]
+            Entries,
+            #[serde(rename = "length")]
+            Length,
+            #[serde(rename = "remainingBudget")]
+            RemainingBudget,
+        }
+        impl AsRef<str> for SharedStorageAccessMethod {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SharedStorageAccessMethod::AddModule => "addModule",
+                    SharedStorageAccessMethod::CreateWorklet => "createWorklet",
+                    SharedStorageAccessMethod::SelectUrl => "selectURL",
+                    SharedStorageAccessMethod::Run => "run",
+                    SharedStorageAccessMethod::BatchUpdate => "batchUpdate",
+                    SharedStorageAccessMethod::Set => "set",
+                    SharedStorageAccessMethod::Append => "append",
+                    SharedStorageAccessMethod::Delete => "delete",
+                    SharedStorageAccessMethod::Clear => "clear",
+                    SharedStorageAccessMethod::Get => "get",
+                    SharedStorageAccessMethod::Keys => "keys",
+                    SharedStorageAccessMethod::Values => "values",
+                    SharedStorageAccessMethod::Entries => "entries",
+                    SharedStorageAccessMethod::Length => "length",
+                    SharedStorageAccessMethod::RemainingBudget => "remainingBudget",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SharedStorageAccessMethod {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "addModule" | "AddModule" | "addmodule" => {
+                        Ok(SharedStorageAccessMethod::AddModule)
+                    }
+                    "createWorklet" | "CreateWorklet" | "createworklet" => {
+                        Ok(SharedStorageAccessMethod::CreateWorklet)
+                    }
+                    "selectURL" | "SelectUrl" | "selecturl" => {
+                        Ok(SharedStorageAccessMethod::SelectUrl)
+                    }
+                    "run" | "Run" => Ok(SharedStorageAccessMethod::Run),
+                    "batchUpdate" | "BatchUpdate" | "batchupdate" => {
+                        Ok(SharedStorageAccessMethod::BatchUpdate)
+                    }
+                    "set" | "Set" => Ok(SharedStorageAccessMethod::Set),
+                    "append" | "Append" => Ok(SharedStorageAccessMethod::Append),
+                    "delete" | "Delete" => Ok(SharedStorageAccessMethod::Delete),
+                    "clear" | "Clear" => Ok(SharedStorageAccessMethod::Clear),
+                    "get" | "Get" => Ok(SharedStorageAccessMethod::Get),
+                    "keys" | "Keys" => Ok(SharedStorageAccessMethod::Keys),
+                    "values" | "Values" => Ok(SharedStorageAccessMethod::Values),
+                    "entries" | "Entries" => Ok(SharedStorageAccessMethod::Entries),
+                    "length" | "Length" => Ok(SharedStorageAccessMethod::Length),
+                    "remainingBudget" | "RemainingBudget" | "remainingbudget" => {
+                        Ok(SharedStorageAccessMethod::RemainingBudget)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Struct for a single key-value pair in an origin's shared storage.\n[SharedStorageEntry](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#type-SharedStorageEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SharedStorageEntry {
+            #[serde(rename = "key")]
+            pub key: String,
+            #[serde(rename = "value")]
+            pub value: String,
+        }
+        impl SharedStorageEntry {
+            pub fn new(key: impl Into<String>, value: impl Into<String>) -> Self {
+                Self {
+                    key: key.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl SharedStorageEntry {
+            pub fn builder() -> SharedStorageEntryBuilder {
+                SharedStorageEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SharedStorageEntryBuilder {
+            key: Option<String>,
+            value: Option<String>,
+        }
+        impl SharedStorageEntryBuilder {
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<SharedStorageEntry, String> {
+                Ok(SharedStorageEntry {
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl SharedStorageEntry {
+            pub const IDENTIFIER: &'static str = "Storage.SharedStorageEntry";
+        }
+        #[doc = "Details for an origin's shared storage.\n[SharedStorageMetadata](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#type-SharedStorageMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SharedStorageMetadata {
+            #[doc = "Time when the origin's shared storage was last created."]
+            #[serde(rename = "creationTime")]
+            pub creation_time: super::network::TimeSinceEpoch,
+            #[doc = "Number of key-value pairs stored in origin's shared storage."]
+            #[serde(rename = "length")]
+            pub length: i64,
+            #[doc = "Current amount of bits of entropy remaining in the navigation budget."]
+            #[serde(rename = "remainingBudget")]
+            pub remaining_budget: f64,
+            #[doc = "Total number of bytes stored as key-value pairs in origin's shared\nstorage."]
+            #[serde(rename = "bytesUsed")]
+            pub bytes_used: i64,
+        }
+        impl SharedStorageMetadata {
+            pub fn new(
+                creation_time: impl Into<super::network::TimeSinceEpoch>,
+                length: impl Into<i64>,
+                remaining_budget: impl Into<f64>,
+                bytes_used: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    creation_time: creation_time.into(),
+                    length: length.into(),
+                    remaining_budget: remaining_budget.into(),
+                    bytes_used: bytes_used.into(),
+                }
+            }
+        }
+        impl SharedStorageMetadata {
+            pub fn builder() -> SharedStorageMetadataBuilder {
+                SharedStorageMetadataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SharedStorageMetadataBuilder {
+            creation_time: Option<super::network::TimeSinceEpoch>,
+            length: Option<i64>,
+            remaining_budget: Option<f64>,
+            bytes_used: Option<i64>,
+        }
+        impl SharedStorageMetadataBuilder {
+            pub fn creation_time(
+                mut self,
+                creation_time: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.creation_time = Some(creation_time.into());
+                self
+            }
+            pub fn length(mut self, length: impl Into<i64>) -> Self {
+                self.length = Some(length.into());
+                self
+            }
+            pub fn remaining_budget(mut self, remaining_budget: impl Into<f64>) -> Self {
+                self.remaining_budget = Some(remaining_budget.into());
+                self
+            }
+            pub fn bytes_used(mut self, bytes_used: impl Into<i64>) -> Self {
+                self.bytes_used = Some(bytes_used.into());
+                self
+            }
+            pub fn build(self) -> Result<SharedStorageMetadata, String> {
+                Ok(SharedStorageMetadata {
+                    creation_time: self.creation_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(creation_time))
+                    })?,
+                    length: self.length.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(length))
+                    })?,
+                    remaining_budget: self.remaining_budget.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(remaining_budget)
+                        )
+                    })?,
+                    bytes_used: self.bytes_used.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bytes_used))
+                    })?,
+                })
+            }
+        }
+        impl SharedStorageMetadata {
+            pub const IDENTIFIER: &'static str = "Storage.SharedStorageMetadata";
+        }
+        #[doc = "Represents a dictionary object passed in as privateAggregationConfig to\nrun or selectURL.\n[SharedStoragePrivateAggregationConfig](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#type-SharedStoragePrivateAggregationConfig)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SharedStoragePrivateAggregationConfig {
+            #[doc = "The chosen aggregation service deployment."]
+            #[serde(rename = "aggregationCoordinatorOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub aggregation_coordinator_origin: Option<String>,
+            #[doc = "The context ID provided."]
+            #[serde(rename = "contextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub context_id: Option<String>,
+            #[doc = "Configures the maximum size allowed for filtering IDs."]
+            #[serde(rename = "filteringIdMaxBytes")]
+            pub filtering_id_max_bytes: i64,
+            #[doc = "The limit on the number of contributions in the final report."]
+            #[serde(rename = "maxContributions")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub max_contributions: Option<i64>,
+        }
+        impl SharedStoragePrivateAggregationConfig {
+            pub fn new(filtering_id_max_bytes: impl Into<i64>) -> Self {
+                Self {
+                    filtering_id_max_bytes: filtering_id_max_bytes.into(),
+                    aggregation_coordinator_origin: None,
+                    context_id: None,
+                    max_contributions: None,
+                }
+            }
+        }
+        impl SharedStoragePrivateAggregationConfig {
+            pub fn builder() -> SharedStoragePrivateAggregationConfigBuilder {
+                SharedStoragePrivateAggregationConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SharedStoragePrivateAggregationConfigBuilder {
+            aggregation_coordinator_origin: Option<String>,
+            context_id: Option<String>,
+            filtering_id_max_bytes: Option<i64>,
+            max_contributions: Option<i64>,
+        }
+        impl SharedStoragePrivateAggregationConfigBuilder {
+            pub fn aggregation_coordinator_origin(
+                mut self,
+                aggregation_coordinator_origin: impl Into<String>,
+            ) -> Self {
+                self.aggregation_coordinator_origin = Some(aggregation_coordinator_origin.into());
+                self
+            }
+            pub fn context_id(mut self, context_id: impl Into<String>) -> Self {
+                self.context_id = Some(context_id.into());
+                self
+            }
+            pub fn filtering_id_max_bytes(
+                mut self,
+                filtering_id_max_bytes: impl Into<i64>,
+            ) -> Self {
+                self.filtering_id_max_bytes = Some(filtering_id_max_bytes.into());
+                self
+            }
+            pub fn max_contributions(mut self, max_contributions: impl Into<i64>) -> Self {
+                self.max_contributions = Some(max_contributions.into());
+                self
+            }
+            pub fn build(self) -> Result<SharedStoragePrivateAggregationConfig, String> {
+                Ok(SharedStoragePrivateAggregationConfig {
+                    aggregation_coordinator_origin: self.aggregation_coordinator_origin,
+                    context_id: self.context_id,
+                    filtering_id_max_bytes: self.filtering_id_max_bytes.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(filtering_id_max_bytes)
+                        )
+                    })?,
+                    max_contributions: self.max_contributions,
+                })
+            }
+        }
+        impl SharedStoragePrivateAggregationConfig {
+            pub const IDENTIFIER: &'static str = "Storage.SharedStoragePrivateAggregationConfig";
+        }
+        #[doc = "Pair of reporting metadata details for a candidate URL for `selectURL()`.\n[SharedStorageReportingMetadata](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#type-SharedStorageReportingMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SharedStorageReportingMetadata {
+            #[serde(rename = "eventType")]
+            pub event_type: String,
+            #[serde(rename = "reportingUrl")]
+            pub reporting_url: String,
+        }
+        impl SharedStorageReportingMetadata {
+            pub fn new(event_type: impl Into<String>, reporting_url: impl Into<String>) -> Self {
+                Self {
+                    event_type: event_type.into(),
+                    reporting_url: reporting_url.into(),
+                }
+            }
+        }
+        impl SharedStorageReportingMetadata {
+            pub fn builder() -> SharedStorageReportingMetadataBuilder {
+                SharedStorageReportingMetadataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SharedStorageReportingMetadataBuilder {
+            event_type: Option<String>,
+            reporting_url: Option<String>,
+        }
+        impl SharedStorageReportingMetadataBuilder {
+            pub fn event_type(mut self, event_type: impl Into<String>) -> Self {
+                self.event_type = Some(event_type.into());
+                self
+            }
+            pub fn reporting_url(mut self, reporting_url: impl Into<String>) -> Self {
+                self.reporting_url = Some(reporting_url.into());
+                self
+            }
+            pub fn build(self) -> Result<SharedStorageReportingMetadata, String> {
+                Ok(SharedStorageReportingMetadata {
+                    event_type: self.event_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(event_type))
+                    })?,
+                    reporting_url: self.reporting_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(reporting_url))
+                    })?,
+                })
+            }
+        }
+        impl SharedStorageReportingMetadata {
+            pub const IDENTIFIER: &'static str = "Storage.SharedStorageReportingMetadata";
+        }
+        #[doc = "Bundles a candidate URL with its reporting metadata.\n[SharedStorageUrlWithMetadata](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#type-SharedStorageUrlWithMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SharedStorageUrlWithMetadata {
+            #[doc = "Spec of candidate URL."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Any associated reporting metadata."]
+            #[serde(rename = "reportingMetadata")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub reporting_metadata: Vec<SharedStorageReportingMetadata>,
+        }
+        impl SharedStorageUrlWithMetadata {
+            pub fn new(
+                url: impl Into<String>,
+                reporting_metadata: Vec<SharedStorageReportingMetadata>,
+            ) -> Self {
+                Self {
+                    url: url.into(),
+                    reporting_metadata,
+                }
+            }
+        }
+        impl SharedStorageUrlWithMetadata {
+            pub fn builder() -> SharedStorageUrlWithMetadataBuilder {
+                SharedStorageUrlWithMetadataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SharedStorageUrlWithMetadataBuilder {
+            url: Option<String>,
+            reporting_metadata: Option<Vec<SharedStorageReportingMetadata>>,
+        }
+        impl SharedStorageUrlWithMetadataBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn reporting_metadata(
+                mut self,
+                reporting_metadata: impl Into<SharedStorageReportingMetadata>,
+            ) -> Self {
+                let v = self.reporting_metadata.get_or_insert(Vec::new());
+                v.push(reporting_metadata.into());
+                self
+            }
+            pub fn reporting_metadatas<I, S>(mut self, reporting_metadatas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SharedStorageReportingMetadata>,
+            {
+                let v = self.reporting_metadata.get_or_insert(Vec::new());
+                for val in reporting_metadatas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SharedStorageUrlWithMetadata, String> {
+                Ok(SharedStorageUrlWithMetadata {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    reporting_metadata: self.reporting_metadata.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(reporting_metadata)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl SharedStorageUrlWithMetadata {
+            pub const IDENTIFIER: &'static str = "Storage.SharedStorageUrlWithMetadata";
+        }
+        #[doc = "Bundles the parameters for shared storage access events whose\npresence/absence can vary according to SharedStorageAccessType.\n[SharedStorageAccessParams](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#type-SharedStorageAccessParams)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SharedStorageAccessParams {
+            #[doc = "Spec of the module script URL.\nPresent only for SharedStorageAccessMethods: addModule and\ncreateWorklet."]
+            #[serde(rename = "scriptSourceUrl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub script_source_url: Option<String>,
+            #[doc = "String denoting \"context-origin\", \"script-origin\", or a custom\norigin to be used as the worklet's data origin.\nPresent only for SharedStorageAccessMethod: createWorklet."]
+            #[serde(rename = "dataOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub data_origin: Option<String>,
+            #[doc = "Name of the registered operation to be run.\nPresent only for SharedStorageAccessMethods: run and selectURL."]
+            #[serde(rename = "operationName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub operation_name: Option<String>,
+            #[doc = "ID of the operation call.\nPresent only for SharedStorageAccessMethods: run and selectURL."]
+            #[serde(rename = "operationId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub operation_id: Option<String>,
+            #[doc = "Whether or not to keep the worket alive for future run or selectURL\ncalls.\nPresent only for SharedStorageAccessMethods: run and selectURL."]
+            #[serde(rename = "keepAlive")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub keep_alive: Option<bool>,
+            #[doc = "Configures the private aggregation options.\nPresent only for SharedStorageAccessMethods: run and selectURL."]
+            #[serde(rename = "privateAggregationConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub private_aggregation_config: Option<SharedStoragePrivateAggregationConfig>,
+            #[doc = "The operation's serialized data in bytes (converted to a string).\nPresent only for SharedStorageAccessMethods: run and selectURL.\nTODO(crbug.com/401011862): Consider updating this parameter to binary."]
+            #[serde(rename = "serializedData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub serialized_data: Option<String>,
+            #[doc = "Array of candidate URLs' specs, along with any associated metadata.\nPresent only for SharedStorageAccessMethod: selectURL."]
+            #[serde(rename = "urlsWithMetadata")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub urls_with_metadata: Option<Vec<SharedStorageUrlWithMetadata>>,
+            #[doc = "Spec of the URN:UUID generated for a selectURL call.\nPresent only for SharedStorageAccessMethod: selectURL."]
+            #[serde(rename = "urnUuid")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub urn_uuid: Option<String>,
+            #[doc = "Key for a specific entry in an origin's shared storage.\nPresent only for SharedStorageAccessMethods: set, append, delete, and\nget."]
+            #[serde(rename = "key")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub key: Option<String>,
+            #[doc = "Value for a specific entry in an origin's shared storage.\nPresent only for SharedStorageAccessMethods: set and append."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<String>,
+            #[doc = "Whether or not to set an entry for a key if that key is already present.\nPresent only for SharedStorageAccessMethod: set."]
+            #[serde(rename = "ignoreIfPresent")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub ignore_if_present: Option<bool>,
+            #[doc = "A number denoting the (0-based) order of the worklet's\ncreation relative to all other shared storage worklets created by\ndocuments using the current storage partition.\nPresent only for SharedStorageAccessMethods: addModule, createWorklet."]
+            #[serde(rename = "workletOrdinal")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub worklet_ordinal: Option<i64>,
+            #[doc = "Hex representation of the DevTools token used as the TargetID for the\nassociated shared storage worklet.\nPresent only for SharedStorageAccessMethods: addModule, createWorklet,\nrun, selectURL, and any other SharedStorageAccessMethod when the\nSharedStorageAccessScope is sharedStorageWorklet."]
+            #[serde(rename = "workletTargetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub worklet_target_id: Option<super::target::TargetId>,
+            #[doc = "Name of the lock to be acquired, if present.\nOptionally present only for SharedStorageAccessMethods: batchUpdate,\nset, append, delete, and clear."]
+            #[serde(rename = "withLock")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub with_lock: Option<String>,
+            #[doc = "If the method has been called as part of a batchUpdate, then this\nnumber identifies the batch to which it belongs.\nOptionally present only for SharedStorageAccessMethods:\nbatchUpdate (required), set, append, delete, and clear."]
+            #[serde(rename = "batchUpdateId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub batch_update_id: Option<String>,
+            #[doc = "Number of modifier methods sent in batch.\nPresent only for SharedStorageAccessMethod: batchUpdate."]
+            #[serde(rename = "batchSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub batch_size: Option<i64>,
+        }
+        impl SharedStorageAccessParams {
+            pub fn builder() -> SharedStorageAccessParamsBuilder {
+                SharedStorageAccessParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SharedStorageAccessParamsBuilder {
+            script_source_url: Option<String>,
+            data_origin: Option<String>,
+            operation_name: Option<String>,
+            operation_id: Option<String>,
+            keep_alive: Option<bool>,
+            private_aggregation_config: Option<SharedStoragePrivateAggregationConfig>,
+            serialized_data: Option<String>,
+            urls_with_metadata: Option<Vec<SharedStorageUrlWithMetadata>>,
+            urn_uuid: Option<String>,
+            key: Option<String>,
+            value: Option<String>,
+            ignore_if_present: Option<bool>,
+            worklet_ordinal: Option<i64>,
+            worklet_target_id: Option<super::target::TargetId>,
+            with_lock: Option<String>,
+            batch_update_id: Option<String>,
+            batch_size: Option<i64>,
+        }
+        impl SharedStorageAccessParamsBuilder {
+            pub fn script_source_url(mut self, script_source_url: impl Into<String>) -> Self {
+                self.script_source_url = Some(script_source_url.into());
+                self
+            }
+            pub fn data_origin(mut self, data_origin: impl Into<String>) -> Self {
+                self.data_origin = Some(data_origin.into());
+                self
+            }
+            pub fn operation_name(mut self, operation_name: impl Into<String>) -> Self {
+                self.operation_name = Some(operation_name.into());
+                self
+            }
+            pub fn operation_id(mut self, operation_id: impl Into<String>) -> Self {
+                self.operation_id = Some(operation_id.into());
+                self
+            }
+            pub fn keep_alive(mut self, keep_alive: impl Into<bool>) -> Self {
+                self.keep_alive = Some(keep_alive.into());
+                self
+            }
+            pub fn private_aggregation_config(
+                mut self,
+                private_aggregation_config: impl Into<SharedStoragePrivateAggregationConfig>,
+            ) -> Self {
+                self.private_aggregation_config = Some(private_aggregation_config.into());
+                self
+            }
+            pub fn serialized_data(mut self, serialized_data: impl Into<String>) -> Self {
+                self.serialized_data = Some(serialized_data.into());
+                self
+            }
+            pub fn urls_with_metadata(
+                mut self,
+                urls_with_metadata: impl Into<SharedStorageUrlWithMetadata>,
+            ) -> Self {
+                let v = self.urls_with_metadata.get_or_insert(Vec::new());
+                v.push(urls_with_metadata.into());
+                self
+            }
+            pub fn urls_with_metadatas<I, S>(mut self, urls_with_metadatas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SharedStorageUrlWithMetadata>,
+            {
+                let v = self.urls_with_metadata.get_or_insert(Vec::new());
+                for val in urls_with_metadatas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn urn_uuid(mut self, urn_uuid: impl Into<String>) -> Self {
+                self.urn_uuid = Some(urn_uuid.into());
+                self
+            }
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn ignore_if_present(mut self, ignore_if_present: impl Into<bool>) -> Self {
+                self.ignore_if_present = Some(ignore_if_present.into());
+                self
+            }
+            pub fn worklet_ordinal(mut self, worklet_ordinal: impl Into<i64>) -> Self {
+                self.worklet_ordinal = Some(worklet_ordinal.into());
+                self
+            }
+            pub fn worklet_target_id(
+                mut self,
+                worklet_target_id: impl Into<super::target::TargetId>,
+            ) -> Self {
+                self.worklet_target_id = Some(worklet_target_id.into());
+                self
+            }
+            pub fn with_lock(mut self, with_lock: impl Into<String>) -> Self {
+                self.with_lock = Some(with_lock.into());
+                self
+            }
+            pub fn batch_update_id(mut self, batch_update_id: impl Into<String>) -> Self {
+                self.batch_update_id = Some(batch_update_id.into());
+                self
+            }
+            pub fn batch_size(mut self, batch_size: impl Into<i64>) -> Self {
+                self.batch_size = Some(batch_size.into());
+                self
+            }
+            pub fn build(self) -> SharedStorageAccessParams {
+                SharedStorageAccessParams {
+                    script_source_url: self.script_source_url,
+                    data_origin: self.data_origin,
+                    operation_name: self.operation_name,
+                    operation_id: self.operation_id,
+                    keep_alive: self.keep_alive,
+                    private_aggregation_config: self.private_aggregation_config,
+                    serialized_data: self.serialized_data,
+                    urls_with_metadata: self.urls_with_metadata,
+                    urn_uuid: self.urn_uuid,
+                    key: self.key,
+                    value: self.value,
+                    ignore_if_present: self.ignore_if_present,
+                    worklet_ordinal: self.worklet_ordinal,
+                    worklet_target_id: self.worklet_target_id,
+                    with_lock: self.with_lock,
+                    batch_update_id: self.batch_update_id,
+                    batch_size: self.batch_size,
+                }
+            }
+        }
+        impl SharedStorageAccessParams {
+            pub const IDENTIFIER: &'static str = "Storage.SharedStorageAccessParams";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum StorageBucketsDurability {
+            #[serde(rename = "relaxed")]
+            Relaxed,
+            #[serde(rename = "strict")]
+            Strict,
+        }
+        impl AsRef<str> for StorageBucketsDurability {
+            fn as_ref(&self) -> &str {
+                match self {
+                    StorageBucketsDurability::Relaxed => "relaxed",
+                    StorageBucketsDurability::Strict => "strict",
+                }
+            }
+        }
+        impl ::std::str::FromStr for StorageBucketsDurability {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "relaxed" | "Relaxed" => Ok(StorageBucketsDurability::Relaxed),
+                    "strict" | "Strict" => Ok(StorageBucketsDurability::Strict),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StorageBucket {
+            #[serde(rename = "storageKey")]
+            pub storage_key: SerializedStorageKey,
+            #[doc = "If not specified, it is the default bucket of the storageKey."]
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+        }
+        impl StorageBucket {
+            pub fn new(storage_key: impl Into<SerializedStorageKey>) -> Self {
+                Self {
+                    storage_key: storage_key.into(),
+                    name: None,
+                }
+            }
+        }
+        impl StorageBucket {
+            pub fn builder() -> StorageBucketBuilder {
+                StorageBucketBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StorageBucketBuilder {
+            storage_key: Option<SerializedStorageKey>,
+            name: Option<String>,
+        }
+        impl StorageBucketBuilder {
+            pub fn storage_key(mut self, storage_key: impl Into<SerializedStorageKey>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn build(self) -> Result<StorageBucket, String> {
+                Ok(StorageBucket {
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                    name: self.name,
+                })
+            }
+        }
+        impl StorageBucket {
+            pub const IDENTIFIER: &'static str = "Storage.StorageBucket";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct StorageBucketInfo {
+            #[serde(rename = "bucket")]
+            pub bucket: StorageBucket,
+            #[serde(rename = "id")]
+            pub id: String,
+            #[serde(rename = "expiration")]
+            pub expiration: super::network::TimeSinceEpoch,
+            #[doc = "Storage quota (bytes)."]
+            #[serde(rename = "quota")]
+            pub quota: f64,
+            #[serde(rename = "persistent")]
+            pub persistent: bool,
+            #[serde(rename = "durability")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub durability: StorageBucketsDurability,
+        }
+        impl StorageBucketInfo {
+            pub fn builder() -> StorageBucketInfoBuilder {
+                StorageBucketInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StorageBucketInfoBuilder {
+            bucket: Option<StorageBucket>,
+            id: Option<String>,
+            expiration: Option<super::network::TimeSinceEpoch>,
+            quota: Option<f64>,
+            persistent: Option<bool>,
+            durability: Option<StorageBucketsDurability>,
+        }
+        impl StorageBucketInfoBuilder {
+            pub fn bucket(mut self, bucket: impl Into<StorageBucket>) -> Self {
+                self.bucket = Some(bucket.into());
+                self
+            }
+            pub fn id(mut self, id: impl Into<String>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn expiration(
+                mut self,
+                expiration: impl Into<super::network::TimeSinceEpoch>,
+            ) -> Self {
+                self.expiration = Some(expiration.into());
+                self
+            }
+            pub fn quota(mut self, quota: impl Into<f64>) -> Self {
+                self.quota = Some(quota.into());
+                self
+            }
+            pub fn persistent(mut self, persistent: impl Into<bool>) -> Self {
+                self.persistent = Some(persistent.into());
+                self
+            }
+            pub fn durability(mut self, durability: impl Into<StorageBucketsDurability>) -> Self {
+                self.durability = Some(durability.into());
+                self
+            }
+            pub fn build(self) -> Result<StorageBucketInfo, String> {
+                Ok(StorageBucketInfo {
+                    bucket: self.bucket.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bucket))
+                    })?,
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    expiration: self.expiration.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expiration))
+                    })?,
+                    quota: self.quota.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(quota))
+                    })?,
+                    persistent: self.persistent.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(persistent))
+                    })?,
+                    durability: self.durability.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(durability))
+                    })?,
+                })
+            }
+        }
+        impl StorageBucketInfo {
+            pub const IDENTIFIER: &'static str = "Storage.StorageBucketInfo";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AttributionReportingSourceType {
+            #[serde(rename = "navigation")]
+            Navigation,
+            #[serde(rename = "event")]
+            Event,
+        }
+        impl AsRef<str> for AttributionReportingSourceType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AttributionReportingSourceType::Navigation => "navigation",
+                    AttributionReportingSourceType::Event => "event",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AttributionReportingSourceType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "navigation" | "Navigation" => Ok(AttributionReportingSourceType::Navigation),
+                    "event" | "Event" => Ok(AttributionReportingSourceType::Event),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct UnsignedInt64AsBase10(String);
+        impl UnsignedInt64AsBase10 {
+            pub fn new(val: impl Into<String>) -> Self {
+                UnsignedInt64AsBase10(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for UnsignedInt64AsBase10 {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<UnsignedInt64AsBase10> for String {
+            fn from(el: UnsignedInt64AsBase10) -> String {
+                el.0
+            }
+        }
+        impl From<String> for UnsignedInt64AsBase10 {
+            fn from(expr: String) -> Self {
+                UnsignedInt64AsBase10(expr)
+            }
+        }
+        impl UnsignedInt64AsBase10 {
+            pub const IDENTIFIER: &'static str = "Storage.UnsignedInt64AsBase10";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct UnsignedInt128AsBase16(String);
+        impl UnsignedInt128AsBase16 {
+            pub fn new(val: impl Into<String>) -> Self {
+                UnsignedInt128AsBase16(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for UnsignedInt128AsBase16 {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<UnsignedInt128AsBase16> for String {
+            fn from(el: UnsignedInt128AsBase16) -> String {
+                el.0
+            }
+        }
+        impl From<String> for UnsignedInt128AsBase16 {
+            fn from(expr: String) -> Self {
+                UnsignedInt128AsBase16(expr)
+            }
+        }
+        impl UnsignedInt128AsBase16 {
+            pub const IDENTIFIER: &'static str = "Storage.UnsignedInt128AsBase16";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct SignedInt64AsBase10(String);
+        impl SignedInt64AsBase10 {
+            pub fn new(val: impl Into<String>) -> Self {
+                SignedInt64AsBase10(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for SignedInt64AsBase10 {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<SignedInt64AsBase10> for String {
+            fn from(el: SignedInt64AsBase10) -> String {
+                el.0
+            }
+        }
+        impl From<String> for SignedInt64AsBase10 {
+            fn from(expr: String) -> Self {
+                SignedInt64AsBase10(expr)
+            }
+        }
+        impl SignedInt64AsBase10 {
+            pub const IDENTIFIER: &'static str = "Storage.SignedInt64AsBase10";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingFilterDataEntry {
+            #[serde(rename = "key")]
+            pub key: String,
+            #[serde(rename = "values")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub values: Vec<String>,
+        }
+        impl AttributionReportingFilterDataEntry {
+            pub fn new(key: impl Into<String>, values: Vec<String>) -> Self {
+                Self {
+                    key: key.into(),
+                    values,
+                }
+            }
+        }
+        impl AttributionReportingFilterDataEntry {
+            pub fn builder() -> AttributionReportingFilterDataEntryBuilder {
+                AttributionReportingFilterDataEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingFilterDataEntryBuilder {
+            key: Option<String>,
+            values: Option<Vec<String>>,
+        }
+        impl AttributionReportingFilterDataEntryBuilder {
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                let v = self.values.get_or_insert(Vec::new());
+                v.push(value.into());
+                self
+            }
+            pub fn values<I, S>(mut self, values: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.values.get_or_insert(Vec::new());
+                for val in values {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingFilterDataEntry, String> {
+                Ok(AttributionReportingFilterDataEntry {
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    values: self.values.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(values))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingFilterDataEntry {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingFilterDataEntry";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingFilterConfig {
+            #[serde(rename = "filterValues")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub filter_values: Vec<AttributionReportingFilterDataEntry>,
+            #[doc = "duration in seconds"]
+            #[serde(rename = "lookbackWindow")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub lookback_window: Option<i64>,
+        }
+        impl AttributionReportingFilterConfig {
+            pub fn new(filter_values: Vec<AttributionReportingFilterDataEntry>) -> Self {
+                Self {
+                    filter_values,
+                    lookback_window: None,
+                }
+            }
+        }
+        impl AttributionReportingFilterConfig {
+            pub fn builder() -> AttributionReportingFilterConfigBuilder {
+                AttributionReportingFilterConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingFilterConfigBuilder {
+            filter_values: Option<Vec<AttributionReportingFilterDataEntry>>,
+            lookback_window: Option<i64>,
+        }
+        impl AttributionReportingFilterConfigBuilder {
+            pub fn filter_value(
+                mut self,
+                filter_value: impl Into<AttributionReportingFilterDataEntry>,
+            ) -> Self {
+                let v = self.filter_values.get_or_insert(Vec::new());
+                v.push(filter_value.into());
+                self
+            }
+            pub fn filter_values<I, S>(mut self, filter_values: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingFilterDataEntry>,
+            {
+                let v = self.filter_values.get_or_insert(Vec::new());
+                for val in filter_values {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn lookback_window(mut self, lookback_window: impl Into<i64>) -> Self {
+                self.lookback_window = Some(lookback_window.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingFilterConfig, String> {
+                Ok(AttributionReportingFilterConfig {
+                    filter_values: self.filter_values.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(filter_values))
+                    })?,
+                    lookback_window: self.lookback_window,
+                })
+            }
+        }
+        impl AttributionReportingFilterConfig {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingFilterConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingFilterPair {
+            #[serde(rename = "filters")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub filters: Vec<AttributionReportingFilterConfig>,
+            #[serde(rename = "notFilters")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub not_filters: Vec<AttributionReportingFilterConfig>,
+        }
+        impl AttributionReportingFilterPair {
+            pub fn new(
+                filters: Vec<AttributionReportingFilterConfig>,
+                not_filters: Vec<AttributionReportingFilterConfig>,
+            ) -> Self {
+                Self {
+                    filters,
+                    not_filters,
+                }
+            }
+        }
+        impl AttributionReportingFilterPair {
+            pub fn builder() -> AttributionReportingFilterPairBuilder {
+                AttributionReportingFilterPairBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingFilterPairBuilder {
+            filters: Option<Vec<AttributionReportingFilterConfig>>,
+            not_filters: Option<Vec<AttributionReportingFilterConfig>>,
+        }
+        impl AttributionReportingFilterPairBuilder {
+            pub fn filter(mut self, filter: impl Into<AttributionReportingFilterConfig>) -> Self {
+                let v = self.filters.get_or_insert(Vec::new());
+                v.push(filter.into());
+                self
+            }
+            pub fn filters<I, S>(mut self, filters: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingFilterConfig>,
+            {
+                let v = self.filters.get_or_insert(Vec::new());
+                for val in filters {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn not_filter(
+                mut self,
+                not_filter: impl Into<AttributionReportingFilterConfig>,
+            ) -> Self {
+                let v = self.not_filters.get_or_insert(Vec::new());
+                v.push(not_filter.into());
+                self
+            }
+            pub fn not_filters<I, S>(mut self, not_filters: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingFilterConfig>,
+            {
+                let v = self.not_filters.get_or_insert(Vec::new());
+                for val in not_filters {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingFilterPair, String> {
+                Ok(AttributionReportingFilterPair {
+                    filters: self.filters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(filters))
+                    })?,
+                    not_filters: self.not_filters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(not_filters))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingFilterPair {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingFilterPair";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingAggregationKeysEntry {
+            #[serde(rename = "key")]
+            pub key: String,
+            #[serde(rename = "value")]
+            pub value: UnsignedInt128AsBase16,
+        }
+        impl AttributionReportingAggregationKeysEntry {
+            pub fn new(key: impl Into<String>, value: impl Into<UnsignedInt128AsBase16>) -> Self {
+                Self {
+                    key: key.into(),
+                    value: value.into(),
+                }
+            }
+        }
+        impl AttributionReportingAggregationKeysEntry {
+            pub fn builder() -> AttributionReportingAggregationKeysEntryBuilder {
+                AttributionReportingAggregationKeysEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingAggregationKeysEntryBuilder {
+            key: Option<String>,
+            value: Option<UnsignedInt128AsBase16>,
+        }
+        impl AttributionReportingAggregationKeysEntryBuilder {
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<UnsignedInt128AsBase16>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingAggregationKeysEntry, String> {
+                Ok(AttributionReportingAggregationKeysEntry {
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingAggregationKeysEntry {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingAggregationKeysEntry";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingEventReportWindows {
+            #[doc = "duration in seconds"]
+            #[serde(rename = "start")]
+            pub start: i64,
+            #[doc = "duration in seconds"]
+            #[serde(rename = "ends")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub ends: Vec<i64>,
+        }
+        impl AttributionReportingEventReportWindows {
+            pub fn new(start: impl Into<i64>, ends: Vec<i64>) -> Self {
+                Self {
+                    start: start.into(),
+                    ends,
+                }
+            }
+        }
+        impl AttributionReportingEventReportWindows {
+            pub fn builder() -> AttributionReportingEventReportWindowsBuilder {
+                AttributionReportingEventReportWindowsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingEventReportWindowsBuilder {
+            start: Option<i64>,
+            ends: Option<Vec<i64>>,
+        }
+        impl AttributionReportingEventReportWindowsBuilder {
+            pub fn start(mut self, start: impl Into<i64>) -> Self {
+                self.start = Some(start.into());
+                self
+            }
+            pub fn end(mut self, end: impl Into<i64>) -> Self {
+                let v = self.ends.get_or_insert(Vec::new());
+                v.push(end.into());
+                self
+            }
+            pub fn ends<I, S>(mut self, ends: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<i64>,
+            {
+                let v = self.ends.get_or_insert(Vec::new());
+                for val in ends {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingEventReportWindows, String> {
+                Ok(AttributionReportingEventReportWindows {
+                    start: self.start.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(start))
+                    })?,
+                    ends: self.ends.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(ends))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingEventReportWindows {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingEventReportWindows";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AttributionReportingTriggerDataMatching {
+            #[serde(rename = "exact")]
+            Exact,
+            #[serde(rename = "modulus")]
+            Modulus,
+        }
+        impl AsRef<str> for AttributionReportingTriggerDataMatching {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AttributionReportingTriggerDataMatching::Exact => "exact",
+                    AttributionReportingTriggerDataMatching::Modulus => "modulus",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AttributionReportingTriggerDataMatching {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "exact" | "Exact" => Ok(AttributionReportingTriggerDataMatching::Exact),
+                    "modulus" | "Modulus" => Ok(AttributionReportingTriggerDataMatching::Modulus),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingAggregatableDebugReportingData {
+            #[serde(rename = "keyPiece")]
+            pub key_piece: UnsignedInt128AsBase16,
+            #[doc = "number instead of integer because not all uint32 can be represented by\nint"]
+            #[serde(rename = "value")]
+            pub value: f64,
+            #[serde(rename = "types")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub types: Vec<String>,
+        }
+        impl AttributionReportingAggregatableDebugReportingData {
+            pub fn new(
+                key_piece: impl Into<UnsignedInt128AsBase16>,
+                value: impl Into<f64>,
+                types: Vec<String>,
+            ) -> Self {
+                Self {
+                    key_piece: key_piece.into(),
+                    value: value.into(),
+                    types,
+                }
+            }
+        }
+        impl AttributionReportingAggregatableDebugReportingData {
+            pub fn builder() -> AttributionReportingAggregatableDebugReportingDataBuilder {
+                AttributionReportingAggregatableDebugReportingDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingAggregatableDebugReportingDataBuilder {
+            key_piece: Option<UnsignedInt128AsBase16>,
+            value: Option<f64>,
+            types: Option<Vec<String>>,
+        }
+        impl AttributionReportingAggregatableDebugReportingDataBuilder {
+            pub fn key_piece(mut self, key_piece: impl Into<UnsignedInt128AsBase16>) -> Self {
+                self.key_piece = Some(key_piece.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<f64>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                let v = self.types.get_or_insert(Vec::new());
+                v.push(r#type.into());
+                self
+            }
+            pub fn types<I, S>(mut self, types: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.types.get_or_insert(Vec::new());
+                for val in types {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(
+                self,
+            ) -> Result<AttributionReportingAggregatableDebugReportingData, String> {
+                Ok(AttributionReportingAggregatableDebugReportingData {
+                    key_piece: self.key_piece.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_piece))
+                    })?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    types: self.types.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(types))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingAggregatableDebugReportingData {
+            pub const IDENTIFIER: &'static str =
+                "Storage.AttributionReportingAggregatableDebugReportingData";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingAggregatableDebugReportingConfig {
+            #[doc = "number instead of integer because not all uint32 can be represented by\nint, only present for source registrations"]
+            #[serde(rename = "budget")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub budget: Option<f64>,
+            #[serde(rename = "keyPiece")]
+            pub key_piece: UnsignedInt128AsBase16,
+            #[serde(rename = "debugData")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub debug_data: Vec<AttributionReportingAggregatableDebugReportingData>,
+            #[serde(rename = "aggregationCoordinatorOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub aggregation_coordinator_origin: Option<String>,
+        }
+        impl AttributionReportingAggregatableDebugReportingConfig {
+            pub fn new(
+                key_piece: impl Into<UnsignedInt128AsBase16>,
+                debug_data: Vec<AttributionReportingAggregatableDebugReportingData>,
+            ) -> Self {
+                Self {
+                    key_piece: key_piece.into(),
+                    debug_data,
+                    budget: None,
+                    aggregation_coordinator_origin: None,
+                }
+            }
+        }
+        impl AttributionReportingAggregatableDebugReportingConfig {
+            pub fn builder() -> AttributionReportingAggregatableDebugReportingConfigBuilder {
+                AttributionReportingAggregatableDebugReportingConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingAggregatableDebugReportingConfigBuilder {
+            budget: Option<f64>,
+            key_piece: Option<UnsignedInt128AsBase16>,
+            debug_data: Option<Vec<AttributionReportingAggregatableDebugReportingData>>,
+            aggregation_coordinator_origin: Option<String>,
+        }
+        impl AttributionReportingAggregatableDebugReportingConfigBuilder {
+            pub fn budget(mut self, budget: impl Into<f64>) -> Self {
+                self.budget = Some(budget.into());
+                self
+            }
+            pub fn key_piece(mut self, key_piece: impl Into<UnsignedInt128AsBase16>) -> Self {
+                self.key_piece = Some(key_piece.into());
+                self
+            }
+            pub fn debug_data(
+                mut self,
+                debug_data: impl Into<AttributionReportingAggregatableDebugReportingData>,
+            ) -> Self {
+                let v = self.debug_data.get_or_insert(Vec::new());
+                v.push(debug_data.into());
+                self
+            }
+            pub fn debug_datas<I, S>(mut self, debug_datas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingAggregatableDebugReportingData>,
+            {
+                let v = self.debug_data.get_or_insert(Vec::new());
+                for val in debug_datas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn aggregation_coordinator_origin(
+                mut self,
+                aggregation_coordinator_origin: impl Into<String>,
+            ) -> Self {
+                self.aggregation_coordinator_origin = Some(aggregation_coordinator_origin.into());
+                self
+            }
+            pub fn build(
+                self,
+            ) -> Result<AttributionReportingAggregatableDebugReportingConfig, String> {
+                Ok(AttributionReportingAggregatableDebugReportingConfig {
+                    budget: self.budget,
+                    key_piece: self.key_piece.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_piece))
+                    })?,
+                    debug_data: self.debug_data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(debug_data))
+                    })?,
+                    aggregation_coordinator_origin: self.aggregation_coordinator_origin,
+                })
+            }
+        }
+        impl AttributionReportingAggregatableDebugReportingConfig {
+            pub const IDENTIFIER: &'static str =
+                "Storage.AttributionReportingAggregatableDebugReportingConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionScopesData {
+            #[serde(rename = "values")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub values: Vec<String>,
+            #[doc = "number instead of integer because not all uint32 can be represented by\nint"]
+            #[serde(rename = "limit")]
+            pub limit: f64,
+            #[serde(rename = "maxEventStates")]
+            pub max_event_states: f64,
+        }
+        impl AttributionScopesData {
+            pub fn new(
+                values: Vec<String>,
+                limit: impl Into<f64>,
+                max_event_states: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    values,
+                    limit: limit.into(),
+                    max_event_states: max_event_states.into(),
+                }
+            }
+        }
+        impl AttributionScopesData {
+            pub fn builder() -> AttributionScopesDataBuilder {
+                AttributionScopesDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionScopesDataBuilder {
+            values: Option<Vec<String>>,
+            limit: Option<f64>,
+            max_event_states: Option<f64>,
+        }
+        impl AttributionScopesDataBuilder {
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                let v = self.values.get_or_insert(Vec::new());
+                v.push(value.into());
+                self
+            }
+            pub fn values<I, S>(mut self, values: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.values.get_or_insert(Vec::new());
+                for val in values {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn limit(mut self, limit: impl Into<f64>) -> Self {
+                self.limit = Some(limit.into());
+                self
+            }
+            pub fn max_event_states(mut self, max_event_states: impl Into<f64>) -> Self {
+                self.max_event_states = Some(max_event_states.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionScopesData, String> {
+                Ok(AttributionScopesData {
+                    values: self.values.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(values))
+                    })?,
+                    limit: self.limit.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(limit))
+                    })?,
+                    max_event_states: self.max_event_states.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(max_event_states)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl AttributionScopesData {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionScopesData";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingNamedBudgetDef {
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "budget")]
+            pub budget: i64,
+        }
+        impl AttributionReportingNamedBudgetDef {
+            pub fn new(name: impl Into<String>, budget: impl Into<i64>) -> Self {
+                Self {
+                    name: name.into(),
+                    budget: budget.into(),
+                }
+            }
+        }
+        impl AttributionReportingNamedBudgetDef {
+            pub fn builder() -> AttributionReportingNamedBudgetDefBuilder {
+                AttributionReportingNamedBudgetDefBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingNamedBudgetDefBuilder {
+            name: Option<String>,
+            budget: Option<i64>,
+        }
+        impl AttributionReportingNamedBudgetDefBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn budget(mut self, budget: impl Into<i64>) -> Self {
+                self.budget = Some(budget.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingNamedBudgetDef, String> {
+                Ok(AttributionReportingNamedBudgetDef {
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    budget: self.budget.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(budget))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingNamedBudgetDef {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingNamedBudgetDef";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingSourceRegistration {
+            #[serde(rename = "time")]
+            pub time: super::network::TimeSinceEpoch,
+            #[doc = "duration in seconds"]
+            #[serde(rename = "expiry")]
+            pub expiry: i64,
+            #[doc = "number instead of integer because not all uint32 can be represented by\nint"]
+            #[serde(rename = "triggerData")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub trigger_data: Vec<f64>,
+            #[serde(rename = "eventReportWindows")]
+            pub event_report_windows: AttributionReportingEventReportWindows,
+            #[doc = "duration in seconds"]
+            #[serde(rename = "aggregatableReportWindow")]
+            pub aggregatable_report_window: i64,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: AttributionReportingSourceType,
+            #[serde(rename = "sourceOrigin")]
+            pub source_origin: String,
+            #[serde(rename = "reportingOrigin")]
+            pub reporting_origin: String,
+            #[serde(rename = "destinationSites")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub destination_sites: Vec<String>,
+            #[serde(rename = "eventId")]
+            pub event_id: UnsignedInt64AsBase10,
+            #[serde(rename = "priority")]
+            pub priority: SignedInt64AsBase10,
+            #[serde(rename = "filterData")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub filter_data: Vec<AttributionReportingFilterDataEntry>,
+            #[serde(rename = "aggregationKeys")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub aggregation_keys: Vec<AttributionReportingAggregationKeysEntry>,
+            #[serde(rename = "debugKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub debug_key: Option<UnsignedInt64AsBase10>,
+            #[serde(rename = "triggerDataMatching")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub trigger_data_matching: AttributionReportingTriggerDataMatching,
+            #[serde(rename = "destinationLimitPriority")]
+            pub destination_limit_priority: SignedInt64AsBase10,
+            #[serde(rename = "aggregatableDebugReportingConfig")]
+            pub aggregatable_debug_reporting_config:
+                AttributionReportingAggregatableDebugReportingConfig,
+            #[serde(rename = "scopesData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub scopes_data: Option<AttributionScopesData>,
+            #[serde(rename = "maxEventLevelReports")]
+            pub max_event_level_reports: i64,
+            #[serde(rename = "namedBudgets")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub named_budgets: Vec<AttributionReportingNamedBudgetDef>,
+            #[serde(rename = "debugReporting")]
+            pub debug_reporting: bool,
+            #[serde(rename = "eventLevelEpsilon")]
+            pub event_level_epsilon: f64,
+        }
+        impl AttributionReportingSourceRegistration {
+            pub fn builder() -> AttributionReportingSourceRegistrationBuilder {
+                AttributionReportingSourceRegistrationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingSourceRegistrationBuilder {
+            time: Option<super::network::TimeSinceEpoch>,
+            expiry: Option<i64>,
+            trigger_data: Option<Vec<f64>>,
+            event_report_windows: Option<AttributionReportingEventReportWindows>,
+            aggregatable_report_window: Option<i64>,
+            r#type: Option<AttributionReportingSourceType>,
+            source_origin: Option<String>,
+            reporting_origin: Option<String>,
+            destination_sites: Option<Vec<String>>,
+            event_id: Option<UnsignedInt64AsBase10>,
+            priority: Option<SignedInt64AsBase10>,
+            filter_data: Option<Vec<AttributionReportingFilterDataEntry>>,
+            aggregation_keys: Option<Vec<AttributionReportingAggregationKeysEntry>>,
+            debug_key: Option<UnsignedInt64AsBase10>,
+            trigger_data_matching: Option<AttributionReportingTriggerDataMatching>,
+            destination_limit_priority: Option<SignedInt64AsBase10>,
+            aggregatable_debug_reporting_config:
+                Option<AttributionReportingAggregatableDebugReportingConfig>,
+            scopes_data: Option<AttributionScopesData>,
+            max_event_level_reports: Option<i64>,
+            named_budgets: Option<Vec<AttributionReportingNamedBudgetDef>>,
+            debug_reporting: Option<bool>,
+            event_level_epsilon: Option<f64>,
+        }
+        impl AttributionReportingSourceRegistrationBuilder {
+            pub fn time(mut self, time: impl Into<super::network::TimeSinceEpoch>) -> Self {
+                self.time = Some(time.into());
+                self
+            }
+            pub fn expiry(mut self, expiry: impl Into<i64>) -> Self {
+                self.expiry = Some(expiry.into());
+                self
+            }
+            pub fn trigger_data(mut self, trigger_data: impl Into<f64>) -> Self {
+                let v = self.trigger_data.get_or_insert(Vec::new());
+                v.push(trigger_data.into());
+                self
+            }
+            pub fn trigger_datas<I, S>(mut self, trigger_datas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<f64>,
+            {
+                let v = self.trigger_data.get_or_insert(Vec::new());
+                for val in trigger_datas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn event_report_windows(
+                mut self,
+                event_report_windows: impl Into<AttributionReportingEventReportWindows>,
+            ) -> Self {
+                self.event_report_windows = Some(event_report_windows.into());
+                self
+            }
+            pub fn aggregatable_report_window(
+                mut self,
+                aggregatable_report_window: impl Into<i64>,
+            ) -> Self {
+                self.aggregatable_report_window = Some(aggregatable_report_window.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<AttributionReportingSourceType>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn source_origin(mut self, source_origin: impl Into<String>) -> Self {
+                self.source_origin = Some(source_origin.into());
+                self
+            }
+            pub fn reporting_origin(mut self, reporting_origin: impl Into<String>) -> Self {
+                self.reporting_origin = Some(reporting_origin.into());
+                self
+            }
+            pub fn destination_site(mut self, destination_site: impl Into<String>) -> Self {
+                let v = self.destination_sites.get_or_insert(Vec::new());
+                v.push(destination_site.into());
+                self
+            }
+            pub fn destination_sites<I, S>(mut self, destination_sites: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.destination_sites.get_or_insert(Vec::new());
+                for val in destination_sites {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn event_id(mut self, event_id: impl Into<UnsignedInt64AsBase10>) -> Self {
+                self.event_id = Some(event_id.into());
+                self
+            }
+            pub fn priority(mut self, priority: impl Into<SignedInt64AsBase10>) -> Self {
+                self.priority = Some(priority.into());
+                self
+            }
+            pub fn filter_data(
+                mut self,
+                filter_data: impl Into<AttributionReportingFilterDataEntry>,
+            ) -> Self {
+                let v = self.filter_data.get_or_insert(Vec::new());
+                v.push(filter_data.into());
+                self
+            }
+            pub fn filter_datas<I, S>(mut self, filter_datas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingFilterDataEntry>,
+            {
+                let v = self.filter_data.get_or_insert(Vec::new());
+                for val in filter_datas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn aggregation_key(
+                mut self,
+                aggregation_key: impl Into<AttributionReportingAggregationKeysEntry>,
+            ) -> Self {
+                let v = self.aggregation_keys.get_or_insert(Vec::new());
+                v.push(aggregation_key.into());
+                self
+            }
+            pub fn aggregation_keys<I, S>(mut self, aggregation_keys: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingAggregationKeysEntry>,
+            {
+                let v = self.aggregation_keys.get_or_insert(Vec::new());
+                for val in aggregation_keys {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn debug_key(mut self, debug_key: impl Into<UnsignedInt64AsBase10>) -> Self {
+                self.debug_key = Some(debug_key.into());
+                self
+            }
+            pub fn trigger_data_matching(
+                mut self,
+                trigger_data_matching: impl Into<AttributionReportingTriggerDataMatching>,
+            ) -> Self {
+                self.trigger_data_matching = Some(trigger_data_matching.into());
+                self
+            }
+            pub fn destination_limit_priority(
+                mut self,
+                destination_limit_priority: impl Into<SignedInt64AsBase10>,
+            ) -> Self {
+                self.destination_limit_priority = Some(destination_limit_priority.into());
+                self
+            }
+            pub fn aggregatable_debug_reporting_config(
+                mut self,
+                aggregatable_debug_reporting_config: impl Into<
+                    AttributionReportingAggregatableDebugReportingConfig,
+                >,
+            ) -> Self {
+                self.aggregatable_debug_reporting_config =
+                    Some(aggregatable_debug_reporting_config.into());
+                self
+            }
+            pub fn scopes_data(mut self, scopes_data: impl Into<AttributionScopesData>) -> Self {
+                self.scopes_data = Some(scopes_data.into());
+                self
+            }
+            pub fn max_event_level_reports(
+                mut self,
+                max_event_level_reports: impl Into<i64>,
+            ) -> Self {
+                self.max_event_level_reports = Some(max_event_level_reports.into());
+                self
+            }
+            pub fn named_budget(
+                mut self,
+                named_budget: impl Into<AttributionReportingNamedBudgetDef>,
+            ) -> Self {
+                let v = self.named_budgets.get_or_insert(Vec::new());
+                v.push(named_budget.into());
+                self
+            }
+            pub fn named_budgets<I, S>(mut self, named_budgets: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingNamedBudgetDef>,
+            {
+                let v = self.named_budgets.get_or_insert(Vec::new());
+                for val in named_budgets {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn debug_reporting(mut self, debug_reporting: impl Into<bool>) -> Self {
+                self.debug_reporting = Some(debug_reporting.into());
+                self
+            }
+            pub fn event_level_epsilon(mut self, event_level_epsilon: impl Into<f64>) -> Self {
+                self.event_level_epsilon = Some(event_level_epsilon.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingSourceRegistration, String> {
+                Ok(AttributionReportingSourceRegistration {
+                    time: self.time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(time))
+                    })?,
+                    expiry: self.expiry.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(expiry))
+                    })?,
+                    trigger_data: self.trigger_data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(trigger_data))
+                    })?,
+                    event_report_windows: self.event_report_windows.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(event_report_windows)
+                        )
+                    })?,
+                    aggregatable_report_window: self.aggregatable_report_window.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(aggregatable_report_window)
+                            )
+                        },
+                    )?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    source_origin: self.source_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source_origin))
+                    })?,
+                    reporting_origin: self.reporting_origin.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(reporting_origin)
+                        )
+                    })?,
+                    destination_sites: self.destination_sites.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(destination_sites)
+                        )
+                    })?,
+                    event_id: self.event_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(event_id))
+                    })?,
+                    priority: self.priority.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(priority))
+                    })?,
+                    filter_data: self.filter_data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(filter_data))
+                    })?,
+                    aggregation_keys: self.aggregation_keys.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(aggregation_keys)
+                        )
+                    })?,
+                    debug_key: self.debug_key,
+                    trigger_data_matching: self.trigger_data_matching.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(trigger_data_matching)
+                        )
+                    })?,
+                    destination_limit_priority: self.destination_limit_priority.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(destination_limit_priority)
+                            )
+                        },
+                    )?,
+                    aggregatable_debug_reporting_config: self
+                        .aggregatable_debug_reporting_config
+                        .ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(aggregatable_debug_reporting_config)
+                        )
+                    })?,
+                    scopes_data: self.scopes_data,
+                    max_event_level_reports: self.max_event_level_reports.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(max_event_level_reports)
+                        )
+                    })?,
+                    named_budgets: self.named_budgets.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(named_budgets))
+                    })?,
+                    debug_reporting: self.debug_reporting.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(debug_reporting))
+                    })?,
+                    event_level_epsilon: self.event_level_epsilon.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(event_level_epsilon)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingSourceRegistration {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingSourceRegistration";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AttributionReportingSourceRegistrationResult {
+            #[serde(rename = "success")]
+            Success,
+            #[serde(rename = "internalError")]
+            InternalError,
+            #[serde(rename = "insufficientSourceCapacity")]
+            InsufficientSourceCapacity,
+            #[serde(rename = "insufficientUniqueDestinationCapacity")]
+            InsufficientUniqueDestinationCapacity,
+            #[serde(rename = "excessiveReportingOrigins")]
+            ExcessiveReportingOrigins,
+            #[serde(rename = "prohibitedByBrowserPolicy")]
+            ProhibitedByBrowserPolicy,
+            #[serde(rename = "successNoised")]
+            SuccessNoised,
+            #[serde(rename = "destinationReportingLimitReached")]
+            DestinationReportingLimitReached,
+            #[serde(rename = "destinationGlobalLimitReached")]
+            DestinationGlobalLimitReached,
+            #[serde(rename = "destinationBothLimitsReached")]
+            DestinationBothLimitsReached,
+            #[serde(rename = "reportingOriginsPerSiteLimitReached")]
+            ReportingOriginsPerSiteLimitReached,
+            #[serde(rename = "exceedsMaxChannelCapacity")]
+            ExceedsMaxChannelCapacity,
+            #[serde(rename = "exceedsMaxScopesChannelCapacity")]
+            ExceedsMaxScopesChannelCapacity,
+            #[serde(rename = "exceedsMaxTriggerStateCardinality")]
+            ExceedsMaxTriggerStateCardinality,
+            #[serde(rename = "exceedsMaxEventStatesLimit")]
+            ExceedsMaxEventStatesLimit,
+            #[serde(rename = "destinationPerDayReportingLimitReached")]
+            DestinationPerDayReportingLimitReached,
+        }
+        impl AsRef<str> for AttributionReportingSourceRegistrationResult {
+            fn as_ref(&self) -> &str {
+                match self { AttributionReportingSourceRegistrationResult :: Success => "success" , AttributionReportingSourceRegistrationResult :: InternalError => "internalError" , AttributionReportingSourceRegistrationResult :: InsufficientSourceCapacity => "insufficientSourceCapacity" , AttributionReportingSourceRegistrationResult :: InsufficientUniqueDestinationCapacity => "insufficientUniqueDestinationCapacity" , AttributionReportingSourceRegistrationResult :: ExcessiveReportingOrigins => "excessiveReportingOrigins" , AttributionReportingSourceRegistrationResult :: ProhibitedByBrowserPolicy => "prohibitedByBrowserPolicy" , AttributionReportingSourceRegistrationResult :: SuccessNoised => "successNoised" , AttributionReportingSourceRegistrationResult :: DestinationReportingLimitReached => "destinationReportingLimitReached" , AttributionReportingSourceRegistrationResult :: DestinationGlobalLimitReached => "destinationGlobalLimitReached" , AttributionReportingSourceRegistrationResult :: DestinationBothLimitsReached => "destinationBothLimitsReached" , AttributionReportingSourceRegistrationResult :: ReportingOriginsPerSiteLimitReached => "reportingOriginsPerSiteLimitReached" , AttributionReportingSourceRegistrationResult :: ExceedsMaxChannelCapacity => "exceedsMaxChannelCapacity" , AttributionReportingSourceRegistrationResult :: ExceedsMaxScopesChannelCapacity => "exceedsMaxScopesChannelCapacity" , AttributionReportingSourceRegistrationResult :: ExceedsMaxTriggerStateCardinality => "exceedsMaxTriggerStateCardinality" , AttributionReportingSourceRegistrationResult :: ExceedsMaxEventStatesLimit => "exceedsMaxEventStatesLimit" , AttributionReportingSourceRegistrationResult :: DestinationPerDayReportingLimitReached => "destinationPerDayReportingLimitReached" }
+            }
+        }
+        impl ::std::str::FromStr for AttributionReportingSourceRegistrationResult {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s { "success" | "Success" => Ok (AttributionReportingSourceRegistrationResult :: Success) , "internalError" | "InternalError" | "internalerror" => Ok (AttributionReportingSourceRegistrationResult :: InternalError) , "insufficientSourceCapacity" | "InsufficientSourceCapacity" | "insufficientsourcecapacity" => Ok (AttributionReportingSourceRegistrationResult :: InsufficientSourceCapacity) , "insufficientUniqueDestinationCapacity" | "InsufficientUniqueDestinationCapacity" | "insufficientuniquedestinationcapacity" => Ok (AttributionReportingSourceRegistrationResult :: InsufficientUniqueDestinationCapacity) , "excessiveReportingOrigins" | "ExcessiveReportingOrigins" | "excessivereportingorigins" => Ok (AttributionReportingSourceRegistrationResult :: ExcessiveReportingOrigins) , "prohibitedByBrowserPolicy" | "ProhibitedByBrowserPolicy" | "prohibitedbybrowserpolicy" => Ok (AttributionReportingSourceRegistrationResult :: ProhibitedByBrowserPolicy) , "successNoised" | "SuccessNoised" | "successnoised" => Ok (AttributionReportingSourceRegistrationResult :: SuccessNoised) , "destinationReportingLimitReached" | "DestinationReportingLimitReached" | "destinationreportinglimitreached" => Ok (AttributionReportingSourceRegistrationResult :: DestinationReportingLimitReached) , "destinationGlobalLimitReached" | "DestinationGlobalLimitReached" | "destinationgloballimitreached" => Ok (AttributionReportingSourceRegistrationResult :: DestinationGlobalLimitReached) , "destinationBothLimitsReached" | "DestinationBothLimitsReached" | "destinationbothlimitsreached" => Ok (AttributionReportingSourceRegistrationResult :: DestinationBothLimitsReached) , "reportingOriginsPerSiteLimitReached" | "ReportingOriginsPerSiteLimitReached" | "reportingoriginspersitelimitreached" => Ok (AttributionReportingSourceRegistrationResult :: ReportingOriginsPerSiteLimitReached) , "exceedsMaxChannelCapacity" | "ExceedsMaxChannelCapacity" | "exceedsmaxchannelcapacity" => Ok (AttributionReportingSourceRegistrationResult :: ExceedsMaxChannelCapacity) , "exceedsMaxScopesChannelCapacity" | "ExceedsMaxScopesChannelCapacity" | "exceedsmaxscopeschannelcapacity" => Ok (AttributionReportingSourceRegistrationResult :: ExceedsMaxScopesChannelCapacity) , "exceedsMaxTriggerStateCardinality" | "ExceedsMaxTriggerStateCardinality" | "exceedsmaxtriggerstatecardinality" => Ok (AttributionReportingSourceRegistrationResult :: ExceedsMaxTriggerStateCardinality) , "exceedsMaxEventStatesLimit" | "ExceedsMaxEventStatesLimit" | "exceedsmaxeventstateslimit" => Ok (AttributionReportingSourceRegistrationResult :: ExceedsMaxEventStatesLimit) , "destinationPerDayReportingLimitReached" | "DestinationPerDayReportingLimitReached" | "destinationperdayreportinglimitreached" => Ok (AttributionReportingSourceRegistrationResult :: DestinationPerDayReportingLimitReached) , _ => Err (s . to_string ()) }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AttributionReportingSourceRegistrationTimeConfig {
+            #[serde(rename = "include")]
+            Include,
+            #[serde(rename = "exclude")]
+            Exclude,
+        }
+        impl AsRef<str> for AttributionReportingSourceRegistrationTimeConfig {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AttributionReportingSourceRegistrationTimeConfig::Include => "include",
+                    AttributionReportingSourceRegistrationTimeConfig::Exclude => "exclude",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AttributionReportingSourceRegistrationTimeConfig {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "include" | "Include" => {
+                        Ok(AttributionReportingSourceRegistrationTimeConfig::Include)
+                    }
+                    "exclude" | "Exclude" => {
+                        Ok(AttributionReportingSourceRegistrationTimeConfig::Exclude)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingAggregatableValueDictEntry {
+            #[serde(rename = "key")]
+            pub key: String,
+            #[doc = "number instead of integer because not all uint32 can be represented by\nint"]
+            #[serde(rename = "value")]
+            pub value: f64,
+            #[serde(rename = "filteringId")]
+            pub filtering_id: UnsignedInt64AsBase10,
+        }
+        impl AttributionReportingAggregatableValueDictEntry {
+            pub fn new(
+                key: impl Into<String>,
+                value: impl Into<f64>,
+                filtering_id: impl Into<UnsignedInt64AsBase10>,
+            ) -> Self {
+                Self {
+                    key: key.into(),
+                    value: value.into(),
+                    filtering_id: filtering_id.into(),
+                }
+            }
+        }
+        impl AttributionReportingAggregatableValueDictEntry {
+            pub fn builder() -> AttributionReportingAggregatableValueDictEntryBuilder {
+                AttributionReportingAggregatableValueDictEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingAggregatableValueDictEntryBuilder {
+            key: Option<String>,
+            value: Option<f64>,
+            filtering_id: Option<UnsignedInt64AsBase10>,
+        }
+        impl AttributionReportingAggregatableValueDictEntryBuilder {
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<f64>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn filtering_id(mut self, filtering_id: impl Into<UnsignedInt64AsBase10>) -> Self {
+                self.filtering_id = Some(filtering_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingAggregatableValueDictEntry, String> {
+                Ok(AttributionReportingAggregatableValueDictEntry {
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    filtering_id: self.filtering_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(filtering_id))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingAggregatableValueDictEntry {
+            pub const IDENTIFIER: &'static str =
+                "Storage.AttributionReportingAggregatableValueDictEntry";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingAggregatableValueEntry {
+            #[serde(rename = "values")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub values: Vec<AttributionReportingAggregatableValueDictEntry>,
+            #[serde(rename = "filters")]
+            pub filters: AttributionReportingFilterPair,
+        }
+        impl AttributionReportingAggregatableValueEntry {
+            pub fn new(
+                values: Vec<AttributionReportingAggregatableValueDictEntry>,
+                filters: impl Into<AttributionReportingFilterPair>,
+            ) -> Self {
+                Self {
+                    values,
+                    filters: filters.into(),
+                }
+            }
+        }
+        impl AttributionReportingAggregatableValueEntry {
+            pub fn builder() -> AttributionReportingAggregatableValueEntryBuilder {
+                AttributionReportingAggregatableValueEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingAggregatableValueEntryBuilder {
+            values: Option<Vec<AttributionReportingAggregatableValueDictEntry>>,
+            filters: Option<AttributionReportingFilterPair>,
+        }
+        impl AttributionReportingAggregatableValueEntryBuilder {
+            pub fn value(
+                mut self,
+                value: impl Into<AttributionReportingAggregatableValueDictEntry>,
+            ) -> Self {
+                let v = self.values.get_or_insert(Vec::new());
+                v.push(value.into());
+                self
+            }
+            pub fn values<I, S>(mut self, values: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingAggregatableValueDictEntry>,
+            {
+                let v = self.values.get_or_insert(Vec::new());
+                for val in values {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn filters(mut self, filters: impl Into<AttributionReportingFilterPair>) -> Self {
+                self.filters = Some(filters.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingAggregatableValueEntry, String> {
+                Ok(AttributionReportingAggregatableValueEntry {
+                    values: self.values.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(values))
+                    })?,
+                    filters: self.filters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(filters))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingAggregatableValueEntry {
+            pub const IDENTIFIER: &'static str =
+                "Storage.AttributionReportingAggregatableValueEntry";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingEventTriggerData {
+            #[serde(rename = "data")]
+            pub data: UnsignedInt64AsBase10,
+            #[serde(rename = "priority")]
+            pub priority: SignedInt64AsBase10,
+            #[serde(rename = "dedupKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub dedup_key: Option<UnsignedInt64AsBase10>,
+            #[serde(rename = "filters")]
+            pub filters: AttributionReportingFilterPair,
+        }
+        impl AttributionReportingEventTriggerData {
+            pub fn new(
+                data: impl Into<UnsignedInt64AsBase10>,
+                priority: impl Into<SignedInt64AsBase10>,
+                filters: impl Into<AttributionReportingFilterPair>,
+            ) -> Self {
+                Self {
+                    data: data.into(),
+                    priority: priority.into(),
+                    filters: filters.into(),
+                    dedup_key: None,
+                }
+            }
+        }
+        impl AttributionReportingEventTriggerData {
+            pub fn builder() -> AttributionReportingEventTriggerDataBuilder {
+                AttributionReportingEventTriggerDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingEventTriggerDataBuilder {
+            data: Option<UnsignedInt64AsBase10>,
+            priority: Option<SignedInt64AsBase10>,
+            dedup_key: Option<UnsignedInt64AsBase10>,
+            filters: Option<AttributionReportingFilterPair>,
+        }
+        impl AttributionReportingEventTriggerDataBuilder {
+            pub fn data(mut self, data: impl Into<UnsignedInt64AsBase10>) -> Self {
+                self.data = Some(data.into());
+                self
+            }
+            pub fn priority(mut self, priority: impl Into<SignedInt64AsBase10>) -> Self {
+                self.priority = Some(priority.into());
+                self
+            }
+            pub fn dedup_key(mut self, dedup_key: impl Into<UnsignedInt64AsBase10>) -> Self {
+                self.dedup_key = Some(dedup_key.into());
+                self
+            }
+            pub fn filters(mut self, filters: impl Into<AttributionReportingFilterPair>) -> Self {
+                self.filters = Some(filters.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingEventTriggerData, String> {
+                Ok(AttributionReportingEventTriggerData {
+                    data: self.data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(data))
+                    })?,
+                    priority: self.priority.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(priority))
+                    })?,
+                    dedup_key: self.dedup_key,
+                    filters: self.filters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(filters))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingEventTriggerData {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingEventTriggerData";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingAggregatableTriggerData {
+            #[serde(rename = "keyPiece")]
+            pub key_piece: UnsignedInt128AsBase16,
+            #[serde(rename = "sourceKeys")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub source_keys: Vec<String>,
+            #[serde(rename = "filters")]
+            pub filters: AttributionReportingFilterPair,
+        }
+        impl AttributionReportingAggregatableTriggerData {
+            pub fn new(
+                key_piece: impl Into<UnsignedInt128AsBase16>,
+                source_keys: Vec<String>,
+                filters: impl Into<AttributionReportingFilterPair>,
+            ) -> Self {
+                Self {
+                    key_piece: key_piece.into(),
+                    source_keys,
+                    filters: filters.into(),
+                }
+            }
+        }
+        impl AttributionReportingAggregatableTriggerData {
+            pub fn builder() -> AttributionReportingAggregatableTriggerDataBuilder {
+                AttributionReportingAggregatableTriggerDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingAggregatableTriggerDataBuilder {
+            key_piece: Option<UnsignedInt128AsBase16>,
+            source_keys: Option<Vec<String>>,
+            filters: Option<AttributionReportingFilterPair>,
+        }
+        impl AttributionReportingAggregatableTriggerDataBuilder {
+            pub fn key_piece(mut self, key_piece: impl Into<UnsignedInt128AsBase16>) -> Self {
+                self.key_piece = Some(key_piece.into());
+                self
+            }
+            pub fn source_key(mut self, source_key: impl Into<String>) -> Self {
+                let v = self.source_keys.get_or_insert(Vec::new());
+                v.push(source_key.into());
+                self
+            }
+            pub fn source_keys<I, S>(mut self, source_keys: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.source_keys.get_or_insert(Vec::new());
+                for val in source_keys {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn filters(mut self, filters: impl Into<AttributionReportingFilterPair>) -> Self {
+                self.filters = Some(filters.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingAggregatableTriggerData, String> {
+                Ok(AttributionReportingAggregatableTriggerData {
+                    key_piece: self.key_piece.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(key_piece))
+                    })?,
+                    source_keys: self.source_keys.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(source_keys))
+                    })?,
+                    filters: self.filters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(filters))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingAggregatableTriggerData {
+            pub const IDENTIFIER: &'static str =
+                "Storage.AttributionReportingAggregatableTriggerData";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingAggregatableDedupKey {
+            #[serde(rename = "dedupKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub dedup_key: Option<UnsignedInt64AsBase10>,
+            #[serde(rename = "filters")]
+            pub filters: AttributionReportingFilterPair,
+        }
+        impl AttributionReportingAggregatableDedupKey {
+            pub fn new(filters: impl Into<AttributionReportingFilterPair>) -> Self {
+                Self {
+                    filters: filters.into(),
+                    dedup_key: None,
+                }
+            }
+        }
+        impl AttributionReportingAggregatableDedupKey {
+            pub fn builder() -> AttributionReportingAggregatableDedupKeyBuilder {
+                AttributionReportingAggregatableDedupKeyBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingAggregatableDedupKeyBuilder {
+            dedup_key: Option<UnsignedInt64AsBase10>,
+            filters: Option<AttributionReportingFilterPair>,
+        }
+        impl AttributionReportingAggregatableDedupKeyBuilder {
+            pub fn dedup_key(mut self, dedup_key: impl Into<UnsignedInt64AsBase10>) -> Self {
+                self.dedup_key = Some(dedup_key.into());
+                self
+            }
+            pub fn filters(mut self, filters: impl Into<AttributionReportingFilterPair>) -> Self {
+                self.filters = Some(filters.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingAggregatableDedupKey, String> {
+                Ok(AttributionReportingAggregatableDedupKey {
+                    dedup_key: self.dedup_key,
+                    filters: self.filters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(filters))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingAggregatableDedupKey {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingAggregatableDedupKey";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingNamedBudgetCandidate {
+            #[serde(rename = "name")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[serde(rename = "filters")]
+            pub filters: AttributionReportingFilterPair,
+        }
+        impl AttributionReportingNamedBudgetCandidate {
+            pub fn new(filters: impl Into<AttributionReportingFilterPair>) -> Self {
+                Self {
+                    filters: filters.into(),
+                    name: None,
+                }
+            }
+        }
+        impl AttributionReportingNamedBudgetCandidate {
+            pub fn builder() -> AttributionReportingNamedBudgetCandidateBuilder {
+                AttributionReportingNamedBudgetCandidateBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingNamedBudgetCandidateBuilder {
+            name: Option<String>,
+            filters: Option<AttributionReportingFilterPair>,
+        }
+        impl AttributionReportingNamedBudgetCandidateBuilder {
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn filters(mut self, filters: impl Into<AttributionReportingFilterPair>) -> Self {
+                self.filters = Some(filters.into());
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingNamedBudgetCandidate, String> {
+                Ok(AttributionReportingNamedBudgetCandidate {
+                    name: self.name,
+                    filters: self.filters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(filters))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingNamedBudgetCandidate {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingNamedBudgetCandidate";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttributionReportingTriggerRegistration {
+            #[serde(rename = "filters")]
+            pub filters: AttributionReportingFilterPair,
+            #[serde(rename = "debugKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub debug_key: Option<UnsignedInt64AsBase10>,
+            #[serde(rename = "aggregatableDedupKeys")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub aggregatable_dedup_keys: Vec<AttributionReportingAggregatableDedupKey>,
+            #[serde(rename = "eventTriggerData")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub event_trigger_data: Vec<AttributionReportingEventTriggerData>,
+            #[serde(rename = "aggregatableTriggerData")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub aggregatable_trigger_data: Vec<AttributionReportingAggregatableTriggerData>,
+            #[serde(rename = "aggregatableValues")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub aggregatable_values: Vec<AttributionReportingAggregatableValueEntry>,
+            #[serde(rename = "aggregatableFilteringIdMaxBytes")]
+            pub aggregatable_filtering_id_max_bytes: i64,
+            #[serde(rename = "debugReporting")]
+            pub debug_reporting: bool,
+            #[serde(rename = "aggregationCoordinatorOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub aggregation_coordinator_origin: Option<String>,
+            #[serde(rename = "sourceRegistrationTimeConfig")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub source_registration_time_config: AttributionReportingSourceRegistrationTimeConfig,
+            #[serde(rename = "triggerContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub trigger_context_id: Option<String>,
+            #[serde(rename = "aggregatableDebugReportingConfig")]
+            pub aggregatable_debug_reporting_config:
+                AttributionReportingAggregatableDebugReportingConfig,
+            #[serde(rename = "scopes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub scopes: Vec<String>,
+            #[serde(rename = "namedBudgets")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub named_budgets: Vec<AttributionReportingNamedBudgetCandidate>,
+        }
+        impl AttributionReportingTriggerRegistration {
+            pub fn builder() -> AttributionReportingTriggerRegistrationBuilder {
+                AttributionReportingTriggerRegistrationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttributionReportingTriggerRegistrationBuilder {
+            filters: Option<AttributionReportingFilterPair>,
+            debug_key: Option<UnsignedInt64AsBase10>,
+            aggregatable_dedup_keys: Option<Vec<AttributionReportingAggregatableDedupKey>>,
+            event_trigger_data: Option<Vec<AttributionReportingEventTriggerData>>,
+            aggregatable_trigger_data: Option<Vec<AttributionReportingAggregatableTriggerData>>,
+            aggregatable_values: Option<Vec<AttributionReportingAggregatableValueEntry>>,
+            aggregatable_filtering_id_max_bytes: Option<i64>,
+            debug_reporting: Option<bool>,
+            aggregation_coordinator_origin: Option<String>,
+            source_registration_time_config:
+                Option<AttributionReportingSourceRegistrationTimeConfig>,
+            trigger_context_id: Option<String>,
+            aggregatable_debug_reporting_config:
+                Option<AttributionReportingAggregatableDebugReportingConfig>,
+            scopes: Option<Vec<String>>,
+            named_budgets: Option<Vec<AttributionReportingNamedBudgetCandidate>>,
+        }
+        impl AttributionReportingTriggerRegistrationBuilder {
+            pub fn filters(mut self, filters: impl Into<AttributionReportingFilterPair>) -> Self {
+                self.filters = Some(filters.into());
+                self
+            }
+            pub fn debug_key(mut self, debug_key: impl Into<UnsignedInt64AsBase10>) -> Self {
+                self.debug_key = Some(debug_key.into());
+                self
+            }
+            pub fn aggregatable_dedup_key(
+                mut self,
+                aggregatable_dedup_key: impl Into<AttributionReportingAggregatableDedupKey>,
+            ) -> Self {
+                let v = self.aggregatable_dedup_keys.get_or_insert(Vec::new());
+                v.push(aggregatable_dedup_key.into());
+                self
+            }
+            pub fn aggregatable_dedup_keys<I, S>(mut self, aggregatable_dedup_keys: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingAggregatableDedupKey>,
+            {
+                let v = self.aggregatable_dedup_keys.get_or_insert(Vec::new());
+                for val in aggregatable_dedup_keys {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn event_trigger_data(
+                mut self,
+                event_trigger_data: impl Into<AttributionReportingEventTriggerData>,
+            ) -> Self {
+                let v = self.event_trigger_data.get_or_insert(Vec::new());
+                v.push(event_trigger_data.into());
+                self
+            }
+            pub fn event_trigger_datas<I, S>(mut self, event_trigger_datas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingEventTriggerData>,
+            {
+                let v = self.event_trigger_data.get_or_insert(Vec::new());
+                for val in event_trigger_datas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn aggregatable_trigger_data(
+                mut self,
+                aggregatable_trigger_data: impl Into<AttributionReportingAggregatableTriggerData>,
+            ) -> Self {
+                let v = self.aggregatable_trigger_data.get_or_insert(Vec::new());
+                v.push(aggregatable_trigger_data.into());
+                self
+            }
+            pub fn aggregatable_trigger_datas<I, S>(mut self, aggregatable_trigger_datas: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingAggregatableTriggerData>,
+            {
+                let v = self.aggregatable_trigger_data.get_or_insert(Vec::new());
+                for val in aggregatable_trigger_datas {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn aggregatable_value(
+                mut self,
+                aggregatable_value: impl Into<AttributionReportingAggregatableValueEntry>,
+            ) -> Self {
+                let v = self.aggregatable_values.get_or_insert(Vec::new());
+                v.push(aggregatable_value.into());
+                self
+            }
+            pub fn aggregatable_values<I, S>(mut self, aggregatable_values: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingAggregatableValueEntry>,
+            {
+                let v = self.aggregatable_values.get_or_insert(Vec::new());
+                for val in aggregatable_values {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn aggregatable_filtering_id_max_bytes(
+                mut self,
+                aggregatable_filtering_id_max_bytes: impl Into<i64>,
+            ) -> Self {
+                self.aggregatable_filtering_id_max_bytes =
+                    Some(aggregatable_filtering_id_max_bytes.into());
+                self
+            }
+            pub fn debug_reporting(mut self, debug_reporting: impl Into<bool>) -> Self {
+                self.debug_reporting = Some(debug_reporting.into());
+                self
+            }
+            pub fn aggregation_coordinator_origin(
+                mut self,
+                aggregation_coordinator_origin: impl Into<String>,
+            ) -> Self {
+                self.aggregation_coordinator_origin = Some(aggregation_coordinator_origin.into());
+                self
+            }
+            pub fn source_registration_time_config(
+                mut self,
+                source_registration_time_config: impl Into<
+                    AttributionReportingSourceRegistrationTimeConfig,
+                >,
+            ) -> Self {
+                self.source_registration_time_config = Some(source_registration_time_config.into());
+                self
+            }
+            pub fn trigger_context_id(mut self, trigger_context_id: impl Into<String>) -> Self {
+                self.trigger_context_id = Some(trigger_context_id.into());
+                self
+            }
+            pub fn aggregatable_debug_reporting_config(
+                mut self,
+                aggregatable_debug_reporting_config: impl Into<
+                    AttributionReportingAggregatableDebugReportingConfig,
+                >,
+            ) -> Self {
+                self.aggregatable_debug_reporting_config =
+                    Some(aggregatable_debug_reporting_config.into());
+                self
+            }
+            pub fn scope(mut self, scope: impl Into<String>) -> Self {
+                let v = self.scopes.get_or_insert(Vec::new());
+                v.push(scope.into());
+                self
+            }
+            pub fn scopes<I, S>(mut self, scopes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.scopes.get_or_insert(Vec::new());
+                for val in scopes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn named_budget(
+                mut self,
+                named_budget: impl Into<AttributionReportingNamedBudgetCandidate>,
+            ) -> Self {
+                let v = self.named_budgets.get_or_insert(Vec::new());
+                v.push(named_budget.into());
+                self
+            }
+            pub fn named_budgets<I, S>(mut self, named_budgets: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<AttributionReportingNamedBudgetCandidate>,
+            {
+                let v = self.named_budgets.get_or_insert(Vec::new());
+                for val in named_budgets {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<AttributionReportingTriggerRegistration, String> {
+                Ok(AttributionReportingTriggerRegistration {
+                    filters: self.filters.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(filters))
+                    })?,
+                    debug_key: self.debug_key,
+                    aggregatable_dedup_keys: self.aggregatable_dedup_keys.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(aggregatable_dedup_keys)
+                        )
+                    })?,
+                    event_trigger_data: self.event_trigger_data.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(event_trigger_data)
+                        )
+                    })?,
+                    aggregatable_trigger_data: self.aggregatable_trigger_data.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(aggregatable_trigger_data)
+                        )
+                    })?,
+                    aggregatable_values: self.aggregatable_values.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(aggregatable_values)
+                        )
+                    })?,
+                    aggregatable_filtering_id_max_bytes: self
+                        .aggregatable_filtering_id_max_bytes
+                        .ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(aggregatable_filtering_id_max_bytes)
+                        )
+                    })?,
+                    debug_reporting: self.debug_reporting.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(debug_reporting))
+                    })?,
+                    aggregation_coordinator_origin: self.aggregation_coordinator_origin,
+                    source_registration_time_config: self
+                        .source_registration_time_config
+                        .ok_or_else(|| {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(source_registration_time_config)
+                            )
+                        })?,
+                    trigger_context_id: self.trigger_context_id,
+                    aggregatable_debug_reporting_config: self
+                        .aggregatable_debug_reporting_config
+                        .ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(aggregatable_debug_reporting_config)
+                        )
+                    })?,
+                    scopes: self.scopes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(scopes))
+                    })?,
+                    named_budgets: self.named_budgets.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(named_budgets))
+                    })?,
+                })
+            }
+        }
+        impl AttributionReportingTriggerRegistration {
+            pub const IDENTIFIER: &'static str = "Storage.AttributionReportingTriggerRegistration";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AttributionReportingEventLevelResult {
+            #[serde(rename = "success")]
+            Success,
+            #[serde(rename = "successDroppedLowerPriority")]
+            SuccessDroppedLowerPriority,
+            #[serde(rename = "internalError")]
+            InternalError,
+            #[serde(rename = "noCapacityForAttributionDestination")]
+            NoCapacityForAttributionDestination,
+            #[serde(rename = "noMatchingSources")]
+            NoMatchingSources,
+            #[serde(rename = "deduplicated")]
+            Deduplicated,
+            #[serde(rename = "excessiveAttributions")]
+            ExcessiveAttributions,
+            #[serde(rename = "priorityTooLow")]
+            PriorityTooLow,
+            #[serde(rename = "neverAttributedSource")]
+            NeverAttributedSource,
+            #[serde(rename = "excessiveReportingOrigins")]
+            ExcessiveReportingOrigins,
+            #[serde(rename = "noMatchingSourceFilterData")]
+            NoMatchingSourceFilterData,
+            #[serde(rename = "prohibitedByBrowserPolicy")]
+            ProhibitedByBrowserPolicy,
+            #[serde(rename = "noMatchingConfigurations")]
+            NoMatchingConfigurations,
+            #[serde(rename = "excessiveReports")]
+            ExcessiveReports,
+            #[serde(rename = "falselyAttributedSource")]
+            FalselyAttributedSource,
+            #[serde(rename = "reportWindowPassed")]
+            ReportWindowPassed,
+            #[serde(rename = "notRegistered")]
+            NotRegistered,
+            #[serde(rename = "reportWindowNotStarted")]
+            ReportWindowNotStarted,
+            #[serde(rename = "noMatchingTriggerData")]
+            NoMatchingTriggerData,
+        }
+        impl AsRef<str> for AttributionReportingEventLevelResult {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AttributionReportingEventLevelResult::Success => "success",
+                    AttributionReportingEventLevelResult::SuccessDroppedLowerPriority => {
+                        "successDroppedLowerPriority"
+                    }
+                    AttributionReportingEventLevelResult::InternalError => "internalError",
+                    AttributionReportingEventLevelResult::NoCapacityForAttributionDestination => {
+                        "noCapacityForAttributionDestination"
+                    }
+                    AttributionReportingEventLevelResult::NoMatchingSources => "noMatchingSources",
+                    AttributionReportingEventLevelResult::Deduplicated => "deduplicated",
+                    AttributionReportingEventLevelResult::ExcessiveAttributions => {
+                        "excessiveAttributions"
+                    }
+                    AttributionReportingEventLevelResult::PriorityTooLow => "priorityTooLow",
+                    AttributionReportingEventLevelResult::NeverAttributedSource => {
+                        "neverAttributedSource"
+                    }
+                    AttributionReportingEventLevelResult::ExcessiveReportingOrigins => {
+                        "excessiveReportingOrigins"
+                    }
+                    AttributionReportingEventLevelResult::NoMatchingSourceFilterData => {
+                        "noMatchingSourceFilterData"
+                    }
+                    AttributionReportingEventLevelResult::ProhibitedByBrowserPolicy => {
+                        "prohibitedByBrowserPolicy"
+                    }
+                    AttributionReportingEventLevelResult::NoMatchingConfigurations => {
+                        "noMatchingConfigurations"
+                    }
+                    AttributionReportingEventLevelResult::ExcessiveReports => "excessiveReports",
+                    AttributionReportingEventLevelResult::FalselyAttributedSource => {
+                        "falselyAttributedSource"
+                    }
+                    AttributionReportingEventLevelResult::ReportWindowPassed => {
+                        "reportWindowPassed"
+                    }
+                    AttributionReportingEventLevelResult::NotRegistered => "notRegistered",
+                    AttributionReportingEventLevelResult::ReportWindowNotStarted => {
+                        "reportWindowNotStarted"
+                    }
+                    AttributionReportingEventLevelResult::NoMatchingTriggerData => {
+                        "noMatchingTriggerData"
+                    }
+                }
+            }
+        }
+        impl ::std::str::FromStr for AttributionReportingEventLevelResult {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "success" | "Success" => Ok(AttributionReportingEventLevelResult::Success),
+                    "successDroppedLowerPriority"
+                    | "SuccessDroppedLowerPriority"
+                    | "successdroppedlowerpriority" => {
+                        Ok(AttributionReportingEventLevelResult::SuccessDroppedLowerPriority)
+                    }
+                    "internalError" | "InternalError" | "internalerror" => {
+                        Ok(AttributionReportingEventLevelResult::InternalError)
+                    }
+                    "noCapacityForAttributionDestination"
+                    | "NoCapacityForAttributionDestination"
+                    | "nocapacityforattributiondestination" => Ok(
+                        AttributionReportingEventLevelResult::NoCapacityForAttributionDestination,
+                    ),
+                    "noMatchingSources" | "NoMatchingSources" | "nomatchingsources" => {
+                        Ok(AttributionReportingEventLevelResult::NoMatchingSources)
+                    }
+                    "deduplicated" | "Deduplicated" => {
+                        Ok(AttributionReportingEventLevelResult::Deduplicated)
+                    }
+                    "excessiveAttributions" | "ExcessiveAttributions" | "excessiveattributions" => {
+                        Ok(AttributionReportingEventLevelResult::ExcessiveAttributions)
+                    }
+                    "priorityTooLow" | "PriorityTooLow" | "prioritytoolow" => {
+                        Ok(AttributionReportingEventLevelResult::PriorityTooLow)
+                    }
+                    "neverAttributedSource" | "NeverAttributedSource" | "neverattributedsource" => {
+                        Ok(AttributionReportingEventLevelResult::NeverAttributedSource)
+                    }
+                    "excessiveReportingOrigins"
+                    | "ExcessiveReportingOrigins"
+                    | "excessivereportingorigins" => {
+                        Ok(AttributionReportingEventLevelResult::ExcessiveReportingOrigins)
+                    }
+                    "noMatchingSourceFilterData"
+                    | "NoMatchingSourceFilterData"
+                    | "nomatchingsourcefilterdata" => {
+                        Ok(AttributionReportingEventLevelResult::NoMatchingSourceFilterData)
+                    }
+                    "prohibitedByBrowserPolicy"
+                    | "ProhibitedByBrowserPolicy"
+                    | "prohibitedbybrowserpolicy" => {
+                        Ok(AttributionReportingEventLevelResult::ProhibitedByBrowserPolicy)
+                    }
+                    "noMatchingConfigurations"
+                    | "NoMatchingConfigurations"
+                    | "nomatchingconfigurations" => {
+                        Ok(AttributionReportingEventLevelResult::NoMatchingConfigurations)
+                    }
+                    "excessiveReports" | "ExcessiveReports" | "excessivereports" => {
+                        Ok(AttributionReportingEventLevelResult::ExcessiveReports)
+                    }
+                    "falselyAttributedSource"
+                    | "FalselyAttributedSource"
+                    | "falselyattributedsource" => {
+                        Ok(AttributionReportingEventLevelResult::FalselyAttributedSource)
+                    }
+                    "reportWindowPassed" | "ReportWindowPassed" | "reportwindowpassed" => {
+                        Ok(AttributionReportingEventLevelResult::ReportWindowPassed)
+                    }
+                    "notRegistered" | "NotRegistered" | "notregistered" => {
+                        Ok(AttributionReportingEventLevelResult::NotRegistered)
+                    }
+                    "reportWindowNotStarted"
+                    | "ReportWindowNotStarted"
+                    | "reportwindownotstarted" => {
+                        Ok(AttributionReportingEventLevelResult::ReportWindowNotStarted)
+                    }
+                    "noMatchingTriggerData" | "NoMatchingTriggerData" | "nomatchingtriggerdata" => {
+                        Ok(AttributionReportingEventLevelResult::NoMatchingTriggerData)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AttributionReportingAggregatableResult {
+            #[serde(rename = "success")]
+            Success,
+            #[serde(rename = "internalError")]
+            InternalError,
+            #[serde(rename = "noCapacityForAttributionDestination")]
+            NoCapacityForAttributionDestination,
+            #[serde(rename = "noMatchingSources")]
+            NoMatchingSources,
+            #[serde(rename = "excessiveAttributions")]
+            ExcessiveAttributions,
+            #[serde(rename = "excessiveReportingOrigins")]
+            ExcessiveReportingOrigins,
+            #[serde(rename = "noHistograms")]
+            NoHistograms,
+            #[serde(rename = "insufficientBudget")]
+            InsufficientBudget,
+            #[serde(rename = "insufficientNamedBudget")]
+            InsufficientNamedBudget,
+            #[serde(rename = "noMatchingSourceFilterData")]
+            NoMatchingSourceFilterData,
+            #[serde(rename = "notRegistered")]
+            NotRegistered,
+            #[serde(rename = "prohibitedByBrowserPolicy")]
+            ProhibitedByBrowserPolicy,
+            #[serde(rename = "deduplicated")]
+            Deduplicated,
+            #[serde(rename = "reportWindowPassed")]
+            ReportWindowPassed,
+            #[serde(rename = "excessiveReports")]
+            ExcessiveReports,
+        }
+        impl AsRef<str> for AttributionReportingAggregatableResult {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AttributionReportingAggregatableResult::Success => "success",
+                    AttributionReportingAggregatableResult::InternalError => "internalError",
+                    AttributionReportingAggregatableResult::NoCapacityForAttributionDestination => {
+                        "noCapacityForAttributionDestination"
+                    }
+                    AttributionReportingAggregatableResult::NoMatchingSources => {
+                        "noMatchingSources"
+                    }
+                    AttributionReportingAggregatableResult::ExcessiveAttributions => {
+                        "excessiveAttributions"
+                    }
+                    AttributionReportingAggregatableResult::ExcessiveReportingOrigins => {
+                        "excessiveReportingOrigins"
+                    }
+                    AttributionReportingAggregatableResult::NoHistograms => "noHistograms",
+                    AttributionReportingAggregatableResult::InsufficientBudget => {
+                        "insufficientBudget"
+                    }
+                    AttributionReportingAggregatableResult::InsufficientNamedBudget => {
+                        "insufficientNamedBudget"
+                    }
+                    AttributionReportingAggregatableResult::NoMatchingSourceFilterData => {
+                        "noMatchingSourceFilterData"
+                    }
+                    AttributionReportingAggregatableResult::NotRegistered => "notRegistered",
+                    AttributionReportingAggregatableResult::ProhibitedByBrowserPolicy => {
+                        "prohibitedByBrowserPolicy"
+                    }
+                    AttributionReportingAggregatableResult::Deduplicated => "deduplicated",
+                    AttributionReportingAggregatableResult::ReportWindowPassed => {
+                        "reportWindowPassed"
+                    }
+                    AttributionReportingAggregatableResult::ExcessiveReports => "excessiveReports",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AttributionReportingAggregatableResult {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "success" | "Success" => Ok(AttributionReportingAggregatableResult::Success),
+                    "internalError" | "InternalError" | "internalerror" => {
+                        Ok(AttributionReportingAggregatableResult::InternalError)
+                    }
+                    "noCapacityForAttributionDestination"
+                    | "NoCapacityForAttributionDestination"
+                    | "nocapacityforattributiondestination" => Ok(
+                        AttributionReportingAggregatableResult::NoCapacityForAttributionDestination,
+                    ),
+                    "noMatchingSources" | "NoMatchingSources" | "nomatchingsources" => {
+                        Ok(AttributionReportingAggregatableResult::NoMatchingSources)
+                    }
+                    "excessiveAttributions" | "ExcessiveAttributions" | "excessiveattributions" => {
+                        Ok(AttributionReportingAggregatableResult::ExcessiveAttributions)
+                    }
+                    "excessiveReportingOrigins"
+                    | "ExcessiveReportingOrigins"
+                    | "excessivereportingorigins" => {
+                        Ok(AttributionReportingAggregatableResult::ExcessiveReportingOrigins)
+                    }
+                    "noHistograms" | "NoHistograms" | "nohistograms" => {
+                        Ok(AttributionReportingAggregatableResult::NoHistograms)
+                    }
+                    "insufficientBudget" | "InsufficientBudget" | "insufficientbudget" => {
+                        Ok(AttributionReportingAggregatableResult::InsufficientBudget)
+                    }
+                    "insufficientNamedBudget"
+                    | "InsufficientNamedBudget"
+                    | "insufficientnamedbudget" => {
+                        Ok(AttributionReportingAggregatableResult::InsufficientNamedBudget)
+                    }
+                    "noMatchingSourceFilterData"
+                    | "NoMatchingSourceFilterData"
+                    | "nomatchingsourcefilterdata" => {
+                        Ok(AttributionReportingAggregatableResult::NoMatchingSourceFilterData)
+                    }
+                    "notRegistered" | "NotRegistered" | "notregistered" => {
+                        Ok(AttributionReportingAggregatableResult::NotRegistered)
+                    }
+                    "prohibitedByBrowserPolicy"
+                    | "ProhibitedByBrowserPolicy"
+                    | "prohibitedbybrowserpolicy" => {
+                        Ok(AttributionReportingAggregatableResult::ProhibitedByBrowserPolicy)
+                    }
+                    "deduplicated" | "Deduplicated" => {
+                        Ok(AttributionReportingAggregatableResult::Deduplicated)
+                    }
+                    "reportWindowPassed" | "ReportWindowPassed" | "reportwindowpassed" => {
+                        Ok(AttributionReportingAggregatableResult::ReportWindowPassed)
+                    }
+                    "excessiveReports" | "ExcessiveReports" | "excessivereports" => {
+                        Ok(AttributionReportingAggregatableResult::ExcessiveReports)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AttributionReportingReportResult {
+            #[doc = "A network request was attempted for the report."]
+            #[serde(rename = "sent")]
+            Sent,
+            #[doc = "No request was attempted because of browser policy."]
+            #[serde(rename = "prohibited")]
+            Prohibited,
+            #[doc = "No request was attempted because of an error in report assembly,\ne.g. the aggregation service was unavailable."]
+            #[serde(rename = "failedToAssemble")]
+            FailedToAssemble,
+            #[doc = "No request was attempted because the report's expiry passed."]
+            #[serde(rename = "expired")]
+            Expired,
+        }
+        impl AsRef<str> for AttributionReportingReportResult {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AttributionReportingReportResult::Sent => "sent",
+                    AttributionReportingReportResult::Prohibited => "prohibited",
+                    AttributionReportingReportResult::FailedToAssemble => "failedToAssemble",
+                    AttributionReportingReportResult::Expired => "expired",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AttributionReportingReportResult {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "sent" | "Sent" => Ok(AttributionReportingReportResult::Sent),
+                    "prohibited" | "Prohibited" => Ok(AttributionReportingReportResult::Prohibited),
+                    "failedToAssemble" | "FailedToAssemble" | "failedtoassemble" => {
+                        Ok(AttributionReportingReportResult::FailedToAssemble)
+                    }
+                    "expired" | "Expired" => Ok(AttributionReportingReportResult::Expired),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "A single Related Website Set object.\n[RelatedWebsiteSet](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#type-RelatedWebsiteSet)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RelatedWebsiteSet {
+            #[doc = "The primary site of this set, along with the ccTLDs if there is any."]
+            #[serde(rename = "primarySites")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub primary_sites: Vec<String>,
+            #[doc = "The associated sites of this set, along with the ccTLDs if there is any."]
+            #[serde(rename = "associatedSites")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub associated_sites: Vec<String>,
+            #[doc = "The service sites of this set, along with the ccTLDs if there is any."]
+            #[serde(rename = "serviceSites")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub service_sites: Vec<String>,
+        }
+        impl RelatedWebsiteSet {
+            pub fn new(
+                primary_sites: Vec<String>,
+                associated_sites: Vec<String>,
+                service_sites: Vec<String>,
+            ) -> Self {
+                Self {
+                    primary_sites,
+                    associated_sites,
+                    service_sites,
+                }
+            }
+        }
+        impl RelatedWebsiteSet {
+            pub fn builder() -> RelatedWebsiteSetBuilder {
+                RelatedWebsiteSetBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RelatedWebsiteSetBuilder {
+            primary_sites: Option<Vec<String>>,
+            associated_sites: Option<Vec<String>>,
+            service_sites: Option<Vec<String>>,
+        }
+        impl RelatedWebsiteSetBuilder {
+            pub fn primary_site(mut self, primary_site: impl Into<String>) -> Self {
+                let v = self.primary_sites.get_or_insert(Vec::new());
+                v.push(primary_site.into());
+                self
+            }
+            pub fn primary_sites<I, S>(mut self, primary_sites: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.primary_sites.get_or_insert(Vec::new());
+                for val in primary_sites {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn associated_site(mut self, associated_site: impl Into<String>) -> Self {
+                let v = self.associated_sites.get_or_insert(Vec::new());
+                v.push(associated_site.into());
+                self
+            }
+            pub fn associated_sites<I, S>(mut self, associated_sites: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.associated_sites.get_or_insert(Vec::new());
+                for val in associated_sites {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn service_site(mut self, service_site: impl Into<String>) -> Self {
+                let v = self.service_sites.get_or_insert(Vec::new());
+                v.push(service_site.into());
+                self
+            }
+            pub fn service_sites<I, S>(mut self, service_sites: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.service_sites.get_or_insert(Vec::new());
+                for val in service_sites {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<RelatedWebsiteSet, String> {
+                Ok(RelatedWebsiteSet {
+                    primary_sites: self.primary_sites.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(primary_sites))
+                    })?,
+                    associated_sites: self.associated_sites.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(associated_sites)
+                        )
+                    })?,
+                    service_sites: self.service_sites.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(service_sites))
+                    })?,
+                })
+            }
+        }
+        impl RelatedWebsiteSet {
+            pub const IDENTIFIER: &'static str = "Storage.RelatedWebsiteSet";
+        }
+        #[doc = "Returns storage key for the given frame. If no frame ID is provided,\nthe storage key of the target executing this command is returned.\n[getStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetStorageKeyParams {
+            #[serde(rename = "frameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub frame_id: Option<super::page::FrameId>,
+        }
+        impl GetStorageKeyParams {
+            pub fn builder() -> GetStorageKeyParamsBuilder {
+                GetStorageKeyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetStorageKeyParamsBuilder {
+            frame_id: Option<super::page::FrameId>,
+        }
+        impl GetStorageKeyParamsBuilder {
+            pub fn frame_id(mut self, frame_id: impl Into<super::page::FrameId>) -> Self {
+                self.frame_id = Some(frame_id.into());
+                self
+            }
+            pub fn build(self) -> GetStorageKeyParams {
+                GetStorageKeyParams {
+                    frame_id: self.frame_id,
+                }
+            }
+        }
+        impl GetStorageKeyParams {
+            pub const IDENTIFIER: &'static str = "Storage.getStorageKey";
+        }
+        impl chromiumoxide_types::Method for GetStorageKeyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetStorageKeyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns storage key for the given frame. If no frame ID is provided,\nthe storage key of the target executing this command is returned.\n[getStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetStorageKeyReturns {
+            #[serde(rename = "storageKey")]
+            pub storage_key: SerializedStorageKey,
+        }
+        impl GetStorageKeyReturns {
+            pub fn new(storage_key: impl Into<SerializedStorageKey>) -> Self {
+                Self {
+                    storage_key: storage_key.into(),
+                }
+            }
+        }
+        impl GetStorageKeyReturns {
+            pub fn builder() -> GetStorageKeyReturnsBuilder {
+                GetStorageKeyReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetStorageKeyReturnsBuilder {
+            storage_key: Option<SerializedStorageKey>,
+        }
+        impl GetStorageKeyReturnsBuilder {
+            pub fn storage_key(mut self, storage_key: impl Into<SerializedStorageKey>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn build(self) -> Result<GetStorageKeyReturns, String> {
+                Ok(GetStorageKeyReturns {
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetStorageKeyParams {
+            type Response = GetStorageKeyReturns;
+        }
+        #[doc = "Clears storage for origin.\n[clearDataForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-clearDataForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClearDataForOriginParams {
+            #[doc = "Security origin."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "Comma separated list of StorageType to clear."]
+            #[serde(rename = "storageTypes")]
+            pub storage_types: String,
+        }
+        impl ClearDataForOriginParams {
+            pub fn new(origin: impl Into<String>, storage_types: impl Into<String>) -> Self {
+                Self {
+                    origin: origin.into(),
+                    storage_types: storage_types.into(),
+                }
+            }
+        }
+        impl ClearDataForOriginParams {
+            pub fn builder() -> ClearDataForOriginParamsBuilder {
+                ClearDataForOriginParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearDataForOriginParamsBuilder {
+            origin: Option<String>,
+            storage_types: Option<String>,
+        }
+        impl ClearDataForOriginParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn storage_types(mut self, storage_types: impl Into<String>) -> Self {
+                self.storage_types = Some(storage_types.into());
+                self
+            }
+            pub fn build(self) -> Result<ClearDataForOriginParams, String> {
+                Ok(ClearDataForOriginParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    storage_types: self.storage_types.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_types))
+                    })?,
+                })
+            }
+        }
+        impl ClearDataForOriginParams {
+            pub const IDENTIFIER: &'static str = "Storage.clearDataForOrigin";
+        }
+        impl chromiumoxide_types::Method for ClearDataForOriginParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearDataForOriginParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears storage for origin.\n[clearDataForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-clearDataForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearDataForOriginReturns {}
+        impl chromiumoxide_types::Command for ClearDataForOriginParams {
+            type Response = ClearDataForOriginReturns;
+        }
+        #[doc = "Clears storage for storage key.\n[clearDataForStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-clearDataForStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClearDataForStorageKeyParams {
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+            #[doc = "Comma separated list of StorageType to clear."]
+            #[serde(rename = "storageTypes")]
+            pub storage_types: String,
+        }
+        impl ClearDataForStorageKeyParams {
+            pub fn new(storage_key: impl Into<String>, storage_types: impl Into<String>) -> Self {
+                Self {
+                    storage_key: storage_key.into(),
+                    storage_types: storage_types.into(),
+                }
+            }
+        }
+        impl ClearDataForStorageKeyParams {
+            pub fn builder() -> ClearDataForStorageKeyParamsBuilder {
+                ClearDataForStorageKeyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearDataForStorageKeyParamsBuilder {
+            storage_key: Option<String>,
+            storage_types: Option<String>,
+        }
+        impl ClearDataForStorageKeyParamsBuilder {
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn storage_types(mut self, storage_types: impl Into<String>) -> Self {
+                self.storage_types = Some(storage_types.into());
+                self
+            }
+            pub fn build(self) -> Result<ClearDataForStorageKeyParams, String> {
+                Ok(ClearDataForStorageKeyParams {
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                    storage_types: self.storage_types.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_types))
+                    })?,
+                })
+            }
+        }
+        impl ClearDataForStorageKeyParams {
+            pub const IDENTIFIER: &'static str = "Storage.clearDataForStorageKey";
+        }
+        impl chromiumoxide_types::Method for ClearDataForStorageKeyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearDataForStorageKeyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears storage for storage key.\n[clearDataForStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-clearDataForStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearDataForStorageKeyReturns {}
+        impl chromiumoxide_types::Command for ClearDataForStorageKeyParams {
+            type Response = ClearDataForStorageKeyReturns;
+        }
+        #[doc = "Returns all browser cookies.\n[getCookies](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getCookies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetCookiesParams {
+            #[doc = "Browser context to use when called on the browser endpoint."]
+            #[serde(rename = "browserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub browser_context_id: Option<super::browser::BrowserContextId>,
+        }
+        impl GetCookiesParams {
+            pub fn builder() -> GetCookiesParamsBuilder {
+                GetCookiesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCookiesParamsBuilder {
+            browser_context_id: Option<super::browser::BrowserContextId>,
+        }
+        impl GetCookiesParamsBuilder {
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<super::browser::BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn build(self) -> GetCookiesParams {
+                GetCookiesParams {
+                    browser_context_id: self.browser_context_id,
+                }
+            }
+        }
+        impl GetCookiesParams {
+            pub const IDENTIFIER: &'static str = "Storage.getCookies";
+        }
+        impl chromiumoxide_types::Method for GetCookiesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetCookiesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns all browser cookies.\n[getCookies](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getCookies)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCookiesReturns {
+            #[doc = "Array of cookie objects."]
+            #[serde(rename = "cookies")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub cookies: Vec<super::network::Cookie>,
+        }
+        impl GetCookiesReturns {
+            pub fn new(cookies: Vec<super::network::Cookie>) -> Self {
+                Self { cookies }
+            }
+        }
+        impl GetCookiesReturns {
+            pub fn builder() -> GetCookiesReturnsBuilder {
+                GetCookiesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCookiesReturnsBuilder {
+            cookies: Option<Vec<super::network::Cookie>>,
+        }
+        impl GetCookiesReturnsBuilder {
+            pub fn cookie(mut self, cookie: impl Into<super::network::Cookie>) -> Self {
+                let v = self.cookies.get_or_insert(Vec::new());
+                v.push(cookie.into());
+                self
+            }
+            pub fn cookies<I, S>(mut self, cookies: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::network::Cookie>,
+            {
+                let v = self.cookies.get_or_insert(Vec::new());
+                for val in cookies {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetCookiesReturns, String> {
+                Ok(GetCookiesReturns {
+                    cookies: self.cookies.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cookies))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetCookiesParams {
+            type Response = GetCookiesReturns;
+        }
+        #[doc = "Sets given cookies.\n[setCookies](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setCookies)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetCookiesParams {
+            #[doc = "Cookies to be set."]
+            #[serde(rename = "cookies")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub cookies: Vec<super::network::CookieParam>,
+            #[doc = "Browser context to use when called on the browser endpoint."]
+            #[serde(rename = "browserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub browser_context_id: Option<super::browser::BrowserContextId>,
+        }
+        impl SetCookiesParams {
+            pub fn new(cookies: Vec<super::network::CookieParam>) -> Self {
+                Self {
+                    cookies,
+                    browser_context_id: None,
+                }
+            }
+        }
+        impl SetCookiesParams {
+            pub fn builder() -> SetCookiesParamsBuilder {
+                SetCookiesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetCookiesParamsBuilder {
+            cookies: Option<Vec<super::network::CookieParam>>,
+            browser_context_id: Option<super::browser::BrowserContextId>,
+        }
+        impl SetCookiesParamsBuilder {
+            pub fn cookie(mut self, cookie: impl Into<super::network::CookieParam>) -> Self {
+                let v = self.cookies.get_or_insert(Vec::new());
+                v.push(cookie.into());
+                self
+            }
+            pub fn cookies<I, S>(mut self, cookies: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::network::CookieParam>,
+            {
+                let v = self.cookies.get_or_insert(Vec::new());
+                for val in cookies {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<super::browser::BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<SetCookiesParams, String> {
+                Ok(SetCookiesParams {
+                    cookies: self.cookies.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cookies))
+                    })?,
+                    browser_context_id: self.browser_context_id,
+                })
+            }
+        }
+        impl SetCookiesParams {
+            pub const IDENTIFIER: &'static str = "Storage.setCookies";
+        }
+        impl chromiumoxide_types::Method for SetCookiesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetCookiesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets given cookies.\n[setCookies](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setCookies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetCookiesReturns {}
+        impl chromiumoxide_types::Command for SetCookiesParams {
+            type Response = SetCookiesReturns;
+        }
+        #[doc = "Clears cookies.\n[clearCookies](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-clearCookies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearCookiesParams {
+            #[doc = "Browser context to use when called on the browser endpoint."]
+            #[serde(rename = "browserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub browser_context_id: Option<super::browser::BrowserContextId>,
+        }
+        impl ClearCookiesParams {
+            pub fn builder() -> ClearCookiesParamsBuilder {
+                ClearCookiesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearCookiesParamsBuilder {
+            browser_context_id: Option<super::browser::BrowserContextId>,
+        }
+        impl ClearCookiesParamsBuilder {
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<super::browser::BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn build(self) -> ClearCookiesParams {
+                ClearCookiesParams {
+                    browser_context_id: self.browser_context_id,
+                }
+            }
+        }
+        impl ClearCookiesParams {
+            pub const IDENTIFIER: &'static str = "Storage.clearCookies";
+        }
+        impl chromiumoxide_types::Method for ClearCookiesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearCookiesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears cookies.\n[clearCookies](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-clearCookies)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearCookiesReturns {}
+        impl chromiumoxide_types::Command for ClearCookiesParams {
+            type Response = ClearCookiesReturns;
+        }
+        #[doc = "Returns usage and quota in bytes.\n[getUsageAndQuota](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getUsageAndQuota)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetUsageAndQuotaParams {
+            #[doc = "Security origin."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+        }
+        impl GetUsageAndQuotaParams {
+            pub fn new(origin: impl Into<String>) -> Self {
+                Self {
+                    origin: origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetUsageAndQuotaParams {
+            fn from(url: T) -> Self {
+                GetUsageAndQuotaParams::new(url)
+            }
+        }
+        impl GetUsageAndQuotaParams {
+            pub fn builder() -> GetUsageAndQuotaParamsBuilder {
+                GetUsageAndQuotaParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetUsageAndQuotaParamsBuilder {
+            origin: Option<String>,
+        }
+        impl GetUsageAndQuotaParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn build(self) -> Result<GetUsageAndQuotaParams, String> {
+                Ok(GetUsageAndQuotaParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                })
+            }
+        }
+        impl GetUsageAndQuotaParams {
+            pub const IDENTIFIER: &'static str = "Storage.getUsageAndQuota";
+        }
+        impl chromiumoxide_types::Method for GetUsageAndQuotaParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetUsageAndQuotaParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns usage and quota in bytes.\n[getUsageAndQuota](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getUsageAndQuota)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetUsageAndQuotaReturns {
+            #[doc = "Storage usage (bytes)."]
+            #[serde(rename = "usage")]
+            pub usage: f64,
+            #[doc = "Storage quota (bytes)."]
+            #[serde(rename = "quota")]
+            pub quota: f64,
+            #[doc = "Whether or not the origin has an active storage quota override"]
+            #[serde(rename = "overrideActive")]
+            pub override_active: bool,
+            #[doc = "Storage usage per type (bytes)."]
+            #[serde(rename = "usageBreakdown")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub usage_breakdown: Vec<UsageForType>,
+        }
+        impl GetUsageAndQuotaReturns {
+            pub fn new(
+                usage: impl Into<f64>,
+                quota: impl Into<f64>,
+                override_active: impl Into<bool>,
+                usage_breakdown: Vec<UsageForType>,
+            ) -> Self {
+                Self {
+                    usage: usage.into(),
+                    quota: quota.into(),
+                    override_active: override_active.into(),
+                    usage_breakdown,
+                }
+            }
+        }
+        impl GetUsageAndQuotaReturns {
+            pub fn builder() -> GetUsageAndQuotaReturnsBuilder {
+                GetUsageAndQuotaReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetUsageAndQuotaReturnsBuilder {
+            usage: Option<f64>,
+            quota: Option<f64>,
+            override_active: Option<bool>,
+            usage_breakdown: Option<Vec<UsageForType>>,
+        }
+        impl GetUsageAndQuotaReturnsBuilder {
+            pub fn usage(mut self, usage: impl Into<f64>) -> Self {
+                self.usage = Some(usage.into());
+                self
+            }
+            pub fn quota(mut self, quota: impl Into<f64>) -> Self {
+                self.quota = Some(quota.into());
+                self
+            }
+            pub fn override_active(mut self, override_active: impl Into<bool>) -> Self {
+                self.override_active = Some(override_active.into());
+                self
+            }
+            pub fn usage_breakdown(mut self, usage_breakdown: impl Into<UsageForType>) -> Self {
+                let v = self.usage_breakdown.get_or_insert(Vec::new());
+                v.push(usage_breakdown.into());
+                self
+            }
+            pub fn usage_breakdowns<I, S>(mut self, usage_breakdowns: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<UsageForType>,
+            {
+                let v = self.usage_breakdown.get_or_insert(Vec::new());
+                for val in usage_breakdowns {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetUsageAndQuotaReturns, String> {
+                Ok(GetUsageAndQuotaReturns {
+                    usage: self.usage.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(usage))
+                    })?,
+                    quota: self.quota.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(quota))
+                    })?,
+                    override_active: self.override_active.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(override_active))
+                    })?,
+                    usage_breakdown: self.usage_breakdown.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(usage_breakdown))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetUsageAndQuotaParams {
+            type Response = GetUsageAndQuotaReturns;
+        }
+        #[doc = "Override quota for the specified origin\n[overrideQuotaForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-overrideQuotaForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct OverrideQuotaForOriginParams {
+            #[doc = "Security origin."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "The quota size (in bytes) to override the original quota with.\nIf this is called multiple times, the overridden quota will be equal to\nthe quotaSize provided in the final call. If this is called without\nspecifying a quotaSize, the quota will be reset to the default value for\nthe specified origin. If this is called multiple times with different\norigins, the override will be maintained for each origin until it is\ndisabled (called without a quotaSize)."]
+            #[serde(rename = "quotaSize")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub quota_size: Option<f64>,
+        }
+        impl OverrideQuotaForOriginParams {
+            pub fn new(origin: impl Into<String>) -> Self {
+                Self {
+                    origin: origin.into(),
+                    quota_size: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for OverrideQuotaForOriginParams {
+            fn from(url: T) -> Self {
+                OverrideQuotaForOriginParams::new(url)
+            }
+        }
+        impl OverrideQuotaForOriginParams {
+            pub fn builder() -> OverrideQuotaForOriginParamsBuilder {
+                OverrideQuotaForOriginParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct OverrideQuotaForOriginParamsBuilder {
+            origin: Option<String>,
+            quota_size: Option<f64>,
+        }
+        impl OverrideQuotaForOriginParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn quota_size(mut self, quota_size: impl Into<f64>) -> Self {
+                self.quota_size = Some(quota_size.into());
+                self
+            }
+            pub fn build(self) -> Result<OverrideQuotaForOriginParams, String> {
+                Ok(OverrideQuotaForOriginParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                    quota_size: self.quota_size,
+                })
+            }
+        }
+        impl OverrideQuotaForOriginParams {
+            pub const IDENTIFIER: &'static str = "Storage.overrideQuotaForOrigin";
+        }
+        impl chromiumoxide_types::Method for OverrideQuotaForOriginParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for OverrideQuotaForOriginParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Override quota for the specified origin\n[overrideQuotaForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-overrideQuotaForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct OverrideQuotaForOriginReturns {}
+        impl chromiumoxide_types::Command for OverrideQuotaForOriginParams {
+            type Response = OverrideQuotaForOriginReturns;
+        }
+        #[doc = "Registers origin to be notified when an update occurs to its cache storage list.\n[trackCacheStorageForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-trackCacheStorageForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TrackCacheStorageForOriginParams {
+            #[doc = "Security origin."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+        }
+        impl TrackCacheStorageForOriginParams {
+            pub fn new(origin: impl Into<String>) -> Self {
+                Self {
+                    origin: origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for TrackCacheStorageForOriginParams {
+            fn from(url: T) -> Self {
+                TrackCacheStorageForOriginParams::new(url)
+            }
+        }
+        impl TrackCacheStorageForOriginParams {
+            pub fn builder() -> TrackCacheStorageForOriginParamsBuilder {
+                TrackCacheStorageForOriginParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TrackCacheStorageForOriginParamsBuilder {
+            origin: Option<String>,
+        }
+        impl TrackCacheStorageForOriginParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn build(self) -> Result<TrackCacheStorageForOriginParams, String> {
+                Ok(TrackCacheStorageForOriginParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                })
+            }
+        }
+        impl TrackCacheStorageForOriginParams {
+            pub const IDENTIFIER: &'static str = "Storage.trackCacheStorageForOrigin";
+        }
+        impl chromiumoxide_types::Method for TrackCacheStorageForOriginParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TrackCacheStorageForOriginParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Registers origin to be notified when an update occurs to its cache storage list.\n[trackCacheStorageForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-trackCacheStorageForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TrackCacheStorageForOriginReturns {}
+        impl chromiumoxide_types::Command for TrackCacheStorageForOriginParams {
+            type Response = TrackCacheStorageForOriginReturns;
+        }
+        #[doc = "Registers storage key to be notified when an update occurs to its cache storage list.\n[trackCacheStorageForStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-trackCacheStorageForStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TrackCacheStorageForStorageKeyParams {
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+        }
+        impl TrackCacheStorageForStorageKeyParams {
+            pub fn new(storage_key: impl Into<String>) -> Self {
+                Self {
+                    storage_key: storage_key.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for TrackCacheStorageForStorageKeyParams {
+            fn from(url: T) -> Self {
+                TrackCacheStorageForStorageKeyParams::new(url)
+            }
+        }
+        impl TrackCacheStorageForStorageKeyParams {
+            pub fn builder() -> TrackCacheStorageForStorageKeyParamsBuilder {
+                TrackCacheStorageForStorageKeyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TrackCacheStorageForStorageKeyParamsBuilder {
+            storage_key: Option<String>,
+        }
+        impl TrackCacheStorageForStorageKeyParamsBuilder {
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn build(self) -> Result<TrackCacheStorageForStorageKeyParams, String> {
+                Ok(TrackCacheStorageForStorageKeyParams {
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                })
+            }
+        }
+        impl TrackCacheStorageForStorageKeyParams {
+            pub const IDENTIFIER: &'static str = "Storage.trackCacheStorageForStorageKey";
+        }
+        impl chromiumoxide_types::Method for TrackCacheStorageForStorageKeyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TrackCacheStorageForStorageKeyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Registers storage key to be notified when an update occurs to its cache storage list.\n[trackCacheStorageForStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-trackCacheStorageForStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TrackCacheStorageForStorageKeyReturns {}
+        impl chromiumoxide_types::Command for TrackCacheStorageForStorageKeyParams {
+            type Response = TrackCacheStorageForStorageKeyReturns;
+        }
+        #[doc = "Registers origin to be notified when an update occurs to its IndexedDB.\n[trackIndexedDBForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-trackIndexedDBForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TrackIndexedDbForOriginParams {
+            #[doc = "Security origin."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+        }
+        impl TrackIndexedDbForOriginParams {
+            pub fn new(origin: impl Into<String>) -> Self {
+                Self {
+                    origin: origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for TrackIndexedDbForOriginParams {
+            fn from(url: T) -> Self {
+                TrackIndexedDbForOriginParams::new(url)
+            }
+        }
+        impl TrackIndexedDbForOriginParams {
+            pub fn builder() -> TrackIndexedDbForOriginParamsBuilder {
+                TrackIndexedDbForOriginParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TrackIndexedDbForOriginParamsBuilder {
+            origin: Option<String>,
+        }
+        impl TrackIndexedDbForOriginParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn build(self) -> Result<TrackIndexedDbForOriginParams, String> {
+                Ok(TrackIndexedDbForOriginParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                })
+            }
+        }
+        impl TrackIndexedDbForOriginParams {
+            pub const IDENTIFIER: &'static str = "Storage.trackIndexedDBForOrigin";
+        }
+        impl chromiumoxide_types::Method for TrackIndexedDbForOriginParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TrackIndexedDbForOriginParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Registers origin to be notified when an update occurs to its IndexedDB.\n[trackIndexedDBForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-trackIndexedDBForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TrackIndexedDbForOriginReturns {}
+        impl chromiumoxide_types::Command for TrackIndexedDbForOriginParams {
+            type Response = TrackIndexedDbForOriginReturns;
+        }
+        #[doc = "Registers storage key to be notified when an update occurs to its IndexedDB.\n[trackIndexedDBForStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-trackIndexedDBForStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TrackIndexedDbForStorageKeyParams {
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+        }
+        impl TrackIndexedDbForStorageKeyParams {
+            pub fn new(storage_key: impl Into<String>) -> Self {
+                Self {
+                    storage_key: storage_key.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for TrackIndexedDbForStorageKeyParams {
+            fn from(url: T) -> Self {
+                TrackIndexedDbForStorageKeyParams::new(url)
+            }
+        }
+        impl TrackIndexedDbForStorageKeyParams {
+            pub fn builder() -> TrackIndexedDbForStorageKeyParamsBuilder {
+                TrackIndexedDbForStorageKeyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TrackIndexedDbForStorageKeyParamsBuilder {
+            storage_key: Option<String>,
+        }
+        impl TrackIndexedDbForStorageKeyParamsBuilder {
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn build(self) -> Result<TrackIndexedDbForStorageKeyParams, String> {
+                Ok(TrackIndexedDbForStorageKeyParams {
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                })
+            }
+        }
+        impl TrackIndexedDbForStorageKeyParams {
+            pub const IDENTIFIER: &'static str = "Storage.trackIndexedDBForStorageKey";
+        }
+        impl chromiumoxide_types::Method for TrackIndexedDbForStorageKeyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for TrackIndexedDbForStorageKeyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Registers storage key to be notified when an update occurs to its IndexedDB.\n[trackIndexedDBForStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-trackIndexedDBForStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TrackIndexedDbForStorageKeyReturns {}
+        impl chromiumoxide_types::Command for TrackIndexedDbForStorageKeyParams {
+            type Response = TrackIndexedDbForStorageKeyReturns;
+        }
+        #[doc = "Unregisters origin from receiving notifications for cache storage.\n[untrackCacheStorageForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-untrackCacheStorageForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UntrackCacheStorageForOriginParams {
+            #[doc = "Security origin."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+        }
+        impl UntrackCacheStorageForOriginParams {
+            pub fn new(origin: impl Into<String>) -> Self {
+                Self {
+                    origin: origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for UntrackCacheStorageForOriginParams {
+            fn from(url: T) -> Self {
+                UntrackCacheStorageForOriginParams::new(url)
+            }
+        }
+        impl UntrackCacheStorageForOriginParams {
+            pub fn builder() -> UntrackCacheStorageForOriginParamsBuilder {
+                UntrackCacheStorageForOriginParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UntrackCacheStorageForOriginParamsBuilder {
+            origin: Option<String>,
+        }
+        impl UntrackCacheStorageForOriginParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn build(self) -> Result<UntrackCacheStorageForOriginParams, String> {
+                Ok(UntrackCacheStorageForOriginParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                })
+            }
+        }
+        impl UntrackCacheStorageForOriginParams {
+            pub const IDENTIFIER: &'static str = "Storage.untrackCacheStorageForOrigin";
+        }
+        impl chromiumoxide_types::Method for UntrackCacheStorageForOriginParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for UntrackCacheStorageForOriginParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Unregisters origin from receiving notifications for cache storage.\n[untrackCacheStorageForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-untrackCacheStorageForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UntrackCacheStorageForOriginReturns {}
+        impl chromiumoxide_types::Command for UntrackCacheStorageForOriginParams {
+            type Response = UntrackCacheStorageForOriginReturns;
+        }
+        #[doc = "Unregisters storage key from receiving notifications for cache storage.\n[untrackCacheStorageForStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-untrackCacheStorageForStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UntrackCacheStorageForStorageKeyParams {
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+        }
+        impl UntrackCacheStorageForStorageKeyParams {
+            pub fn new(storage_key: impl Into<String>) -> Self {
+                Self {
+                    storage_key: storage_key.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for UntrackCacheStorageForStorageKeyParams {
+            fn from(url: T) -> Self {
+                UntrackCacheStorageForStorageKeyParams::new(url)
+            }
+        }
+        impl UntrackCacheStorageForStorageKeyParams {
+            pub fn builder() -> UntrackCacheStorageForStorageKeyParamsBuilder {
+                UntrackCacheStorageForStorageKeyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UntrackCacheStorageForStorageKeyParamsBuilder {
+            storage_key: Option<String>,
+        }
+        impl UntrackCacheStorageForStorageKeyParamsBuilder {
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn build(self) -> Result<UntrackCacheStorageForStorageKeyParams, String> {
+                Ok(UntrackCacheStorageForStorageKeyParams {
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                })
+            }
+        }
+        impl UntrackCacheStorageForStorageKeyParams {
+            pub const IDENTIFIER: &'static str = "Storage.untrackCacheStorageForStorageKey";
+        }
+        impl chromiumoxide_types::Method for UntrackCacheStorageForStorageKeyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for UntrackCacheStorageForStorageKeyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Unregisters storage key from receiving notifications for cache storage.\n[untrackCacheStorageForStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-untrackCacheStorageForStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UntrackCacheStorageForStorageKeyReturns {}
+        impl chromiumoxide_types::Command for UntrackCacheStorageForStorageKeyParams {
+            type Response = UntrackCacheStorageForStorageKeyReturns;
+        }
+        #[doc = "Unregisters origin from receiving notifications for IndexedDB.\n[untrackIndexedDBForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-untrackIndexedDBForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UntrackIndexedDbForOriginParams {
+            #[doc = "Security origin."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+        }
+        impl UntrackIndexedDbForOriginParams {
+            pub fn new(origin: impl Into<String>) -> Self {
+                Self {
+                    origin: origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for UntrackIndexedDbForOriginParams {
+            fn from(url: T) -> Self {
+                UntrackIndexedDbForOriginParams::new(url)
+            }
+        }
+        impl UntrackIndexedDbForOriginParams {
+            pub fn builder() -> UntrackIndexedDbForOriginParamsBuilder {
+                UntrackIndexedDbForOriginParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UntrackIndexedDbForOriginParamsBuilder {
+            origin: Option<String>,
+        }
+        impl UntrackIndexedDbForOriginParamsBuilder {
+            pub fn origin(mut self, origin: impl Into<String>) -> Self {
+                self.origin = Some(origin.into());
+                self
+            }
+            pub fn build(self) -> Result<UntrackIndexedDbForOriginParams, String> {
+                Ok(UntrackIndexedDbForOriginParams {
+                    origin: self.origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(origin))
+                    })?,
+                })
+            }
+        }
+        impl UntrackIndexedDbForOriginParams {
+            pub const IDENTIFIER: &'static str = "Storage.untrackIndexedDBForOrigin";
+        }
+        impl chromiumoxide_types::Method for UntrackIndexedDbForOriginParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for UntrackIndexedDbForOriginParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Unregisters origin from receiving notifications for IndexedDB.\n[untrackIndexedDBForOrigin](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-untrackIndexedDBForOrigin)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UntrackIndexedDbForOriginReturns {}
+        impl chromiumoxide_types::Command for UntrackIndexedDbForOriginParams {
+            type Response = UntrackIndexedDbForOriginReturns;
+        }
+        #[doc = "Unregisters storage key from receiving notifications for IndexedDB.\n[untrackIndexedDBForStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-untrackIndexedDBForStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UntrackIndexedDbForStorageKeyParams {
+            #[doc = "Storage key."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+        }
+        impl UntrackIndexedDbForStorageKeyParams {
+            pub fn new(storage_key: impl Into<String>) -> Self {
+                Self {
+                    storage_key: storage_key.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for UntrackIndexedDbForStorageKeyParams {
+            fn from(url: T) -> Self {
+                UntrackIndexedDbForStorageKeyParams::new(url)
+            }
+        }
+        impl UntrackIndexedDbForStorageKeyParams {
+            pub fn builder() -> UntrackIndexedDbForStorageKeyParamsBuilder {
+                UntrackIndexedDbForStorageKeyParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UntrackIndexedDbForStorageKeyParamsBuilder {
+            storage_key: Option<String>,
+        }
+        impl UntrackIndexedDbForStorageKeyParamsBuilder {
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn build(self) -> Result<UntrackIndexedDbForStorageKeyParams, String> {
+                Ok(UntrackIndexedDbForStorageKeyParams {
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                })
+            }
+        }
+        impl UntrackIndexedDbForStorageKeyParams {
+            pub const IDENTIFIER: &'static str = "Storage.untrackIndexedDBForStorageKey";
+        }
+        impl chromiumoxide_types::Method for UntrackIndexedDbForStorageKeyParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for UntrackIndexedDbForStorageKeyParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Unregisters storage key from receiving notifications for IndexedDB.\n[untrackIndexedDBForStorageKey](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-untrackIndexedDBForStorageKey)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UntrackIndexedDbForStorageKeyReturns {}
+        impl chromiumoxide_types::Command for UntrackIndexedDbForStorageKeyParams {
+            type Response = UntrackIndexedDbForStorageKeyReturns;
+        }
+        #[doc = "Returns the number of stored Trust Tokens per issuer for the\ncurrent browsing context.\n[getTrustTokens](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getTrustTokens)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetTrustTokensParams {}
+        impl GetTrustTokensParams {
+            pub const IDENTIFIER: &'static str = "Storage.getTrustTokens";
+        }
+        impl chromiumoxide_types::Method for GetTrustTokensParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetTrustTokensParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the number of stored Trust Tokens per issuer for the\ncurrent browsing context.\n[getTrustTokens](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getTrustTokens)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetTrustTokensReturns {
+            #[serde(rename = "tokens")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub tokens: Vec<TrustTokens>,
+        }
+        impl GetTrustTokensReturns {
+            pub fn new(tokens: Vec<TrustTokens>) -> Self {
+                Self { tokens }
+            }
+        }
+        impl GetTrustTokensReturns {
+            pub fn builder() -> GetTrustTokensReturnsBuilder {
+                GetTrustTokensReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetTrustTokensReturnsBuilder {
+            tokens: Option<Vec<TrustTokens>>,
+        }
+        impl GetTrustTokensReturnsBuilder {
+            pub fn token(mut self, token: impl Into<TrustTokens>) -> Self {
+                let v = self.tokens.get_or_insert(Vec::new());
+                v.push(token.into());
+                self
+            }
+            pub fn tokens<I, S>(mut self, tokens: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<TrustTokens>,
+            {
+                let v = self.tokens.get_or_insert(Vec::new());
+                for val in tokens {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetTrustTokensReturns, String> {
+                Ok(GetTrustTokensReturns {
+                    tokens: self.tokens.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(tokens))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetTrustTokensParams {
+            type Response = GetTrustTokensReturns;
+        }
+        #[doc = "Removes all Trust Tokens issued by the provided issuerOrigin.\nLeaves other stored data, including the issuer's Redemption Records, intact.\n[clearTrustTokens](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-clearTrustTokens)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClearTrustTokensParams {
+            #[serde(rename = "issuerOrigin")]
+            pub issuer_origin: String,
+        }
+        impl ClearTrustTokensParams {
+            pub fn new(issuer_origin: impl Into<String>) -> Self {
+                Self {
+                    issuer_origin: issuer_origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for ClearTrustTokensParams {
+            fn from(url: T) -> Self {
+                ClearTrustTokensParams::new(url)
+            }
+        }
+        impl ClearTrustTokensParams {
+            pub fn builder() -> ClearTrustTokensParamsBuilder {
+                ClearTrustTokensParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearTrustTokensParamsBuilder {
+            issuer_origin: Option<String>,
+        }
+        impl ClearTrustTokensParamsBuilder {
+            pub fn issuer_origin(mut self, issuer_origin: impl Into<String>) -> Self {
+                self.issuer_origin = Some(issuer_origin.into());
+                self
+            }
+            pub fn build(self) -> Result<ClearTrustTokensParams, String> {
+                Ok(ClearTrustTokensParams {
+                    issuer_origin: self.issuer_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(issuer_origin))
+                    })?,
+                })
+            }
+        }
+        impl ClearTrustTokensParams {
+            pub const IDENTIFIER: &'static str = "Storage.clearTrustTokens";
+        }
+        impl chromiumoxide_types::Method for ClearTrustTokensParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearTrustTokensParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes all Trust Tokens issued by the provided issuerOrigin.\nLeaves other stored data, including the issuer's Redemption Records, intact.\n[clearTrustTokens](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-clearTrustTokens)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClearTrustTokensReturns {
+            #[doc = "True if any tokens were deleted, false otherwise."]
+            #[serde(rename = "didDeleteTokens")]
+            pub did_delete_tokens: bool,
+        }
+        impl ClearTrustTokensReturns {
+            pub fn new(did_delete_tokens: impl Into<bool>) -> Self {
+                Self {
+                    did_delete_tokens: did_delete_tokens.into(),
+                }
+            }
+        }
+        impl ClearTrustTokensReturns {
+            pub fn builder() -> ClearTrustTokensReturnsBuilder {
+                ClearTrustTokensReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearTrustTokensReturnsBuilder {
+            did_delete_tokens: Option<bool>,
+        }
+        impl ClearTrustTokensReturnsBuilder {
+            pub fn did_delete_tokens(mut self, did_delete_tokens: impl Into<bool>) -> Self {
+                self.did_delete_tokens = Some(did_delete_tokens.into());
+                self
+            }
+            pub fn build(self) -> Result<ClearTrustTokensReturns, String> {
+                Ok(ClearTrustTokensReturns {
+                    did_delete_tokens: self.did_delete_tokens.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(did_delete_tokens)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for ClearTrustTokensParams {
+            type Response = ClearTrustTokensReturns;
+        }
+        #[doc = "Gets details for a named interest group.\n[getInterestGroupDetails](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getInterestGroupDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetInterestGroupDetailsParams {
+            #[serde(rename = "ownerOrigin")]
+            pub owner_origin: String,
+            #[serde(rename = "name")]
+            pub name: String,
+        }
+        impl GetInterestGroupDetailsParams {
+            pub fn new(owner_origin: impl Into<String>, name: impl Into<String>) -> Self {
+                Self {
+                    owner_origin: owner_origin.into(),
+                    name: name.into(),
+                }
+            }
+        }
+        impl GetInterestGroupDetailsParams {
+            pub fn builder() -> GetInterestGroupDetailsParamsBuilder {
+                GetInterestGroupDetailsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetInterestGroupDetailsParamsBuilder {
+            owner_origin: Option<String>,
+            name: Option<String>,
+        }
+        impl GetInterestGroupDetailsParamsBuilder {
+            pub fn owner_origin(mut self, owner_origin: impl Into<String>) -> Self {
+                self.owner_origin = Some(owner_origin.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn build(self) -> Result<GetInterestGroupDetailsParams, String> {
+                Ok(GetInterestGroupDetailsParams {
+                    owner_origin: self.owner_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(owner_origin))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                })
+            }
+        }
+        impl GetInterestGroupDetailsParams {
+            pub const IDENTIFIER: &'static str = "Storage.getInterestGroupDetails";
+        }
+        impl chromiumoxide_types::Method for GetInterestGroupDetailsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetInterestGroupDetailsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets details for a named interest group.\n[getInterestGroupDetails](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getInterestGroupDetails)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetInterestGroupDetailsReturns {
+            #[doc = "This largely corresponds to:\nhttps://wicg.github.io/turtledove/#dictdef-generatebidinterestgroup\nbut has absolute expirationTime instead of relative lifetimeMs and\nalso adds joiningOrigin."]
+            #[serde(rename = "details")]
+            pub details: serde_json::Value,
+        }
+        impl GetInterestGroupDetailsReturns {
+            pub fn new(details: impl Into<serde_json::Value>) -> Self {
+                Self {
+                    details: details.into(),
+                }
+            }
+        }
+        impl GetInterestGroupDetailsReturns {
+            pub fn builder() -> GetInterestGroupDetailsReturnsBuilder {
+                GetInterestGroupDetailsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetInterestGroupDetailsReturnsBuilder {
+            details: Option<serde_json::Value>,
+        }
+        impl GetInterestGroupDetailsReturnsBuilder {
+            pub fn details(mut self, details: impl Into<serde_json::Value>) -> Self {
+                self.details = Some(details.into());
+                self
+            }
+            pub fn build(self) -> Result<GetInterestGroupDetailsReturns, String> {
+                Ok(GetInterestGroupDetailsReturns {
+                    details: self.details.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(details))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetInterestGroupDetailsParams {
+            type Response = GetInterestGroupDetailsReturns;
+        }
+        #[doc = "Enables/Disables issuing of interestGroupAccessed events.\n[setInterestGroupTracking](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setInterestGroupTracking)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetInterestGroupTrackingParams {
+            #[serde(rename = "enable")]
+            pub enable: bool,
+        }
+        impl SetInterestGroupTrackingParams {
+            pub fn new(enable: impl Into<bool>) -> Self {
+                Self {
+                    enable: enable.into(),
+                }
+            }
+        }
+        impl SetInterestGroupTrackingParams {
+            pub fn builder() -> SetInterestGroupTrackingParamsBuilder {
+                SetInterestGroupTrackingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetInterestGroupTrackingParamsBuilder {
+            enable: Option<bool>,
+        }
+        impl SetInterestGroupTrackingParamsBuilder {
+            pub fn enable(mut self, enable: impl Into<bool>) -> Self {
+                self.enable = Some(enable.into());
+                self
+            }
+            pub fn build(self) -> Result<SetInterestGroupTrackingParams, String> {
+                Ok(SetInterestGroupTrackingParams {
+                    enable: self.enable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enable))
+                    })?,
+                })
+            }
+        }
+        impl SetInterestGroupTrackingParams {
+            pub const IDENTIFIER: &'static str = "Storage.setInterestGroupTracking";
+        }
+        impl chromiumoxide_types::Method for SetInterestGroupTrackingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetInterestGroupTrackingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables/Disables issuing of interestGroupAccessed events.\n[setInterestGroupTracking](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setInterestGroupTracking)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetInterestGroupTrackingReturns {}
+        impl chromiumoxide_types::Command for SetInterestGroupTrackingParams {
+            type Response = SetInterestGroupTrackingReturns;
+        }
+        #[doc = "Enables/Disables issuing of interestGroupAuctionEventOccurred and\ninterestGroupAuctionNetworkRequestCreated.\n[setInterestGroupAuctionTracking](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setInterestGroupAuctionTracking)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetInterestGroupAuctionTrackingParams {
+            #[serde(rename = "enable")]
+            pub enable: bool,
+        }
+        impl SetInterestGroupAuctionTrackingParams {
+            pub fn new(enable: impl Into<bool>) -> Self {
+                Self {
+                    enable: enable.into(),
+                }
+            }
+        }
+        impl SetInterestGroupAuctionTrackingParams {
+            pub fn builder() -> SetInterestGroupAuctionTrackingParamsBuilder {
+                SetInterestGroupAuctionTrackingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetInterestGroupAuctionTrackingParamsBuilder {
+            enable: Option<bool>,
+        }
+        impl SetInterestGroupAuctionTrackingParamsBuilder {
+            pub fn enable(mut self, enable: impl Into<bool>) -> Self {
+                self.enable = Some(enable.into());
+                self
+            }
+            pub fn build(self) -> Result<SetInterestGroupAuctionTrackingParams, String> {
+                Ok(SetInterestGroupAuctionTrackingParams {
+                    enable: self.enable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enable))
+                    })?,
+                })
+            }
+        }
+        impl SetInterestGroupAuctionTrackingParams {
+            pub const IDENTIFIER: &'static str = "Storage.setInterestGroupAuctionTracking";
+        }
+        impl chromiumoxide_types::Method for SetInterestGroupAuctionTrackingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetInterestGroupAuctionTrackingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables/Disables issuing of interestGroupAuctionEventOccurred and\ninterestGroupAuctionNetworkRequestCreated.\n[setInterestGroupAuctionTracking](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setInterestGroupAuctionTracking)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetInterestGroupAuctionTrackingReturns {}
+        impl chromiumoxide_types::Command for SetInterestGroupAuctionTrackingParams {
+            type Response = SetInterestGroupAuctionTrackingReturns;
+        }
+        #[doc = "Gets metadata for an origin's shared storage.\n[getSharedStorageMetadata](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getSharedStorageMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSharedStorageMetadataParams {
+            #[serde(rename = "ownerOrigin")]
+            pub owner_origin: String,
+        }
+        impl GetSharedStorageMetadataParams {
+            pub fn new(owner_origin: impl Into<String>) -> Self {
+                Self {
+                    owner_origin: owner_origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetSharedStorageMetadataParams {
+            fn from(url: T) -> Self {
+                GetSharedStorageMetadataParams::new(url)
+            }
+        }
+        impl GetSharedStorageMetadataParams {
+            pub fn builder() -> GetSharedStorageMetadataParamsBuilder {
+                GetSharedStorageMetadataParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSharedStorageMetadataParamsBuilder {
+            owner_origin: Option<String>,
+        }
+        impl GetSharedStorageMetadataParamsBuilder {
+            pub fn owner_origin(mut self, owner_origin: impl Into<String>) -> Self {
+                self.owner_origin = Some(owner_origin.into());
+                self
+            }
+            pub fn build(self) -> Result<GetSharedStorageMetadataParams, String> {
+                Ok(GetSharedStorageMetadataParams {
+                    owner_origin: self.owner_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(owner_origin))
+                    })?,
+                })
+            }
+        }
+        impl GetSharedStorageMetadataParams {
+            pub const IDENTIFIER: &'static str = "Storage.getSharedStorageMetadata";
+        }
+        impl chromiumoxide_types::Method for GetSharedStorageMetadataParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetSharedStorageMetadataParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets metadata for an origin's shared storage.\n[getSharedStorageMetadata](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getSharedStorageMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSharedStorageMetadataReturns {
+            #[serde(rename = "metadata")]
+            pub metadata: SharedStorageMetadata,
+        }
+        impl GetSharedStorageMetadataReturns {
+            pub fn new(metadata: impl Into<SharedStorageMetadata>) -> Self {
+                Self {
+                    metadata: metadata.into(),
+                }
+            }
+        }
+        impl GetSharedStorageMetadataReturns {
+            pub fn builder() -> GetSharedStorageMetadataReturnsBuilder {
+                GetSharedStorageMetadataReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSharedStorageMetadataReturnsBuilder {
+            metadata: Option<SharedStorageMetadata>,
+        }
+        impl GetSharedStorageMetadataReturnsBuilder {
+            pub fn metadata(mut self, metadata: impl Into<SharedStorageMetadata>) -> Self {
+                self.metadata = Some(metadata.into());
+                self
+            }
+            pub fn build(self) -> Result<GetSharedStorageMetadataReturns, String> {
+                Ok(GetSharedStorageMetadataReturns {
+                    metadata: self.metadata.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(metadata))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetSharedStorageMetadataParams {
+            type Response = GetSharedStorageMetadataReturns;
+        }
+        #[doc = "Gets the entries in an given origin's shared storage.\n[getSharedStorageEntries](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getSharedStorageEntries)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSharedStorageEntriesParams {
+            #[serde(rename = "ownerOrigin")]
+            pub owner_origin: String,
+        }
+        impl GetSharedStorageEntriesParams {
+            pub fn new(owner_origin: impl Into<String>) -> Self {
+                Self {
+                    owner_origin: owner_origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetSharedStorageEntriesParams {
+            fn from(url: T) -> Self {
+                GetSharedStorageEntriesParams::new(url)
+            }
+        }
+        impl GetSharedStorageEntriesParams {
+            pub fn builder() -> GetSharedStorageEntriesParamsBuilder {
+                GetSharedStorageEntriesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSharedStorageEntriesParamsBuilder {
+            owner_origin: Option<String>,
+        }
+        impl GetSharedStorageEntriesParamsBuilder {
+            pub fn owner_origin(mut self, owner_origin: impl Into<String>) -> Self {
+                self.owner_origin = Some(owner_origin.into());
+                self
+            }
+            pub fn build(self) -> Result<GetSharedStorageEntriesParams, String> {
+                Ok(GetSharedStorageEntriesParams {
+                    owner_origin: self.owner_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(owner_origin))
+                    })?,
+                })
+            }
+        }
+        impl GetSharedStorageEntriesParams {
+            pub const IDENTIFIER: &'static str = "Storage.getSharedStorageEntries";
+        }
+        impl chromiumoxide_types::Method for GetSharedStorageEntriesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetSharedStorageEntriesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets the entries in an given origin's shared storage.\n[getSharedStorageEntries](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getSharedStorageEntries)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetSharedStorageEntriesReturns {
+            #[serde(rename = "entries")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub entries: Vec<SharedStorageEntry>,
+        }
+        impl GetSharedStorageEntriesReturns {
+            pub fn new(entries: Vec<SharedStorageEntry>) -> Self {
+                Self { entries }
+            }
+        }
+        impl GetSharedStorageEntriesReturns {
+            pub fn builder() -> GetSharedStorageEntriesReturnsBuilder {
+                GetSharedStorageEntriesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetSharedStorageEntriesReturnsBuilder {
+            entries: Option<Vec<SharedStorageEntry>>,
+        }
+        impl GetSharedStorageEntriesReturnsBuilder {
+            pub fn entrie(mut self, entrie: impl Into<SharedStorageEntry>) -> Self {
+                let v = self.entries.get_or_insert(Vec::new());
+                v.push(entrie.into());
+                self
+            }
+            pub fn entries<I, S>(mut self, entries: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<SharedStorageEntry>,
+            {
+                let v = self.entries.get_or_insert(Vec::new());
+                for val in entries {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetSharedStorageEntriesReturns, String> {
+                Ok(GetSharedStorageEntriesReturns {
+                    entries: self.entries.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(entries))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetSharedStorageEntriesParams {
+            type Response = GetSharedStorageEntriesReturns;
+        }
+        #[doc = "Sets entry with `key` and `value` for a given origin's shared storage.\n[setSharedStorageEntry](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setSharedStorageEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSharedStorageEntryParams {
+            #[serde(rename = "ownerOrigin")]
+            pub owner_origin: String,
+            #[serde(rename = "key")]
+            pub key: String,
+            #[serde(rename = "value")]
+            pub value: String,
+            #[doc = "If `ignoreIfPresent` is included and true, then only sets the entry if\n`key` doesn't already exist."]
+            #[serde(rename = "ignoreIfPresent")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub ignore_if_present: Option<bool>,
+        }
+        impl SetSharedStorageEntryParams {
+            pub fn new(
+                owner_origin: impl Into<String>,
+                key: impl Into<String>,
+                value: impl Into<String>,
+            ) -> Self {
+                Self {
+                    owner_origin: owner_origin.into(),
+                    key: key.into(),
+                    value: value.into(),
+                    ignore_if_present: None,
+                }
+            }
+        }
+        impl SetSharedStorageEntryParams {
+            pub fn builder() -> SetSharedStorageEntryParamsBuilder {
+                SetSharedStorageEntryParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSharedStorageEntryParamsBuilder {
+            owner_origin: Option<String>,
+            key: Option<String>,
+            value: Option<String>,
+            ignore_if_present: Option<bool>,
+        }
+        impl SetSharedStorageEntryParamsBuilder {
+            pub fn owner_origin(mut self, owner_origin: impl Into<String>) -> Self {
+                self.owner_origin = Some(owner_origin.into());
+                self
+            }
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn value(mut self, value: impl Into<String>) -> Self {
+                self.value = Some(value.into());
+                self
+            }
+            pub fn ignore_if_present(mut self, ignore_if_present: impl Into<bool>) -> Self {
+                self.ignore_if_present = Some(ignore_if_present.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSharedStorageEntryParams, String> {
+                Ok(SetSharedStorageEntryParams {
+                    owner_origin: self.owner_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(owner_origin))
+                    })?,
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                    value: self.value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(value))
+                    })?,
+                    ignore_if_present: self.ignore_if_present,
+                })
+            }
+        }
+        impl SetSharedStorageEntryParams {
+            pub const IDENTIFIER: &'static str = "Storage.setSharedStorageEntry";
+        }
+        impl chromiumoxide_types::Method for SetSharedStorageEntryParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSharedStorageEntryParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets entry with `key` and `value` for a given origin's shared storage.\n[setSharedStorageEntry](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setSharedStorageEntry)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSharedStorageEntryReturns {}
+        impl chromiumoxide_types::Command for SetSharedStorageEntryParams {
+            type Response = SetSharedStorageEntryReturns;
+        }
+        #[doc = "Deletes entry for `key` (if it exists) for a given origin's shared storage.\n[deleteSharedStorageEntry](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-deleteSharedStorageEntry)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeleteSharedStorageEntryParams {
+            #[serde(rename = "ownerOrigin")]
+            pub owner_origin: String,
+            #[serde(rename = "key")]
+            pub key: String,
+        }
+        impl DeleteSharedStorageEntryParams {
+            pub fn new(owner_origin: impl Into<String>, key: impl Into<String>) -> Self {
+                Self {
+                    owner_origin: owner_origin.into(),
+                    key: key.into(),
+                }
+            }
+        }
+        impl DeleteSharedStorageEntryParams {
+            pub fn builder() -> DeleteSharedStorageEntryParamsBuilder {
+                DeleteSharedStorageEntryParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeleteSharedStorageEntryParamsBuilder {
+            owner_origin: Option<String>,
+            key: Option<String>,
+        }
+        impl DeleteSharedStorageEntryParamsBuilder {
+            pub fn owner_origin(mut self, owner_origin: impl Into<String>) -> Self {
+                self.owner_origin = Some(owner_origin.into());
+                self
+            }
+            pub fn key(mut self, key: impl Into<String>) -> Self {
+                self.key = Some(key.into());
+                self
+            }
+            pub fn build(self) -> Result<DeleteSharedStorageEntryParams, String> {
+                Ok(DeleteSharedStorageEntryParams {
+                    owner_origin: self.owner_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(owner_origin))
+                    })?,
+                    key: self
+                        .key
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(key)))?,
+                })
+            }
+        }
+        impl DeleteSharedStorageEntryParams {
+            pub const IDENTIFIER: &'static str = "Storage.deleteSharedStorageEntry";
+        }
+        impl chromiumoxide_types::Method for DeleteSharedStorageEntryParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DeleteSharedStorageEntryParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Deletes entry for `key` (if it exists) for a given origin's shared storage.\n[deleteSharedStorageEntry](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-deleteSharedStorageEntry)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DeleteSharedStorageEntryReturns {}
+        impl chromiumoxide_types::Command for DeleteSharedStorageEntryParams {
+            type Response = DeleteSharedStorageEntryReturns;
+        }
+        #[doc = "Clears all entries for a given origin's shared storage.\n[clearSharedStorageEntries](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-clearSharedStorageEntries)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClearSharedStorageEntriesParams {
+            #[serde(rename = "ownerOrigin")]
+            pub owner_origin: String,
+        }
+        impl ClearSharedStorageEntriesParams {
+            pub fn new(owner_origin: impl Into<String>) -> Self {
+                Self {
+                    owner_origin: owner_origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for ClearSharedStorageEntriesParams {
+            fn from(url: T) -> Self {
+                ClearSharedStorageEntriesParams::new(url)
+            }
+        }
+        impl ClearSharedStorageEntriesParams {
+            pub fn builder() -> ClearSharedStorageEntriesParamsBuilder {
+                ClearSharedStorageEntriesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearSharedStorageEntriesParamsBuilder {
+            owner_origin: Option<String>,
+        }
+        impl ClearSharedStorageEntriesParamsBuilder {
+            pub fn owner_origin(mut self, owner_origin: impl Into<String>) -> Self {
+                self.owner_origin = Some(owner_origin.into());
+                self
+            }
+            pub fn build(self) -> Result<ClearSharedStorageEntriesParams, String> {
+                Ok(ClearSharedStorageEntriesParams {
+                    owner_origin: self.owner_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(owner_origin))
+                    })?,
+                })
+            }
+        }
+        impl ClearSharedStorageEntriesParams {
+            pub const IDENTIFIER: &'static str = "Storage.clearSharedStorageEntries";
+        }
+        impl chromiumoxide_types::Method for ClearSharedStorageEntriesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearSharedStorageEntriesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears all entries for a given origin's shared storage.\n[clearSharedStorageEntries](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-clearSharedStorageEntries)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearSharedStorageEntriesReturns {}
+        impl chromiumoxide_types::Command for ClearSharedStorageEntriesParams {
+            type Response = ClearSharedStorageEntriesReturns;
+        }
+        #[doc = "Resets the budget for `ownerOrigin` by clearing all budget withdrawals.\n[resetSharedStorageBudget](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-resetSharedStorageBudget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ResetSharedStorageBudgetParams {
+            #[serde(rename = "ownerOrigin")]
+            pub owner_origin: String,
+        }
+        impl ResetSharedStorageBudgetParams {
+            pub fn new(owner_origin: impl Into<String>) -> Self {
+                Self {
+                    owner_origin: owner_origin.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for ResetSharedStorageBudgetParams {
+            fn from(url: T) -> Self {
+                ResetSharedStorageBudgetParams::new(url)
+            }
+        }
+        impl ResetSharedStorageBudgetParams {
+            pub fn builder() -> ResetSharedStorageBudgetParamsBuilder {
+                ResetSharedStorageBudgetParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ResetSharedStorageBudgetParamsBuilder {
+            owner_origin: Option<String>,
+        }
+        impl ResetSharedStorageBudgetParamsBuilder {
+            pub fn owner_origin(mut self, owner_origin: impl Into<String>) -> Self {
+                self.owner_origin = Some(owner_origin.into());
+                self
+            }
+            pub fn build(self) -> Result<ResetSharedStorageBudgetParams, String> {
+                Ok(ResetSharedStorageBudgetParams {
+                    owner_origin: self.owner_origin.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(owner_origin))
+                    })?,
+                })
+            }
+        }
+        impl ResetSharedStorageBudgetParams {
+            pub const IDENTIFIER: &'static str = "Storage.resetSharedStorageBudget";
+        }
+        impl chromiumoxide_types::Method for ResetSharedStorageBudgetParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ResetSharedStorageBudgetParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Resets the budget for `ownerOrigin` by clearing all budget withdrawals.\n[resetSharedStorageBudget](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-resetSharedStorageBudget)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ResetSharedStorageBudgetReturns {}
+        impl chromiumoxide_types::Command for ResetSharedStorageBudgetParams {
+            type Response = ResetSharedStorageBudgetReturns;
+        }
+        #[doc = "Enables/disables issuing of sharedStorageAccessed events.\n[setSharedStorageTracking](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setSharedStorageTracking)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetSharedStorageTrackingParams {
+            #[serde(rename = "enable")]
+            pub enable: bool,
+        }
+        impl SetSharedStorageTrackingParams {
+            pub fn new(enable: impl Into<bool>) -> Self {
+                Self {
+                    enable: enable.into(),
+                }
+            }
+        }
+        impl SetSharedStorageTrackingParams {
+            pub fn builder() -> SetSharedStorageTrackingParamsBuilder {
+                SetSharedStorageTrackingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetSharedStorageTrackingParamsBuilder {
+            enable: Option<bool>,
+        }
+        impl SetSharedStorageTrackingParamsBuilder {
+            pub fn enable(mut self, enable: impl Into<bool>) -> Self {
+                self.enable = Some(enable.into());
+                self
+            }
+            pub fn build(self) -> Result<SetSharedStorageTrackingParams, String> {
+                Ok(SetSharedStorageTrackingParams {
+                    enable: self.enable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enable))
+                    })?,
+                })
+            }
+        }
+        impl SetSharedStorageTrackingParams {
+            pub const IDENTIFIER: &'static str = "Storage.setSharedStorageTracking";
+        }
+        impl chromiumoxide_types::Method for SetSharedStorageTrackingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetSharedStorageTrackingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables/disables issuing of sharedStorageAccessed events.\n[setSharedStorageTracking](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setSharedStorageTracking)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetSharedStorageTrackingReturns {}
+        impl chromiumoxide_types::Command for SetSharedStorageTrackingParams {
+            type Response = SetSharedStorageTrackingReturns;
+        }
+        #[doc = "Set tracking for a storage key's buckets.\n[setStorageBucketTracking](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setStorageBucketTracking)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetStorageBucketTrackingParams {
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+            #[serde(rename = "enable")]
+            pub enable: bool,
+        }
+        impl SetStorageBucketTrackingParams {
+            pub fn new(storage_key: impl Into<String>, enable: impl Into<bool>) -> Self {
+                Self {
+                    storage_key: storage_key.into(),
+                    enable: enable.into(),
+                }
+            }
+        }
+        impl SetStorageBucketTrackingParams {
+            pub fn builder() -> SetStorageBucketTrackingParamsBuilder {
+                SetStorageBucketTrackingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetStorageBucketTrackingParamsBuilder {
+            storage_key: Option<String>,
+            enable: Option<bool>,
+        }
+        impl SetStorageBucketTrackingParamsBuilder {
+            pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
+                self.storage_key = Some(storage_key.into());
+                self
+            }
+            pub fn enable(mut self, enable: impl Into<bool>) -> Self {
+                self.enable = Some(enable.into());
+                self
+            }
+            pub fn build(self) -> Result<SetStorageBucketTrackingParams, String> {
+                Ok(SetStorageBucketTrackingParams {
+                    storage_key: self.storage_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(storage_key))
+                    })?,
+                    enable: self.enable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enable))
+                    })?,
+                })
+            }
+        }
+        impl SetStorageBucketTrackingParams {
+            pub const IDENTIFIER: &'static str = "Storage.setStorageBucketTracking";
+        }
+        impl chromiumoxide_types::Method for SetStorageBucketTrackingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetStorageBucketTrackingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Set tracking for a storage key's buckets.\n[setStorageBucketTracking](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setStorageBucketTracking)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetStorageBucketTrackingReturns {}
+        impl chromiumoxide_types::Command for SetStorageBucketTrackingParams {
+            type Response = SetStorageBucketTrackingReturns;
+        }
+        #[doc = "Deletes the Storage Bucket with the given storage key and bucket name.\n[deleteStorageBucket](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-deleteStorageBucket)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DeleteStorageBucketParams {
+            #[serde(rename = "bucket")]
+            pub bucket: StorageBucket,
+        }
+        impl DeleteStorageBucketParams {
+            pub fn new(bucket: impl Into<StorageBucket>) -> Self {
+                Self {
+                    bucket: bucket.into(),
+                }
+            }
+        }
+        impl DeleteStorageBucketParams {
+            pub fn builder() -> DeleteStorageBucketParamsBuilder {
+                DeleteStorageBucketParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DeleteStorageBucketParamsBuilder {
+            bucket: Option<StorageBucket>,
+        }
+        impl DeleteStorageBucketParamsBuilder {
+            pub fn bucket(mut self, bucket: impl Into<StorageBucket>) -> Self {
+                self.bucket = Some(bucket.into());
+                self
+            }
+            pub fn build(self) -> Result<DeleteStorageBucketParams, String> {
+                Ok(DeleteStorageBucketParams {
+                    bucket: self.bucket.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(bucket))
+                    })?,
+                })
+            }
+        }
+        impl DeleteStorageBucketParams {
+            pub const IDENTIFIER: &'static str = "Storage.deleteStorageBucket";
+        }
+        impl chromiumoxide_types::Method for DeleteStorageBucketParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DeleteStorageBucketParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Deletes the Storage Bucket with the given storage key and bucket name.\n[deleteStorageBucket](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-deleteStorageBucket)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DeleteStorageBucketReturns {}
+        impl chromiumoxide_types::Command for DeleteStorageBucketParams {
+            type Response = DeleteStorageBucketReturns;
+        }
+        #[doc = "Deletes state for sites identified as potential bounce trackers, immediately.\n[runBounceTrackingMitigations](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-runBounceTrackingMitigations)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RunBounceTrackingMitigationsParams {}
+        impl RunBounceTrackingMitigationsParams {
+            pub const IDENTIFIER: &'static str = "Storage.runBounceTrackingMitigations";
+        }
+        impl chromiumoxide_types::Method for RunBounceTrackingMitigationsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RunBounceTrackingMitigationsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Deletes state for sites identified as potential bounce trackers, immediately.\n[runBounceTrackingMitigations](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-runBounceTrackingMitigations)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RunBounceTrackingMitigationsReturns {
+            #[serde(rename = "deletedSites")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub deleted_sites: Vec<String>,
+        }
+        impl RunBounceTrackingMitigationsReturns {
+            pub fn new(deleted_sites: Vec<String>) -> Self {
+                Self { deleted_sites }
+            }
+        }
+        impl RunBounceTrackingMitigationsReturns {
+            pub fn builder() -> RunBounceTrackingMitigationsReturnsBuilder {
+                RunBounceTrackingMitigationsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RunBounceTrackingMitigationsReturnsBuilder {
+            deleted_sites: Option<Vec<String>>,
+        }
+        impl RunBounceTrackingMitigationsReturnsBuilder {
+            pub fn deleted_site(mut self, deleted_site: impl Into<String>) -> Self {
+                let v = self.deleted_sites.get_or_insert(Vec::new());
+                v.push(deleted_site.into());
+                self
+            }
+            pub fn deleted_sites<I, S>(mut self, deleted_sites: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.deleted_sites.get_or_insert(Vec::new());
+                for val in deleted_sites {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<RunBounceTrackingMitigationsReturns, String> {
+                Ok(RunBounceTrackingMitigationsReturns {
+                    deleted_sites: self.deleted_sites.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(deleted_sites))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for RunBounceTrackingMitigationsParams {
+            type Response = RunBounceTrackingMitigationsReturns;
+        }
+        #[doc = "https://wicg.github.io/attribution-reporting-api/\n[setAttributionReportingLocalTestingMode](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setAttributionReportingLocalTestingMode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAttributionReportingLocalTestingModeParams {
+            #[doc = "If enabled, noise is suppressed and reports are sent immediately."]
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetAttributionReportingLocalTestingModeParams {
+            pub fn new(enabled: impl Into<bool>) -> Self {
+                Self {
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetAttributionReportingLocalTestingModeParams {
+            pub fn builder() -> SetAttributionReportingLocalTestingModeParamsBuilder {
+                SetAttributionReportingLocalTestingModeParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAttributionReportingLocalTestingModeParamsBuilder {
+            enabled: Option<bool>,
+        }
+        impl SetAttributionReportingLocalTestingModeParamsBuilder {
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAttributionReportingLocalTestingModeParams, String> {
+                Ok(SetAttributionReportingLocalTestingModeParams {
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetAttributionReportingLocalTestingModeParams {
+            pub const IDENTIFIER: &'static str = "Storage.setAttributionReportingLocalTestingMode";
+        }
+        impl chromiumoxide_types::Method for SetAttributionReportingLocalTestingModeParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAttributionReportingLocalTestingModeParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "https://wicg.github.io/attribution-reporting-api/\n[setAttributionReportingLocalTestingMode](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setAttributionReportingLocalTestingMode)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAttributionReportingLocalTestingModeReturns {}
+        impl chromiumoxide_types::Command for SetAttributionReportingLocalTestingModeParams {
+            type Response = SetAttributionReportingLocalTestingModeReturns;
+        }
+        #[doc = "Enables/disables issuing of Attribution Reporting events.\n[setAttributionReportingTracking](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setAttributionReportingTracking)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAttributionReportingTrackingParams {
+            #[serde(rename = "enable")]
+            pub enable: bool,
+        }
+        impl SetAttributionReportingTrackingParams {
+            pub fn new(enable: impl Into<bool>) -> Self {
+                Self {
+                    enable: enable.into(),
+                }
+            }
+        }
+        impl SetAttributionReportingTrackingParams {
+            pub fn builder() -> SetAttributionReportingTrackingParamsBuilder {
+                SetAttributionReportingTrackingParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAttributionReportingTrackingParamsBuilder {
+            enable: Option<bool>,
+        }
+        impl SetAttributionReportingTrackingParamsBuilder {
+            pub fn enable(mut self, enable: impl Into<bool>) -> Self {
+                self.enable = Some(enable.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAttributionReportingTrackingParams, String> {
+                Ok(SetAttributionReportingTrackingParams {
+                    enable: self.enable.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enable))
+                    })?,
+                })
+            }
+        }
+        impl SetAttributionReportingTrackingParams {
+            pub const IDENTIFIER: &'static str = "Storage.setAttributionReportingTracking";
+        }
+        impl chromiumoxide_types::Method for SetAttributionReportingTrackingParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAttributionReportingTrackingParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables/disables issuing of Attribution Reporting events.\n[setAttributionReportingTracking](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-setAttributionReportingTracking)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAttributionReportingTrackingReturns {}
+        impl chromiumoxide_types::Command for SetAttributionReportingTrackingParams {
+            type Response = SetAttributionReportingTrackingReturns;
+        }
+        #[doc = "Sends all pending Attribution Reports immediately, regardless of their\nscheduled report time.\n[sendPendingAttributionReports](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-sendPendingAttributionReports)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SendPendingAttributionReportsParams {}
+        impl SendPendingAttributionReportsParams {
+            pub const IDENTIFIER: &'static str = "Storage.sendPendingAttributionReports";
+        }
+        impl chromiumoxide_types::Method for SendPendingAttributionReportsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SendPendingAttributionReportsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sends all pending Attribution Reports immediately, regardless of their\nscheduled report time.\n[sendPendingAttributionReports](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-sendPendingAttributionReports)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SendPendingAttributionReportsReturns {
+            #[doc = "The number of reports that were sent."]
+            #[serde(rename = "numSent")]
+            pub num_sent: i64,
+        }
+        impl SendPendingAttributionReportsReturns {
+            pub fn new(num_sent: impl Into<i64>) -> Self {
+                Self {
+                    num_sent: num_sent.into(),
+                }
+            }
+        }
+        impl SendPendingAttributionReportsReturns {
+            pub fn builder() -> SendPendingAttributionReportsReturnsBuilder {
+                SendPendingAttributionReportsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SendPendingAttributionReportsReturnsBuilder {
+            num_sent: Option<i64>,
+        }
+        impl SendPendingAttributionReportsReturnsBuilder {
+            pub fn num_sent(mut self, num_sent: impl Into<i64>) -> Self {
+                self.num_sent = Some(num_sent.into());
+                self
+            }
+            pub fn build(self) -> Result<SendPendingAttributionReportsReturns, String> {
+                Ok(SendPendingAttributionReportsReturns {
+                    num_sent: self.num_sent.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(num_sent))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for SendPendingAttributionReportsParams {
+            type Response = SendPendingAttributionReportsReturns;
+        }
+        #[doc = "Returns the effective Related Website Sets in use by this profile for the browser\nsession. The effective Related Website Sets will not change during a browser session.\n[getRelatedWebsiteSets](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getRelatedWebsiteSets)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetRelatedWebsiteSetsParams {}
+        impl GetRelatedWebsiteSetsParams {
+            pub const IDENTIFIER: &'static str = "Storage.getRelatedWebsiteSets";
+        }
+        impl chromiumoxide_types::Method for GetRelatedWebsiteSetsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetRelatedWebsiteSetsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the effective Related Website Sets in use by this profile for the browser\nsession. The effective Related Website Sets will not change during a browser session.\n[getRelatedWebsiteSets](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getRelatedWebsiteSets)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetRelatedWebsiteSetsReturns {
+            #[serde(rename = "sets")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub sets: Vec<RelatedWebsiteSet>,
+        }
+        impl GetRelatedWebsiteSetsReturns {
+            pub fn new(sets: Vec<RelatedWebsiteSet>) -> Self {
+                Self { sets }
+            }
+        }
+        impl GetRelatedWebsiteSetsReturns {
+            pub fn builder() -> GetRelatedWebsiteSetsReturnsBuilder {
+                GetRelatedWebsiteSetsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetRelatedWebsiteSetsReturnsBuilder {
+            sets: Option<Vec<RelatedWebsiteSet>>,
+        }
+        impl GetRelatedWebsiteSetsReturnsBuilder {
+            pub fn set(mut self, set: impl Into<RelatedWebsiteSet>) -> Self {
+                let v = self.sets.get_or_insert(Vec::new());
+                v.push(set.into());
+                self
+            }
+            pub fn sets<I, S>(mut self, sets: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<RelatedWebsiteSet>,
+            {
+                let v = self.sets.get_or_insert(Vec::new());
+                for val in sets {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetRelatedWebsiteSetsReturns, String> {
+                Ok(GetRelatedWebsiteSetsReturns {
+                    sets: self.sets.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(sets))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetRelatedWebsiteSetsParams {
+            type Response = GetRelatedWebsiteSetsReturns;
+        }
+        #[doc = "Returns the list of URLs from a page and its embedded resources that match\nexisting grace period URL pattern rules.\nhttps://developers.google.com/privacy-sandbox/cookies/temporary-exceptions/grace-period\n[getAffectedUrlsForThirdPartyCookieMetadata](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getAffectedUrlsForThirdPartyCookieMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAffectedUrlsForThirdPartyCookieMetadataParams {
+            #[doc = "The URL of the page currently being visited."]
+            #[serde(rename = "firstPartyUrl")]
+            pub first_party_url: String,
+            #[doc = "The list of embedded resource URLs from the page."]
+            #[serde(rename = "thirdPartyUrls")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub third_party_urls: Vec<String>,
+        }
+        impl GetAffectedUrlsForThirdPartyCookieMetadataParams {
+            pub fn new(first_party_url: impl Into<String>, third_party_urls: Vec<String>) -> Self {
+                Self {
+                    first_party_url: first_party_url.into(),
+                    third_party_urls,
+                }
+            }
+        }
+        impl GetAffectedUrlsForThirdPartyCookieMetadataParams {
+            pub fn builder() -> GetAffectedUrlsForThirdPartyCookieMetadataParamsBuilder {
+                GetAffectedUrlsForThirdPartyCookieMetadataParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAffectedUrlsForThirdPartyCookieMetadataParamsBuilder {
+            first_party_url: Option<String>,
+            third_party_urls: Option<Vec<String>>,
+        }
+        impl GetAffectedUrlsForThirdPartyCookieMetadataParamsBuilder {
+            pub fn first_party_url(mut self, first_party_url: impl Into<String>) -> Self {
+                self.first_party_url = Some(first_party_url.into());
+                self
+            }
+            pub fn third_party_url(mut self, third_party_url: impl Into<String>) -> Self {
+                let v = self.third_party_urls.get_or_insert(Vec::new());
+                v.push(third_party_url.into());
+                self
+            }
+            pub fn third_party_urls<I, S>(mut self, third_party_urls: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.third_party_urls.get_or_insert(Vec::new());
+                for val in third_party_urls {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetAffectedUrlsForThirdPartyCookieMetadataParams, String> {
+                Ok(GetAffectedUrlsForThirdPartyCookieMetadataParams {
+                    first_party_url: self.first_party_url.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(first_party_url))
+                    })?,
+                    third_party_urls: self.third_party_urls.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(third_party_urls)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl GetAffectedUrlsForThirdPartyCookieMetadataParams {
+            pub const IDENTIFIER: &'static str =
+                "Storage.getAffectedUrlsForThirdPartyCookieMetadata";
+        }
+        impl chromiumoxide_types::Method for GetAffectedUrlsForThirdPartyCookieMetadataParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetAffectedUrlsForThirdPartyCookieMetadataParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns the list of URLs from a page and its embedded resources that match\nexisting grace period URL pattern rules.\nhttps://developers.google.com/privacy-sandbox/cookies/temporary-exceptions/grace-period\n[getAffectedUrlsForThirdPartyCookieMetadata](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#method-getAffectedUrlsForThirdPartyCookieMetadata)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetAffectedUrlsForThirdPartyCookieMetadataReturns {
+            #[doc = "Array of matching URLs. If there is a primary pattern match for the first-\nparty URL, only the first-party URL is returned in the array."]
+            #[serde(rename = "matchedUrls")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub matched_urls: Vec<String>,
+        }
+        impl GetAffectedUrlsForThirdPartyCookieMetadataReturns {
+            pub fn new(matched_urls: Vec<String>) -> Self {
+                Self { matched_urls }
+            }
+        }
+        impl GetAffectedUrlsForThirdPartyCookieMetadataReturns {
+            pub fn builder() -> GetAffectedUrlsForThirdPartyCookieMetadataReturnsBuilder {
+                GetAffectedUrlsForThirdPartyCookieMetadataReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetAffectedUrlsForThirdPartyCookieMetadataReturnsBuilder {
+            matched_urls: Option<Vec<String>>,
+        }
+        impl GetAffectedUrlsForThirdPartyCookieMetadataReturnsBuilder {
+            pub fn matched_url(mut self, matched_url: impl Into<String>) -> Self {
+                let v = self.matched_urls.get_or_insert(Vec::new());
+                v.push(matched_url.into());
+                self
+            }
+            pub fn matched_urls<I, S>(mut self, matched_urls: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.matched_urls.get_or_insert(Vec::new());
+                for val in matched_urls {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(
+                self,
+            ) -> Result<GetAffectedUrlsForThirdPartyCookieMetadataReturns, String> {
+                Ok(GetAffectedUrlsForThirdPartyCookieMetadataReturns {
+                    matched_urls: self.matched_urls.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(matched_urls))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetAffectedUrlsForThirdPartyCookieMetadataParams {
+            type Response = GetAffectedUrlsForThirdPartyCookieMetadataReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetProtectedAudienceKAnonymityParams {
+            #[serde(rename = "owner")]
+            pub owner: String,
+            #[serde(rename = "name")]
+            pub name: String,
+            #[serde(rename = "hashes")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub hashes: Vec<chromiumoxide_types::Binary>,
+        }
+        impl SetProtectedAudienceKAnonymityParams {
+            pub fn new(
+                owner: impl Into<String>,
+                name: impl Into<String>,
+                hashes: Vec<chromiumoxide_types::Binary>,
+            ) -> Self {
+                Self {
+                    owner: owner.into(),
+                    name: name.into(),
+                    hashes,
+                }
+            }
+        }
+        impl SetProtectedAudienceKAnonymityParams {
+            pub fn builder() -> SetProtectedAudienceKAnonymityParamsBuilder {
+                SetProtectedAudienceKAnonymityParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetProtectedAudienceKAnonymityParamsBuilder {
+            owner: Option<String>,
+            name: Option<String>,
+            hashes: Option<Vec<chromiumoxide_types::Binary>>,
+        }
+        impl SetProtectedAudienceKAnonymityParamsBuilder {
+            pub fn owner(mut self, owner: impl Into<String>) -> Self {
+                self.owner = Some(owner.into());
+                self
+            }
+            pub fn name(mut self, name: impl Into<String>) -> Self {
+                self.name = Some(name.into());
+                self
+            }
+            pub fn hashe(mut self, hashe: impl Into<chromiumoxide_types::Binary>) -> Self {
+                let v = self.hashes.get_or_insert(Vec::new());
+                v.push(hashe.into());
+                self
+            }
+            pub fn hashes<I, S>(mut self, hashes: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<chromiumoxide_types::Binary>,
+            {
+                let v = self.hashes.get_or_insert(Vec::new());
+                for val in hashes {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetProtectedAudienceKAnonymityParams, String> {
+                Ok(SetProtectedAudienceKAnonymityParams {
+                    owner: self.owner.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(owner))
+                    })?,
+                    name: self.name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(name))
+                    })?,
+                    hashes: self.hashes.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(hashes))
+                    })?,
+                })
+            }
+        }
+        impl SetProtectedAudienceKAnonymityParams {
+            pub const IDENTIFIER: &'static str = "Storage.setProtectedAudienceKAnonymity";
+        }
+        impl chromiumoxide_types::Method for SetProtectedAudienceKAnonymityParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetProtectedAudienceKAnonymityParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetProtectedAudienceKAnonymityReturns {}
+        impl chromiumoxide_types::Command for SetProtectedAudienceKAnonymityParams {
+            type Response = SetProtectedAudienceKAnonymityReturns;
+        }
+        #[doc = "A cache's contents have been modified.\n[cacheStorageContentUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#event-cacheStorageContentUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventCacheStorageContentUpdated {
+            #[doc = "Origin to update."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "Storage key to update."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+            #[doc = "Storage bucket to update."]
+            #[serde(rename = "bucketId")]
+            pub bucket_id: String,
+            #[doc = "Name of cache in origin."]
+            #[serde(rename = "cacheName")]
+            pub cache_name: String,
+        }
+        impl EventCacheStorageContentUpdated {
+            pub const IDENTIFIER: &'static str = "Storage.cacheStorageContentUpdated";
+        }
+        impl chromiumoxide_types::Method for EventCacheStorageContentUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventCacheStorageContentUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "A cache has been added/deleted.\n[cacheStorageListUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#event-cacheStorageListUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventCacheStorageListUpdated {
+            #[doc = "Origin to update."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "Storage key to update."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+            #[doc = "Storage bucket to update."]
+            #[serde(rename = "bucketId")]
+            pub bucket_id: String,
+        }
+        impl EventCacheStorageListUpdated {
+            pub const IDENTIFIER: &'static str = "Storage.cacheStorageListUpdated";
+        }
+        impl chromiumoxide_types::Method for EventCacheStorageListUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventCacheStorageListUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "The origin's IndexedDB object store has been modified.\n[indexedDBContentUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#event-indexedDBContentUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventIndexedDbContentUpdated {
+            #[doc = "Origin to update."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "Storage key to update."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+            #[doc = "Storage bucket to update."]
+            #[serde(rename = "bucketId")]
+            pub bucket_id: String,
+            #[doc = "Database to update."]
+            #[serde(rename = "databaseName")]
+            pub database_name: String,
+            #[doc = "ObjectStore to update."]
+            #[serde(rename = "objectStoreName")]
+            pub object_store_name: String,
+        }
+        impl EventIndexedDbContentUpdated {
+            pub const IDENTIFIER: &'static str = "Storage.indexedDBContentUpdated";
+        }
+        impl chromiumoxide_types::Method for EventIndexedDbContentUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventIndexedDbContentUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "The origin's IndexedDB database list has been modified.\n[indexedDBListUpdated](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#event-indexedDBListUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventIndexedDbListUpdated {
+            #[doc = "Origin to update."]
+            #[serde(rename = "origin")]
+            pub origin: String,
+            #[doc = "Storage key to update."]
+            #[serde(rename = "storageKey")]
+            pub storage_key: String,
+            #[doc = "Storage bucket to update."]
+            #[serde(rename = "bucketId")]
+            pub bucket_id: String,
+        }
+        impl EventIndexedDbListUpdated {
+            pub const IDENTIFIER: &'static str = "Storage.indexedDBListUpdated";
+        }
+        impl chromiumoxide_types::Method for EventIndexedDbListUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventIndexedDbListUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "One of the interest groups was accessed. Note that these events are global\nto all targets sharing an interest group store.\n[interestGroupAccessed](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#event-interestGroupAccessed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventInterestGroupAccessed {
+            #[serde(rename = "accessTime")]
+            pub access_time: super::network::TimeSinceEpoch,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: InterestGroupAccessType,
+            #[serde(rename = "ownerOrigin")]
+            pub owner_origin: String,
+            #[serde(rename = "name")]
+            pub name: String,
+            #[doc = "For topLevelBid/topLevelAdditionalBid, and when appropriate,\nwin and additionalBidWin"]
+            #[serde(rename = "componentSellerOrigin")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub component_seller_origin: Option<String>,
+            #[doc = "For bid or somethingBid event, if done locally and not on a server."]
+            #[serde(rename = "bid")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub bid: Option<f64>,
+            #[serde(rename = "bidCurrency")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub bid_currency: Option<String>,
+            #[doc = "For non-global events --- links to interestGroupAuctionEvent"]
+            #[serde(rename = "uniqueAuctionId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub unique_auction_id: Option<InterestGroupAuctionId>,
+        }
+        impl EventInterestGroupAccessed {
+            pub const IDENTIFIER: &'static str = "Storage.interestGroupAccessed";
+        }
+        impl chromiumoxide_types::Method for EventInterestGroupAccessed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventInterestGroupAccessed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "An auction involving interest groups is taking place. These events are\ntarget-specific.\n[interestGroupAuctionEventOccurred](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#event-interestGroupAuctionEventOccurred)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventInterestGroupAuctionEventOccurred {
+            #[serde(rename = "eventTime")]
+            pub event_time: super::network::TimeSinceEpoch,
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: InterestGroupAuctionEventType,
+            #[serde(rename = "uniqueAuctionId")]
+            pub unique_auction_id: InterestGroupAuctionId,
+            #[doc = "Set for child auctions."]
+            #[serde(rename = "parentAuctionId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent_auction_id: Option<InterestGroupAuctionId>,
+            #[doc = "Set for started and configResolved"]
+            #[serde(rename = "auctionConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub auction_config: Option<serde_json::Value>,
+        }
+        impl EventInterestGroupAuctionEventOccurred {
+            pub const IDENTIFIER: &'static str = "Storage.interestGroupAuctionEventOccurred";
+        }
+        impl chromiumoxide_types::Method for EventInterestGroupAuctionEventOccurred {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventInterestGroupAuctionEventOccurred {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Specifies which auctions a particular network fetch may be related to, and\nin what role. Note that it is not ordered with respect to\nNetwork.requestWillBeSent (but will happen before loadingFinished\nloadingFailed).\n[interestGroupAuctionNetworkRequestCreated](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#event-interestGroupAuctionNetworkRequestCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventInterestGroupAuctionNetworkRequestCreated {
+            #[serde(rename = "type")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub r#type: InterestGroupAuctionFetchType,
+            #[serde(rename = "requestId")]
+            pub request_id: super::network::RequestId,
+            #[doc = "This is the set of the auctions using the worklet that issued this\nrequest.  In the case of trusted signals, it's possible that only some of\nthem actually care about the keys being queried."]
+            #[serde(rename = "auctions")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub auctions: Vec<InterestGroupAuctionId>,
+        }
+        impl EventInterestGroupAuctionNetworkRequestCreated {
+            pub const IDENTIFIER: &'static str =
+                "Storage.interestGroupAuctionNetworkRequestCreated";
+        }
+        impl chromiumoxide_types::Method for EventInterestGroupAuctionNetworkRequestCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventInterestGroupAuctionNetworkRequestCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Shared storage was accessed by the associated page.\nThe following parameters are included in all events.\n[sharedStorageAccessed](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#event-sharedStorageAccessed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventSharedStorageAccessed {
+            #[doc = "Time of the access."]
+            #[serde(rename = "accessTime")]
+            pub access_time: super::network::TimeSinceEpoch,
+            #[doc = "Enum value indicating the access scope."]
+            #[serde(rename = "scope")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub scope: SharedStorageAccessScope,
+            #[doc = "Enum value indicating the Shared Storage API method invoked."]
+            #[serde(rename = "method")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub method: SharedStorageAccessMethod,
+            #[doc = "DevTools Frame Token for the primary frame tree's root."]
+            #[serde(rename = "mainFrameId")]
+            pub main_frame_id: super::page::FrameId,
+            #[doc = "Serialization of the origin owning the Shared Storage data."]
+            #[serde(rename = "ownerOrigin")]
+            pub owner_origin: String,
+            #[doc = "Serialization of the site owning the Shared Storage data."]
+            #[serde(rename = "ownerSite")]
+            pub owner_site: String,
+            #[doc = "The sub-parameters wrapped by `params` are all optional and their\npresence/absence depends on `type`."]
+            #[serde(rename = "params")]
+            pub params: SharedStorageAccessParams,
+        }
+        impl EventSharedStorageAccessed {
+            pub const IDENTIFIER: &'static str = "Storage.sharedStorageAccessed";
+        }
+        impl chromiumoxide_types::Method for EventSharedStorageAccessed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventSharedStorageAccessed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "A shared storage run or selectURL operation finished its execution.\nThe following parameters are included in all events.\n[sharedStorageWorkletOperationExecutionFinished](https://chromedevtools.github.io/devtools-protocol/tot/Storage/#event-sharedStorageWorkletOperationExecutionFinished)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventSharedStorageWorkletOperationExecutionFinished {
+            #[doc = "Time that the operation finished."]
+            #[serde(rename = "finishedTime")]
+            pub finished_time: super::network::TimeSinceEpoch,
+            #[doc = "Time, in microseconds, from start of shared storage JS API call until\nend of operation execution in the worklet."]
+            #[serde(rename = "executionTime")]
+            pub execution_time: i64,
+            #[doc = "Enum value indicating the Shared Storage API method invoked."]
+            #[serde(rename = "method")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub method: SharedStorageAccessMethod,
+            #[doc = "ID of the operation call."]
+            #[serde(rename = "operationId")]
+            pub operation_id: String,
+            #[doc = "Hex representation of the DevTools token used as the TargetID for the\nassociated shared storage worklet."]
+            #[serde(rename = "workletTargetId")]
+            pub worklet_target_id: super::target::TargetId,
+            #[doc = "DevTools Frame Token for the primary frame tree's root."]
+            #[serde(rename = "mainFrameId")]
+            pub main_frame_id: super::page::FrameId,
+            #[doc = "Serialization of the origin owning the Shared Storage data."]
+            #[serde(rename = "ownerOrigin")]
+            pub owner_origin: String,
+        }
+        impl EventSharedStorageWorkletOperationExecutionFinished {
+            pub const IDENTIFIER: &'static str =
+                "Storage.sharedStorageWorkletOperationExecutionFinished";
+        }
+        impl chromiumoxide_types::Method for EventSharedStorageWorkletOperationExecutionFinished {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventSharedStorageWorkletOperationExecutionFinished {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventStorageBucketCreatedOrUpdated {
+            #[serde(rename = "bucketInfo")]
+            pub bucket_info: StorageBucketInfo,
+        }
+        impl EventStorageBucketCreatedOrUpdated {
+            pub const IDENTIFIER: &'static str = "Storage.storageBucketCreatedOrUpdated";
+        }
+        impl chromiumoxide_types::Method for EventStorageBucketCreatedOrUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventStorageBucketCreatedOrUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventStorageBucketDeleted {
+            #[serde(rename = "bucketId")]
+            pub bucket_id: String,
+        }
+        impl EventStorageBucketDeleted {
+            pub const IDENTIFIER: &'static str = "Storage.storageBucketDeleted";
+        }
+        impl chromiumoxide_types::Method for EventStorageBucketDeleted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventStorageBucketDeleted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAttributionReportingSourceRegistered {
+            #[serde(rename = "registration")]
+            pub registration: AttributionReportingSourceRegistration,
+            #[serde(rename = "result")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub result: AttributionReportingSourceRegistrationResult,
+        }
+        impl EventAttributionReportingSourceRegistered {
+            pub const IDENTIFIER: &'static str = "Storage.attributionReportingSourceRegistered";
+        }
+        impl chromiumoxide_types::Method for EventAttributionReportingSourceRegistered {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAttributionReportingSourceRegistered {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAttributionReportingTriggerRegistered {
+            #[serde(rename = "registration")]
+            pub registration: AttributionReportingTriggerRegistration,
+            #[serde(rename = "eventLevel")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub event_level: AttributionReportingEventLevelResult,
+            #[serde(rename = "aggregatable")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub aggregatable: AttributionReportingAggregatableResult,
+        }
+        impl EventAttributionReportingTriggerRegistered {
+            pub const IDENTIFIER: &'static str = "Storage.attributionReportingTriggerRegistered";
+        }
+        impl chromiumoxide_types::Method for EventAttributionReportingTriggerRegistered {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAttributionReportingTriggerRegistered {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAttributionReportingReportSent {
+            #[serde(rename = "url")]
+            pub url: String,
+            #[serde(rename = "body")]
+            pub body: serde_json::Value,
+            #[serde(rename = "result")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub result: AttributionReportingReportResult,
+            #[doc = "If result is `sent`, populated with net/HTTP status."]
+            #[serde(rename = "netError")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub net_error: Option<i64>,
+            #[serde(rename = "netErrorName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub net_error_name: Option<String>,
+            #[serde(rename = "httpStatusCode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub http_status_code: Option<i64>,
+        }
+        impl EventAttributionReportingReportSent {
+            pub const IDENTIFIER: &'static str = "Storage.attributionReportingReportSent";
+        }
+        impl chromiumoxide_types::Method for EventAttributionReportingReportSent {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAttributionReportingReportSent {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAttributionReportingVerboseDebugReportSent {
+            #[serde(rename = "url")]
+            pub url: String,
+            #[serde(rename = "body")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub body: Option<Vec<serde_json::Value>>,
+            #[serde(rename = "netError")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub net_error: Option<i64>,
+            #[serde(rename = "netErrorName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub net_error_name: Option<String>,
+            #[serde(rename = "httpStatusCode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub http_status_code: Option<i64>,
+        }
+        impl EventAttributionReportingVerboseDebugReportSent {
+            pub const IDENTIFIER: &'static str =
+                "Storage.attributionReportingVerboseDebugReportSent";
+        }
+        impl chromiumoxide_types::Method for EventAttributionReportingVerboseDebugReportSent {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAttributionReportingVerboseDebugReportSent {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "The SystemInfo domain defines methods and events for querying low-level system information."]
+    pub mod system_info {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Describes a single graphics processor (GPU).\n[GPUDevice](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#type-GPUDevice)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GpuDevice {
+            #[doc = "PCI ID of the GPU vendor, if available; 0 otherwise."]
+            #[serde(rename = "vendorId")]
+            pub vendor_id: f64,
+            #[doc = "PCI ID of the GPU device, if available; 0 otherwise."]
+            #[serde(rename = "deviceId")]
+            pub device_id: f64,
+            #[doc = "Sub sys ID of the GPU, only available on Windows."]
+            #[serde(rename = "subSysId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub sub_sys_id: Option<f64>,
+            #[doc = "Revision of the GPU, only available on Windows."]
+            #[serde(rename = "revision")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub revision: Option<f64>,
+            #[doc = "String description of the GPU vendor, if the PCI ID is not available."]
+            #[serde(rename = "vendorString")]
+            pub vendor_string: String,
+            #[doc = "String description of the GPU device, if the PCI ID is not available."]
+            #[serde(rename = "deviceString")]
+            pub device_string: String,
+            #[doc = "String description of the GPU driver vendor."]
+            #[serde(rename = "driverVendor")]
+            pub driver_vendor: String,
+            #[doc = "String description of the GPU driver version."]
+            #[serde(rename = "driverVersion")]
+            pub driver_version: String,
+        }
+        impl GpuDevice {
+            pub fn builder() -> GpuDeviceBuilder {
+                GpuDeviceBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GpuDeviceBuilder {
+            vendor_id: Option<f64>,
+            device_id: Option<f64>,
+            sub_sys_id: Option<f64>,
+            revision: Option<f64>,
+            vendor_string: Option<String>,
+            device_string: Option<String>,
+            driver_vendor: Option<String>,
+            driver_version: Option<String>,
+        }
+        impl GpuDeviceBuilder {
+            pub fn vendor_id(mut self, vendor_id: impl Into<f64>) -> Self {
+                self.vendor_id = Some(vendor_id.into());
+                self
+            }
+            pub fn device_id(mut self, device_id: impl Into<f64>) -> Self {
+                self.device_id = Some(device_id.into());
+                self
+            }
+            pub fn sub_sys_id(mut self, sub_sys_id: impl Into<f64>) -> Self {
+                self.sub_sys_id = Some(sub_sys_id.into());
+                self
+            }
+            pub fn revision(mut self, revision: impl Into<f64>) -> Self {
+                self.revision = Some(revision.into());
+                self
+            }
+            pub fn vendor_string(mut self, vendor_string: impl Into<String>) -> Self {
+                self.vendor_string = Some(vendor_string.into());
+                self
+            }
+            pub fn device_string(mut self, device_string: impl Into<String>) -> Self {
+                self.device_string = Some(device_string.into());
+                self
+            }
+            pub fn driver_vendor(mut self, driver_vendor: impl Into<String>) -> Self {
+                self.driver_vendor = Some(driver_vendor.into());
+                self
+            }
+            pub fn driver_version(mut self, driver_version: impl Into<String>) -> Self {
+                self.driver_version = Some(driver_version.into());
+                self
+            }
+            pub fn build(self) -> Result<GpuDevice, String> {
+                Ok(GpuDevice {
+                    vendor_id: self.vendor_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(vendor_id))
+                    })?,
+                    device_id: self.device_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(device_id))
+                    })?,
+                    sub_sys_id: self.sub_sys_id,
+                    revision: self.revision,
+                    vendor_string: self.vendor_string.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(vendor_string))
+                    })?,
+                    device_string: self.device_string.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(device_string))
+                    })?,
+                    driver_vendor: self.driver_vendor.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(driver_vendor))
+                    })?,
+                    driver_version: self.driver_version.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(driver_version))
+                    })?,
+                })
+            }
+        }
+        impl GpuDevice {
+            pub const IDENTIFIER: &'static str = "SystemInfo.GPUDevice";
+        }
+        #[doc = "Describes the width and height dimensions of an entity.\n[Size](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#type-Size)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Size {
+            #[doc = "Width in pixels."]
+            #[serde(rename = "width")]
+            pub width: i64,
+            #[doc = "Height in pixels."]
+            #[serde(rename = "height")]
+            pub height: i64,
+        }
+        impl Size {
+            pub fn new(width: impl Into<i64>, height: impl Into<i64>) -> Self {
+                Self {
+                    width: width.into(),
+                    height: height.into(),
+                }
+            }
+        }
+        impl Size {
+            pub fn builder() -> SizeBuilder {
+                SizeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SizeBuilder {
+            width: Option<i64>,
+            height: Option<i64>,
+        }
+        impl SizeBuilder {
+            pub fn width(mut self, width: impl Into<i64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<i64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn build(self) -> Result<Size, String> {
+                Ok(Size {
+                    width: self.width.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(width))
+                    })?,
+                    height: self.height.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(height))
+                    })?,
+                })
+            }
+        }
+        impl Size {
+            pub const IDENTIFIER: &'static str = "SystemInfo.Size";
+        }
+        #[doc = "Describes a supported video decoding profile with its associated minimum and\nmaximum resolutions.\n[VideoDecodeAcceleratorCapability](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#type-VideoDecodeAcceleratorCapability)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct VideoDecodeAcceleratorCapability {
+            #[doc = "Video codec profile that is supported, e.g. VP9 Profile 2."]
+            #[serde(rename = "profile")]
+            pub profile: String,
+            #[doc = "Maximum video dimensions in pixels supported for this |profile|."]
+            #[serde(rename = "maxResolution")]
+            pub max_resolution: Size,
+            #[doc = "Minimum video dimensions in pixels supported for this |profile|."]
+            #[serde(rename = "minResolution")]
+            pub min_resolution: Size,
+        }
+        impl VideoDecodeAcceleratorCapability {
+            pub fn new(
+                profile: impl Into<String>,
+                max_resolution: impl Into<Size>,
+                min_resolution: impl Into<Size>,
+            ) -> Self {
+                Self {
+                    profile: profile.into(),
+                    max_resolution: max_resolution.into(),
+                    min_resolution: min_resolution.into(),
+                }
+            }
+        }
+        impl VideoDecodeAcceleratorCapability {
+            pub fn builder() -> VideoDecodeAcceleratorCapabilityBuilder {
+                VideoDecodeAcceleratorCapabilityBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct VideoDecodeAcceleratorCapabilityBuilder {
+            profile: Option<String>,
+            max_resolution: Option<Size>,
+            min_resolution: Option<Size>,
+        }
+        impl VideoDecodeAcceleratorCapabilityBuilder {
+            pub fn profile(mut self, profile: impl Into<String>) -> Self {
+                self.profile = Some(profile.into());
+                self
+            }
+            pub fn max_resolution(mut self, max_resolution: impl Into<Size>) -> Self {
+                self.max_resolution = Some(max_resolution.into());
+                self
+            }
+            pub fn min_resolution(mut self, min_resolution: impl Into<Size>) -> Self {
+                self.min_resolution = Some(min_resolution.into());
+                self
+            }
+            pub fn build(self) -> Result<VideoDecodeAcceleratorCapability, String> {
+                Ok(VideoDecodeAcceleratorCapability {
+                    profile: self.profile.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(profile))
+                    })?,
+                    max_resolution: self.max_resolution.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(max_resolution))
+                    })?,
+                    min_resolution: self.min_resolution.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(min_resolution))
+                    })?,
+                })
+            }
+        }
+        impl VideoDecodeAcceleratorCapability {
+            pub const IDENTIFIER: &'static str = "SystemInfo.VideoDecodeAcceleratorCapability";
+        }
+        #[doc = "Describes a supported video encoding profile with its associated maximum\nresolution and maximum framerate.\n[VideoEncodeAcceleratorCapability](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#type-VideoEncodeAcceleratorCapability)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct VideoEncodeAcceleratorCapability {
+            #[doc = "Video codec profile that is supported, e.g H264 Main."]
+            #[serde(rename = "profile")]
+            pub profile: String,
+            #[doc = "Maximum video dimensions in pixels supported for this |profile|."]
+            #[serde(rename = "maxResolution")]
+            pub max_resolution: Size,
+            #[doc = "Maximum encoding framerate in frames per second supported for this\n|profile|, as fraction's numerator and denominator, e.g. 24/1 fps,\n24000/1001 fps, etc."]
+            #[serde(rename = "maxFramerateNumerator")]
+            pub max_framerate_numerator: i64,
+            #[serde(rename = "maxFramerateDenominator")]
+            pub max_framerate_denominator: i64,
+        }
+        impl VideoEncodeAcceleratorCapability {
+            pub fn new(
+                profile: impl Into<String>,
+                max_resolution: impl Into<Size>,
+                max_framerate_numerator: impl Into<i64>,
+                max_framerate_denominator: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    profile: profile.into(),
+                    max_resolution: max_resolution.into(),
+                    max_framerate_numerator: max_framerate_numerator.into(),
+                    max_framerate_denominator: max_framerate_denominator.into(),
+                }
+            }
+        }
+        impl VideoEncodeAcceleratorCapability {
+            pub fn builder() -> VideoEncodeAcceleratorCapabilityBuilder {
+                VideoEncodeAcceleratorCapabilityBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct VideoEncodeAcceleratorCapabilityBuilder {
+            profile: Option<String>,
+            max_resolution: Option<Size>,
+            max_framerate_numerator: Option<i64>,
+            max_framerate_denominator: Option<i64>,
+        }
+        impl VideoEncodeAcceleratorCapabilityBuilder {
+            pub fn profile(mut self, profile: impl Into<String>) -> Self {
+                self.profile = Some(profile.into());
+                self
+            }
+            pub fn max_resolution(mut self, max_resolution: impl Into<Size>) -> Self {
+                self.max_resolution = Some(max_resolution.into());
+                self
+            }
+            pub fn max_framerate_numerator(
+                mut self,
+                max_framerate_numerator: impl Into<i64>,
+            ) -> Self {
+                self.max_framerate_numerator = Some(max_framerate_numerator.into());
+                self
+            }
+            pub fn max_framerate_denominator(
+                mut self,
+                max_framerate_denominator: impl Into<i64>,
+            ) -> Self {
+                self.max_framerate_denominator = Some(max_framerate_denominator.into());
+                self
+            }
+            pub fn build(self) -> Result<VideoEncodeAcceleratorCapability, String> {
+                Ok(VideoEncodeAcceleratorCapability {
+                    profile: self.profile.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(profile))
+                    })?,
+                    max_resolution: self.max_resolution.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(max_resolution))
+                    })?,
+                    max_framerate_numerator: self.max_framerate_numerator.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(max_framerate_numerator)
+                        )
+                    })?,
+                    max_framerate_denominator: self.max_framerate_denominator.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(max_framerate_denominator)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl VideoEncodeAcceleratorCapability {
+            pub const IDENTIFIER: &'static str = "SystemInfo.VideoEncodeAcceleratorCapability";
+        }
+        #[doc = "YUV subsampling type of the pixels of a given image."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum SubsamplingFormat {
+            #[serde(rename = "yuv420")]
+            Yuv420,
+            #[serde(rename = "yuv422")]
+            Yuv422,
+            #[serde(rename = "yuv444")]
+            Yuv444,
+        }
+        impl AsRef<str> for SubsamplingFormat {
+            fn as_ref(&self) -> &str {
+                match self {
+                    SubsamplingFormat::Yuv420 => "yuv420",
+                    SubsamplingFormat::Yuv422 => "yuv422",
+                    SubsamplingFormat::Yuv444 => "yuv444",
+                }
+            }
+        }
+        impl ::std::str::FromStr for SubsamplingFormat {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "yuv420" | "Yuv420" => Ok(SubsamplingFormat::Yuv420),
+                    "yuv422" | "Yuv422" => Ok(SubsamplingFormat::Yuv422),
+                    "yuv444" | "Yuv444" => Ok(SubsamplingFormat::Yuv444),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Image format of a given image."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ImageType {
+            #[serde(rename = "jpeg")]
+            Jpeg,
+            #[serde(rename = "webp")]
+            Webp,
+            #[serde(rename = "unknown")]
+            Unknown,
+        }
+        impl AsRef<str> for ImageType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ImageType::Jpeg => "jpeg",
+                    ImageType::Webp => "webp",
+                    ImageType::Unknown => "unknown",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ImageType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "jpeg" | "Jpeg" => Ok(ImageType::Jpeg),
+                    "webp" | "Webp" => Ok(ImageType::Webp),
+                    "unknown" | "Unknown" => Ok(ImageType::Unknown),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Provides information about the GPU(s) on the system.\n[GPUInfo](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#type-GPUInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GpuInfo {
+            #[doc = "The graphics devices on the system. Element 0 is the primary GPU."]
+            #[serde(rename = "devices")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub devices: Vec<GpuDevice>,
+            #[doc = "An optional dictionary of additional GPU related attributes."]
+            #[serde(rename = "auxAttributes")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub aux_attributes: Option<serde_json::Value>,
+            #[doc = "An optional dictionary of graphics features and their status."]
+            #[serde(rename = "featureStatus")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub feature_status: Option<serde_json::Value>,
+            #[doc = "An optional array of GPU driver bug workarounds."]
+            #[serde(rename = "driverBugWorkarounds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub driver_bug_workarounds: Vec<String>,
+            #[doc = "Supported accelerated video decoding capabilities."]
+            #[serde(rename = "videoDecoding")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub video_decoding: Vec<VideoDecodeAcceleratorCapability>,
+            #[doc = "Supported accelerated video encoding capabilities."]
+            #[serde(rename = "videoEncoding")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub video_encoding: Vec<VideoEncodeAcceleratorCapability>,
+        }
+        impl GpuInfo {
+            pub fn new(
+                devices: Vec<GpuDevice>,
+                driver_bug_workarounds: Vec<String>,
+                video_decoding: Vec<VideoDecodeAcceleratorCapability>,
+                video_encoding: Vec<VideoEncodeAcceleratorCapability>,
+            ) -> Self {
+                Self {
+                    devices,
+                    driver_bug_workarounds,
+                    video_decoding,
+                    video_encoding,
+                    aux_attributes: None,
+                    feature_status: None,
+                }
+            }
+        }
+        impl GpuInfo {
+            pub fn builder() -> GpuInfoBuilder {
+                GpuInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GpuInfoBuilder {
+            devices: Option<Vec<GpuDevice>>,
+            aux_attributes: Option<serde_json::Value>,
+            feature_status: Option<serde_json::Value>,
+            driver_bug_workarounds: Option<Vec<String>>,
+            video_decoding: Option<Vec<VideoDecodeAcceleratorCapability>>,
+            video_encoding: Option<Vec<VideoEncodeAcceleratorCapability>>,
+        }
+        impl GpuInfoBuilder {
+            pub fn device(mut self, device: impl Into<GpuDevice>) -> Self {
+                let v = self.devices.get_or_insert(Vec::new());
+                v.push(device.into());
+                self
+            }
+            pub fn devices<I, S>(mut self, devices: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<GpuDevice>,
+            {
+                let v = self.devices.get_or_insert(Vec::new());
+                for val in devices {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn aux_attributes(mut self, aux_attributes: impl Into<serde_json::Value>) -> Self {
+                self.aux_attributes = Some(aux_attributes.into());
+                self
+            }
+            pub fn feature_status(mut self, feature_status: impl Into<serde_json::Value>) -> Self {
+                self.feature_status = Some(feature_status.into());
+                self
+            }
+            pub fn driver_bug_workaround(
+                mut self,
+                driver_bug_workaround: impl Into<String>,
+            ) -> Self {
+                let v = self.driver_bug_workarounds.get_or_insert(Vec::new());
+                v.push(driver_bug_workaround.into());
+                self
+            }
+            pub fn driver_bug_workarounds<I, S>(mut self, driver_bug_workarounds: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.driver_bug_workarounds.get_or_insert(Vec::new());
+                for val in driver_bug_workarounds {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn video_decoding(
+                mut self,
+                video_decoding: impl Into<VideoDecodeAcceleratorCapability>,
+            ) -> Self {
+                let v = self.video_decoding.get_or_insert(Vec::new());
+                v.push(video_decoding.into());
+                self
+            }
+            pub fn video_decodings<I, S>(mut self, video_decodings: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<VideoDecodeAcceleratorCapability>,
+            {
+                let v = self.video_decoding.get_or_insert(Vec::new());
+                for val in video_decodings {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn video_encoding(
+                mut self,
+                video_encoding: impl Into<VideoEncodeAcceleratorCapability>,
+            ) -> Self {
+                let v = self.video_encoding.get_or_insert(Vec::new());
+                v.push(video_encoding.into());
+                self
+            }
+            pub fn video_encodings<I, S>(mut self, video_encodings: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<VideoEncodeAcceleratorCapability>,
+            {
+                let v = self.video_encoding.get_or_insert(Vec::new());
+                for val in video_encodings {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GpuInfo, String> {
+                Ok(GpuInfo {
+                    devices: self.devices.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(devices))
+                    })?,
+                    aux_attributes: self.aux_attributes,
+                    feature_status: self.feature_status,
+                    driver_bug_workarounds: self.driver_bug_workarounds.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(driver_bug_workarounds)
+                        )
+                    })?,
+                    video_decoding: self.video_decoding.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(video_decoding))
+                    })?,
+                    video_encoding: self.video_encoding.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(video_encoding))
+                    })?,
+                })
+            }
+        }
+        impl GpuInfo {
+            pub const IDENTIFIER: &'static str = "SystemInfo.GPUInfo";
+        }
+        #[doc = "Represents process info.\n[ProcessInfo](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#type-ProcessInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ProcessInfo {
+            #[doc = "Specifies process type."]
+            #[serde(rename = "type")]
+            pub r#type: String,
+            #[doc = "Specifies process id."]
+            #[serde(rename = "id")]
+            pub id: i64,
+            #[doc = "Specifies cumulative CPU usage in seconds across all threads of the\nprocess since the process start."]
+            #[serde(rename = "cpuTime")]
+            pub cpu_time: f64,
+        }
+        impl ProcessInfo {
+            pub fn new(
+                r#type: impl Into<String>,
+                id: impl Into<i64>,
+                cpu_time: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    r#type: r#type.into(),
+                    id: id.into(),
+                    cpu_time: cpu_time.into(),
+                }
+            }
+        }
+        impl ProcessInfo {
+            pub fn builder() -> ProcessInfoBuilder {
+                ProcessInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ProcessInfoBuilder {
+            r#type: Option<String>,
+            id: Option<i64>,
+            cpu_time: Option<f64>,
+        }
+        impl ProcessInfoBuilder {
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn id(mut self, id: impl Into<i64>) -> Self {
+                self.id = Some(id.into());
+                self
+            }
+            pub fn cpu_time(mut self, cpu_time: impl Into<f64>) -> Self {
+                self.cpu_time = Some(cpu_time.into());
+                self
+            }
+            pub fn build(self) -> Result<ProcessInfo, String> {
+                Ok(ProcessInfo {
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    id: self
+                        .id
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(id)))?,
+                    cpu_time: self.cpu_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(cpu_time))
+                    })?,
+                })
+            }
+        }
+        impl ProcessInfo {
+            pub const IDENTIFIER: &'static str = "SystemInfo.ProcessInfo";
+        }
+        #[doc = "Returns information about the system.\n[getInfo](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#method-getInfo)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetInfoParams {}
+        impl GetInfoParams {
+            pub const IDENTIFIER: &'static str = "SystemInfo.getInfo";
+        }
+        impl chromiumoxide_types::Method for GetInfoParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetInfoParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns information about the system.\n[getInfo](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#method-getInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetInfoReturns {
+            #[doc = "Information about the GPUs on the system."]
+            #[serde(rename = "gpu")]
+            pub gpu: GpuInfo,
+            #[doc = "A platform-dependent description of the model of the machine. On Mac OS, this is, for\nexample, 'MacBookPro'. Will be the empty string if not supported."]
+            #[serde(rename = "modelName")]
+            pub model_name: String,
+            #[doc = "A platform-dependent description of the version of the machine. On Mac OS, this is, for\nexample, '10.1'. Will be the empty string if not supported."]
+            #[serde(rename = "modelVersion")]
+            pub model_version: String,
+            #[doc = "The command line string used to launch the browser. Will be the empty string if not\nsupported."]
+            #[serde(rename = "commandLine")]
+            pub command_line: String,
+        }
+        impl GetInfoReturns {
+            pub fn new(
+                gpu: impl Into<GpuInfo>,
+                model_name: impl Into<String>,
+                model_version: impl Into<String>,
+                command_line: impl Into<String>,
+            ) -> Self {
+                Self {
+                    gpu: gpu.into(),
+                    model_name: model_name.into(),
+                    model_version: model_version.into(),
+                    command_line: command_line.into(),
+                }
+            }
+        }
+        impl GetInfoReturns {
+            pub fn builder() -> GetInfoReturnsBuilder {
+                GetInfoReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetInfoReturnsBuilder {
+            gpu: Option<GpuInfo>,
+            model_name: Option<String>,
+            model_version: Option<String>,
+            command_line: Option<String>,
+        }
+        impl GetInfoReturnsBuilder {
+            pub fn gpu(mut self, gpu: impl Into<GpuInfo>) -> Self {
+                self.gpu = Some(gpu.into());
+                self
+            }
+            pub fn model_name(mut self, model_name: impl Into<String>) -> Self {
+                self.model_name = Some(model_name.into());
+                self
+            }
+            pub fn model_version(mut self, model_version: impl Into<String>) -> Self {
+                self.model_version = Some(model_version.into());
+                self
+            }
+            pub fn command_line(mut self, command_line: impl Into<String>) -> Self {
+                self.command_line = Some(command_line.into());
+                self
+            }
+            pub fn build(self) -> Result<GetInfoReturns, String> {
+                Ok(GetInfoReturns {
+                    gpu: self
+                        .gpu
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(gpu)))?,
+                    model_name: self.model_name.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(model_name))
+                    })?,
+                    model_version: self.model_version.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(model_version))
+                    })?,
+                    command_line: self.command_line.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(command_line))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetInfoParams {
+            type Response = GetInfoReturns;
+        }
+        #[doc = "Returns information about the feature state.\n[getFeatureState](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#method-getFeatureState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetFeatureStateParams {
+            #[serde(rename = "featureState")]
+            pub feature_state: String,
+        }
+        impl GetFeatureStateParams {
+            pub fn new(feature_state: impl Into<String>) -> Self {
+                Self {
+                    feature_state: feature_state.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for GetFeatureStateParams {
+            fn from(url: T) -> Self {
+                GetFeatureStateParams::new(url)
+            }
+        }
+        impl GetFeatureStateParams {
+            pub fn builder() -> GetFeatureStateParamsBuilder {
+                GetFeatureStateParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetFeatureStateParamsBuilder {
+            feature_state: Option<String>,
+        }
+        impl GetFeatureStateParamsBuilder {
+            pub fn feature_state(mut self, feature_state: impl Into<String>) -> Self {
+                self.feature_state = Some(feature_state.into());
+                self
+            }
+            pub fn build(self) -> Result<GetFeatureStateParams, String> {
+                Ok(GetFeatureStateParams {
+                    feature_state: self.feature_state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(feature_state))
+                    })?,
+                })
+            }
+        }
+        impl GetFeatureStateParams {
+            pub const IDENTIFIER: &'static str = "SystemInfo.getFeatureState";
+        }
+        impl chromiumoxide_types::Method for GetFeatureStateParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetFeatureStateParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns information about the feature state.\n[getFeatureState](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#method-getFeatureState)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetFeatureStateReturns {
+            #[serde(rename = "featureEnabled")]
+            pub feature_enabled: bool,
+        }
+        impl GetFeatureStateReturns {
+            pub fn new(feature_enabled: impl Into<bool>) -> Self {
+                Self {
+                    feature_enabled: feature_enabled.into(),
+                }
+            }
+        }
+        impl GetFeatureStateReturns {
+            pub fn builder() -> GetFeatureStateReturnsBuilder {
+                GetFeatureStateReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetFeatureStateReturnsBuilder {
+            feature_enabled: Option<bool>,
+        }
+        impl GetFeatureStateReturnsBuilder {
+            pub fn feature_enabled(mut self, feature_enabled: impl Into<bool>) -> Self {
+                self.feature_enabled = Some(feature_enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<GetFeatureStateReturns, String> {
+                Ok(GetFeatureStateReturns {
+                    feature_enabled: self.feature_enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(feature_enabled))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetFeatureStateParams {
+            type Response = GetFeatureStateReturns;
+        }
+        #[doc = "Returns information about all running processes.\n[getProcessInfo](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#method-getProcessInfo)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetProcessInfoParams {}
+        impl GetProcessInfoParams {
+            pub const IDENTIFIER: &'static str = "SystemInfo.getProcessInfo";
+        }
+        impl chromiumoxide_types::Method for GetProcessInfoParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetProcessInfoParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns information about all running processes.\n[getProcessInfo](https://chromedevtools.github.io/devtools-protocol/tot/SystemInfo/#method-getProcessInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetProcessInfoReturns {
+            #[doc = "An array of process info blocks."]
+            #[serde(rename = "processInfo")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub process_info: Vec<ProcessInfo>,
+        }
+        impl GetProcessInfoReturns {
+            pub fn new(process_info: Vec<ProcessInfo>) -> Self {
+                Self { process_info }
+            }
+        }
+        impl GetProcessInfoReturns {
+            pub fn builder() -> GetProcessInfoReturnsBuilder {
+                GetProcessInfoReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetProcessInfoReturnsBuilder {
+            process_info: Option<Vec<ProcessInfo>>,
+        }
+        impl GetProcessInfoReturnsBuilder {
+            pub fn process_info(mut self, process_info: impl Into<ProcessInfo>) -> Self {
+                let v = self.process_info.get_or_insert(Vec::new());
+                v.push(process_info.into());
+                self
+            }
+            pub fn process_infos<I, S>(mut self, process_infos: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<ProcessInfo>,
+            {
+                let v = self.process_info.get_or_insert(Vec::new());
+                for val in process_infos {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetProcessInfoReturns, String> {
+                Ok(GetProcessInfoReturns {
+                    process_info: self.process_info.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(process_info))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetProcessInfoParams {
+            type Response = GetProcessInfoReturns;
+        }
+    }
+    #[doc = "Supports additional targets discovery and allows to attach to them."]
+    pub mod target {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct TargetId(String);
+        impl TargetId {
+            pub fn new(val: impl Into<String>) -> Self {
+                TargetId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for TargetId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<TargetId> for String {
+            fn from(el: TargetId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for TargetId {
+            fn from(expr: String) -> Self {
+                TargetId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for TargetId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl TargetId {
+            pub const IDENTIFIER: &'static str = "Target.TargetID";
+        }
+        #[doc = "Unique identifier of attached debugging session.\n[SessionID](https://chromedevtools.github.io/devtools-protocol/tot/Target/#type-SessionID)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct SessionId(String);
+        impl SessionId {
+            pub fn new(val: impl Into<String>) -> Self {
+                SessionId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for SessionId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<SessionId> for String {
+            fn from(el: SessionId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for SessionId {
+            fn from(expr: String) -> Self {
+                SessionId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for SessionId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl SessionId {
+            pub const IDENTIFIER: &'static str = "Target.SessionID";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct TargetInfo {
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+            #[doc = "List of types: https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/devtools_agent_host_impl.cc?ss=chromium&q=f:devtools%20-f:out%20%22::kTypeTab%5B%5D%22"]
+            #[serde(rename = "type")]
+            pub r#type: String,
+            #[serde(rename = "title")]
+            pub title: String,
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Whether the target has an attached client."]
+            #[serde(rename = "attached")]
+            pub attached: bool,
+            #[doc = "Opener target Id"]
+            #[serde(rename = "openerId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub opener_id: Option<TargetId>,
+            #[doc = "Whether the target has access to the originating window."]
+            #[serde(rename = "canAccessOpener")]
+            pub can_access_opener: bool,
+            #[doc = "Frame id of originating window (is only set if target has an opener)."]
+            #[serde(rename = "openerFrameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub opener_frame_id: Option<super::page::FrameId>,
+            #[doc = "Id of the parent frame, only present for the \"iframe\" targets."]
+            #[serde(rename = "parentFrameId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub parent_frame_id: Option<super::page::FrameId>,
+            #[serde(rename = "browserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub browser_context_id: Option<super::browser::BrowserContextId>,
+            #[doc = "Provides additional details for specific target types. For example, for\nthe type of \"page\", this may be set to \"prerender\"."]
+            #[serde(rename = "subtype")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub subtype: Option<String>,
+        }
+        impl TargetInfo {
+            pub fn builder() -> TargetInfoBuilder {
+                TargetInfoBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TargetInfoBuilder {
+            target_id: Option<TargetId>,
+            r#type: Option<String>,
+            title: Option<String>,
+            url: Option<String>,
+            attached: Option<bool>,
+            opener_id: Option<TargetId>,
+            can_access_opener: Option<bool>,
+            opener_frame_id: Option<super::page::FrameId>,
+            parent_frame_id: Option<super::page::FrameId>,
+            browser_context_id: Option<super::browser::BrowserContextId>,
+            subtype: Option<String>,
+        }
+        impl TargetInfoBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn title(mut self, title: impl Into<String>) -> Self {
+                self.title = Some(title.into());
+                self
+            }
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn attached(mut self, attached: impl Into<bool>) -> Self {
+                self.attached = Some(attached.into());
+                self
+            }
+            pub fn opener_id(mut self, opener_id: impl Into<TargetId>) -> Self {
+                self.opener_id = Some(opener_id.into());
+                self
+            }
+            pub fn can_access_opener(mut self, can_access_opener: impl Into<bool>) -> Self {
+                self.can_access_opener = Some(can_access_opener.into());
+                self
+            }
+            pub fn opener_frame_id(
+                mut self,
+                opener_frame_id: impl Into<super::page::FrameId>,
+            ) -> Self {
+                self.opener_frame_id = Some(opener_frame_id.into());
+                self
+            }
+            pub fn parent_frame_id(
+                mut self,
+                parent_frame_id: impl Into<super::page::FrameId>,
+            ) -> Self {
+                self.parent_frame_id = Some(parent_frame_id.into());
+                self
+            }
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<super::browser::BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn subtype(mut self, subtype: impl Into<String>) -> Self {
+                self.subtype = Some(subtype.into());
+                self
+            }
+            pub fn build(self) -> Result<TargetInfo, String> {
+                Ok(TargetInfo {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                    r#type: self.r#type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(r#type))
+                    })?,
+                    title: self.title.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(title))
+                    })?,
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    attached: self.attached.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(attached))
+                    })?,
+                    opener_id: self.opener_id,
+                    can_access_opener: self.can_access_opener.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(can_access_opener)
+                        )
+                    })?,
+                    opener_frame_id: self.opener_frame_id,
+                    parent_frame_id: self.parent_frame_id,
+                    browser_context_id: self.browser_context_id,
+                    subtype: self.subtype,
+                })
+            }
+        }
+        impl TargetInfo {
+            pub const IDENTIFIER: &'static str = "Target.TargetInfo";
+        }
+        #[doc = "A filter used by target query/discovery/auto-attach operations.\n[FilterEntry](https://chromedevtools.github.io/devtools-protocol/tot/Target/#type-FilterEntry)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct FilterEntry {
+            #[doc = "If set, causes exclusion of matching targets from the list."]
+            #[serde(rename = "exclude")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub exclude: Option<bool>,
+            #[doc = "If not present, matches any type."]
+            #[serde(rename = "type")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub r#type: Option<String>,
+        }
+        impl FilterEntry {
+            pub fn builder() -> FilterEntryBuilder {
+                FilterEntryBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct FilterEntryBuilder {
+            exclude: Option<bool>,
+            r#type: Option<String>,
+        }
+        impl FilterEntryBuilder {
+            pub fn exclude(mut self, exclude: impl Into<bool>) -> Self {
+                self.exclude = Some(exclude.into());
+                self
+            }
+            pub fn r#type(mut self, r#type: impl Into<String>) -> Self {
+                self.r#type = Some(r#type.into());
+                self
+            }
+            pub fn build(self) -> FilterEntry {
+                FilterEntry {
+                    exclude: self.exclude,
+                    r#type: self.r#type,
+                }
+            }
+        }
+        impl FilterEntry {
+            pub const IDENTIFIER: &'static str = "Target.FilterEntry";
+        }
+        #[doc = "The entries in TargetFilter are matched sequentially against targets and\nthe first entry that matches determines if the target is included or not,\ndepending on the value of `exclude` field in the entry.\nIf filter is not specified, the one assumed is\n[{type: \"browser\", exclude: true}, {type: \"tab\", exclude: true}, {}]\n(i.e. include everything but `browser` and `tab`).\n[TargetFilter](https://chromedevtools.github.io/devtools-protocol/tot/Target/#type-TargetFilter)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TargetFilter(Vec<FilterEntry>);
+        impl TargetFilter {
+            pub fn new(val: impl Into<Vec<FilterEntry>>) -> Self {
+                TargetFilter(val.into())
+            }
+            pub fn inner(&self) -> &Vec<FilterEntry> {
+                &self.0
+            }
+        }
+        impl TargetFilter {
+            pub const IDENTIFIER: &'static str = "Target.TargetFilter";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoteLocation {
+            #[serde(rename = "host")]
+            pub host: String,
+            #[serde(rename = "port")]
+            pub port: i64,
+        }
+        impl RemoteLocation {
+            pub fn new(host: impl Into<String>, port: impl Into<i64>) -> Self {
+                Self {
+                    host: host.into(),
+                    port: port.into(),
+                }
+            }
+        }
+        impl RemoteLocation {
+            pub fn builder() -> RemoteLocationBuilder {
+                RemoteLocationBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoteLocationBuilder {
+            host: Option<String>,
+            port: Option<i64>,
+        }
+        impl RemoteLocationBuilder {
+            pub fn host(mut self, host: impl Into<String>) -> Self {
+                self.host = Some(host.into());
+                self
+            }
+            pub fn port(mut self, port: impl Into<i64>) -> Self {
+                self.port = Some(port.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoteLocation, String> {
+                Ok(RemoteLocation {
+                    host: self.host.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(host))
+                    })?,
+                    port: self.port.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(port))
+                    })?,
+                })
+            }
+        }
+        impl RemoteLocation {
+            pub const IDENTIFIER: &'static str = "Target.RemoteLocation";
+        }
+        #[doc = "The state of the target window."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum WindowState {
+            #[serde(rename = "normal")]
+            Normal,
+            #[serde(rename = "minimized")]
+            Minimized,
+            #[serde(rename = "maximized")]
+            Maximized,
+            #[serde(rename = "fullscreen")]
+            Fullscreen,
+        }
+        impl AsRef<str> for WindowState {
+            fn as_ref(&self) -> &str {
+                match self {
+                    WindowState::Normal => "normal",
+                    WindowState::Minimized => "minimized",
+                    WindowState::Maximized => "maximized",
+                    WindowState::Fullscreen => "fullscreen",
+                }
+            }
+        }
+        impl ::std::str::FromStr for WindowState {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "normal" | "Normal" => Ok(WindowState::Normal),
+                    "minimized" | "Minimized" => Ok(WindowState::Minimized),
+                    "maximized" | "Maximized" => Ok(WindowState::Maximized),
+                    "fullscreen" | "Fullscreen" => Ok(WindowState::Fullscreen),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Activates (focuses) the target.\n[activateTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-activateTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ActivateTargetParams {
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+        }
+        impl ActivateTargetParams {
+            pub fn new(target_id: impl Into<TargetId>) -> Self {
+                Self {
+                    target_id: target_id.into(),
+                }
+            }
+        }
+        impl ActivateTargetParams {
+            pub fn builder() -> ActivateTargetParamsBuilder {
+                ActivateTargetParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ActivateTargetParamsBuilder {
+            target_id: Option<TargetId>,
+        }
+        impl ActivateTargetParamsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ActivateTargetParams, String> {
+                Ok(ActivateTargetParams {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                })
+            }
+        }
+        impl ActivateTargetParams {
+            pub const IDENTIFIER: &'static str = "Target.activateTarget";
+        }
+        impl chromiumoxide_types::Method for ActivateTargetParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ActivateTargetParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Activates (focuses) the target.\n[activateTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-activateTarget)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ActivateTargetReturns {}
+        impl chromiumoxide_types::Command for ActivateTargetParams {
+            type Response = ActivateTargetReturns;
+        }
+        #[doc = "Attaches to the target with given id.\n[attachToTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-attachToTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttachToTargetParams {
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+            #[doc = "Enables \"flat\" access to the session via specifying sessionId attribute in the commands.\nWe plan to make this the default, deprecate non-flattened mode,\nand eventually retire it. See crbug.com/991325."]
+            #[serde(rename = "flatten")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub flatten: Option<bool>,
+        }
+        impl AttachToTargetParams {
+            pub fn new(target_id: impl Into<TargetId>) -> Self {
+                Self {
+                    target_id: target_id.into(),
+                    flatten: None,
+                }
+            }
+        }
+        impl AttachToTargetParams {
+            pub fn builder() -> AttachToTargetParamsBuilder {
+                AttachToTargetParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttachToTargetParamsBuilder {
+            target_id: Option<TargetId>,
+            flatten: Option<bool>,
+        }
+        impl AttachToTargetParamsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn flatten(mut self, flatten: impl Into<bool>) -> Self {
+                self.flatten = Some(flatten.into());
+                self
+            }
+            pub fn build(self) -> Result<AttachToTargetParams, String> {
+                Ok(AttachToTargetParams {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                    flatten: self.flatten,
+                })
+            }
+        }
+        impl AttachToTargetParams {
+            pub const IDENTIFIER: &'static str = "Target.attachToTarget";
+        }
+        impl chromiumoxide_types::Method for AttachToTargetParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AttachToTargetParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Attaches to the target with given id.\n[attachToTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-attachToTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttachToTargetReturns {
+            #[doc = "Id assigned to the session."]
+            #[serde(rename = "sessionId")]
+            pub session_id: SessionId,
+        }
+        impl AttachToTargetReturns {
+            pub fn new(session_id: impl Into<SessionId>) -> Self {
+                Self {
+                    session_id: session_id.into(),
+                }
+            }
+        }
+        impl AttachToTargetReturns {
+            pub fn builder() -> AttachToTargetReturnsBuilder {
+                AttachToTargetReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttachToTargetReturnsBuilder {
+            session_id: Option<SessionId>,
+        }
+        impl AttachToTargetReturnsBuilder {
+            pub fn session_id(mut self, session_id: impl Into<SessionId>) -> Self {
+                self.session_id = Some(session_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AttachToTargetReturns, String> {
+                Ok(AttachToTargetReturns {
+                    session_id: self.session_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(session_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for AttachToTargetParams {
+            type Response = AttachToTargetReturns;
+        }
+        #[doc = "Attaches to the browser target, only uses flat sessionId mode.\n[attachToBrowserTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-attachToBrowserTarget)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct AttachToBrowserTargetParams {}
+        impl AttachToBrowserTargetParams {
+            pub const IDENTIFIER: &'static str = "Target.attachToBrowserTarget";
+        }
+        impl chromiumoxide_types::Method for AttachToBrowserTargetParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AttachToBrowserTargetParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Attaches to the browser target, only uses flat sessionId mode.\n[attachToBrowserTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-attachToBrowserTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AttachToBrowserTargetReturns {
+            #[doc = "Id assigned to the session."]
+            #[serde(rename = "sessionId")]
+            pub session_id: SessionId,
+        }
+        impl AttachToBrowserTargetReturns {
+            pub fn new(session_id: impl Into<SessionId>) -> Self {
+                Self {
+                    session_id: session_id.into(),
+                }
+            }
+        }
+        impl AttachToBrowserTargetReturns {
+            pub fn builder() -> AttachToBrowserTargetReturnsBuilder {
+                AttachToBrowserTargetReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AttachToBrowserTargetReturnsBuilder {
+            session_id: Option<SessionId>,
+        }
+        impl AttachToBrowserTargetReturnsBuilder {
+            pub fn session_id(mut self, session_id: impl Into<SessionId>) -> Self {
+                self.session_id = Some(session_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AttachToBrowserTargetReturns, String> {
+                Ok(AttachToBrowserTargetReturns {
+                    session_id: self.session_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(session_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for AttachToBrowserTargetParams {
+            type Response = AttachToBrowserTargetReturns;
+        }
+        #[doc = "Closes the target. If the target is a page that gets closed too.\n[closeTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-closeTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CloseTargetParams {
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+        }
+        impl CloseTargetParams {
+            pub fn new(target_id: impl Into<TargetId>) -> Self {
+                Self {
+                    target_id: target_id.into(),
+                }
+            }
+        }
+        impl CloseTargetParams {
+            pub fn builder() -> CloseTargetParamsBuilder {
+                CloseTargetParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CloseTargetParamsBuilder {
+            target_id: Option<TargetId>,
+        }
+        impl CloseTargetParamsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CloseTargetParams, String> {
+                Ok(CloseTargetParams {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                })
+            }
+        }
+        impl CloseTargetParams {
+            pub const IDENTIFIER: &'static str = "Target.closeTarget";
+        }
+        impl chromiumoxide_types::Method for CloseTargetParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CloseTargetParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Closes the target. If the target is a page that gets closed too.\n[closeTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-closeTarget)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CloseTargetReturns {}
+        impl chromiumoxide_types::Command for CloseTargetParams {
+            type Response = CloseTargetReturns;
+        }
+        #[doc = "Inject object to the target's main frame that provides a communication\nchannel with browser target.\n\nInjected object will be available as `window[bindingName]`.\n\nThe object has the following API:\n- `binding.send(json)` - a method to send messages over the remote debugging protocol\n- `binding.onmessage = json => handleMessage(json)` - a callback that will be called for the protocol notifications and command responses.\n[exposeDevToolsProtocol](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-exposeDevToolsProtocol)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ExposeDevToolsProtocolParams {
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+            #[doc = "Binding name, 'cdp' if not specified."]
+            #[serde(rename = "bindingName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub binding_name: Option<String>,
+            #[doc = "If true, inherits the current root session's permissions (default: false)."]
+            #[serde(rename = "inheritPermissions")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub inherit_permissions: Option<bool>,
+        }
+        impl ExposeDevToolsProtocolParams {
+            pub fn new(target_id: impl Into<TargetId>) -> Self {
+                Self {
+                    target_id: target_id.into(),
+                    binding_name: None,
+                    inherit_permissions: None,
+                }
+            }
+        }
+        impl ExposeDevToolsProtocolParams {
+            pub fn builder() -> ExposeDevToolsProtocolParamsBuilder {
+                ExposeDevToolsProtocolParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ExposeDevToolsProtocolParamsBuilder {
+            target_id: Option<TargetId>,
+            binding_name: Option<String>,
+            inherit_permissions: Option<bool>,
+        }
+        impl ExposeDevToolsProtocolParamsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn binding_name(mut self, binding_name: impl Into<String>) -> Self {
+                self.binding_name = Some(binding_name.into());
+                self
+            }
+            pub fn inherit_permissions(mut self, inherit_permissions: impl Into<bool>) -> Self {
+                self.inherit_permissions = Some(inherit_permissions.into());
+                self
+            }
+            pub fn build(self) -> Result<ExposeDevToolsProtocolParams, String> {
+                Ok(ExposeDevToolsProtocolParams {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                    binding_name: self.binding_name,
+                    inherit_permissions: self.inherit_permissions,
+                })
+            }
+        }
+        impl ExposeDevToolsProtocolParams {
+            pub const IDENTIFIER: &'static str = "Target.exposeDevToolsProtocol";
+        }
+        impl chromiumoxide_types::Method for ExposeDevToolsProtocolParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ExposeDevToolsProtocolParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Inject object to the target's main frame that provides a communication\nchannel with browser target.\n\nInjected object will be available as `window[bindingName]`.\n\nThe object has the following API:\n- `binding.send(json)` - a method to send messages over the remote debugging protocol\n- `binding.onmessage = json => handleMessage(json)` - a callback that will be called for the protocol notifications and command responses.\n[exposeDevToolsProtocol](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-exposeDevToolsProtocol)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ExposeDevToolsProtocolReturns {}
+        impl chromiumoxide_types::Command for ExposeDevToolsProtocolParams {
+            type Response = ExposeDevToolsProtocolReturns;
+        }
+        #[doc = "Creates a new empty BrowserContext. Similar to an incognito profile but you can have more than\none.\n[createBrowserContext](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-createBrowserContext)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct CreateBrowserContextParams {
+            #[doc = "If specified, disposes this context when debugging session disconnects."]
+            #[serde(rename = "disposeOnDetach")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub dispose_on_detach: Option<bool>,
+            #[doc = "Proxy server, similar to the one passed to --proxy-server"]
+            #[serde(rename = "proxyServer")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub proxy_server: Option<String>,
+            #[doc = "Proxy bypass list, similar to the one passed to --proxy-bypass-list"]
+            #[serde(rename = "proxyBypassList")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub proxy_bypass_list: Option<String>,
+            #[doc = "An optional list of origins to grant unlimited cross-origin access to.\nParts of the URL other than those constituting origin are ignored."]
+            #[serde(rename = "originsWithUniversalNetworkAccess")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub origins_with_universal_network_access: Option<Vec<String>>,
+        }
+        impl CreateBrowserContextParams {
+            pub fn builder() -> CreateBrowserContextParamsBuilder {
+                CreateBrowserContextParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CreateBrowserContextParamsBuilder {
+            dispose_on_detach: Option<bool>,
+            proxy_server: Option<String>,
+            proxy_bypass_list: Option<String>,
+            origins_with_universal_network_access: Option<Vec<String>>,
+        }
+        impl CreateBrowserContextParamsBuilder {
+            pub fn dispose_on_detach(mut self, dispose_on_detach: impl Into<bool>) -> Self {
+                self.dispose_on_detach = Some(dispose_on_detach.into());
+                self
+            }
+            pub fn proxy_server(mut self, proxy_server: impl Into<String>) -> Self {
+                self.proxy_server = Some(proxy_server.into());
+                self
+            }
+            pub fn proxy_bypass_list(mut self, proxy_bypass_list: impl Into<String>) -> Self {
+                self.proxy_bypass_list = Some(proxy_bypass_list.into());
+                self
+            }
+            pub fn origins_with_universal_network_acces(
+                mut self,
+                origins_with_universal_network_acces: impl Into<String>,
+            ) -> Self {
+                let v = self
+                    .origins_with_universal_network_access
+                    .get_or_insert(Vec::new());
+                v.push(origins_with_universal_network_acces.into());
+                self
+            }
+            pub fn origins_with_universal_network_access<I, S>(
+                mut self,
+                origins_with_universal_network_access: I,
+            ) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self
+                    .origins_with_universal_network_access
+                    .get_or_insert(Vec::new());
+                for val in origins_with_universal_network_access {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> CreateBrowserContextParams {
+                CreateBrowserContextParams {
+                    dispose_on_detach: self.dispose_on_detach,
+                    proxy_server: self.proxy_server,
+                    proxy_bypass_list: self.proxy_bypass_list,
+                    origins_with_universal_network_access: self
+                        .origins_with_universal_network_access,
+                }
+            }
+        }
+        impl CreateBrowserContextParams {
+            pub const IDENTIFIER: &'static str = "Target.createBrowserContext";
+        }
+        impl chromiumoxide_types::Method for CreateBrowserContextParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CreateBrowserContextParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Creates a new empty BrowserContext. Similar to an incognito profile but you can have more than\none.\n[createBrowserContext](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-createBrowserContext)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CreateBrowserContextReturns {
+            #[doc = "The id of the context created."]
+            #[serde(rename = "browserContextId")]
+            pub browser_context_id: super::browser::BrowserContextId,
+        }
+        impl CreateBrowserContextReturns {
+            pub fn new(browser_context_id: impl Into<super::browser::BrowserContextId>) -> Self {
+                Self {
+                    browser_context_id: browser_context_id.into(),
+                }
+            }
+        }
+        impl CreateBrowserContextReturns {
+            pub fn builder() -> CreateBrowserContextReturnsBuilder {
+                CreateBrowserContextReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CreateBrowserContextReturnsBuilder {
+            browser_context_id: Option<super::browser::BrowserContextId>,
+        }
+        impl CreateBrowserContextReturnsBuilder {
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<super::browser::BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CreateBrowserContextReturns, String> {
+                Ok(CreateBrowserContextReturns {
+                    browser_context_id: self.browser_context_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(browser_context_id)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CreateBrowserContextParams {
+            type Response = CreateBrowserContextReturns;
+        }
+        #[doc = "Returns all browser contexts created with `Target.createBrowserContext` method.\n[getBrowserContexts](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-getBrowserContexts)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetBrowserContextsParams {}
+        impl GetBrowserContextsParams {
+            pub const IDENTIFIER: &'static str = "Target.getBrowserContexts";
+        }
+        impl chromiumoxide_types::Method for GetBrowserContextsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetBrowserContextsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns all browser contexts created with `Target.createBrowserContext` method.\n[getBrowserContexts](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-getBrowserContexts)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetBrowserContextsReturns {
+            #[doc = "An array of browser context ids."]
+            #[serde(rename = "browserContextIds")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub browser_context_ids: Vec<super::browser::BrowserContextId>,
+            #[doc = "The id of the default browser context if available."]
+            #[serde(rename = "defaultBrowserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub default_browser_context_id: Option<super::browser::BrowserContextId>,
+        }
+        impl GetBrowserContextsReturns {
+            pub fn new(browser_context_ids: Vec<super::browser::BrowserContextId>) -> Self {
+                Self {
+                    browser_context_ids,
+                    default_browser_context_id: None,
+                }
+            }
+        }
+        impl GetBrowserContextsReturns {
+            pub fn builder() -> GetBrowserContextsReturnsBuilder {
+                GetBrowserContextsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetBrowserContextsReturnsBuilder {
+            browser_context_ids: Option<Vec<super::browser::BrowserContextId>>,
+            default_browser_context_id: Option<super::browser::BrowserContextId>,
+        }
+        impl GetBrowserContextsReturnsBuilder {
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<super::browser::BrowserContextId>,
+            ) -> Self {
+                let v = self.browser_context_ids.get_or_insert(Vec::new());
+                v.push(browser_context_id.into());
+                self
+            }
+            pub fn browser_context_ids<I, S>(mut self, browser_context_ids: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<super::browser::BrowserContextId>,
+            {
+                let v = self.browser_context_ids.get_or_insert(Vec::new());
+                for val in browser_context_ids {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn default_browser_context_id(
+                mut self,
+                default_browser_context_id: impl Into<super::browser::BrowserContextId>,
+            ) -> Self {
+                self.default_browser_context_id = Some(default_browser_context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetBrowserContextsReturns, String> {
+                Ok(GetBrowserContextsReturns {
+                    browser_context_ids: self.browser_context_ids.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(browser_context_ids)
+                        )
+                    })?,
+                    default_browser_context_id: self.default_browser_context_id,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetBrowserContextsParams {
+            type Response = GetBrowserContextsReturns;
+        }
+        #[doc = "Creates a new page.\n[createTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-createTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CreateTargetParams {
+            #[doc = "The initial URL the page will be navigated to. An empty string indicates about:blank."]
+            #[serde(rename = "url")]
+            pub url: String,
+            #[doc = "Frame left origin in DIP (requires newWindow to be true or headless shell)."]
+            #[serde(rename = "left")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub left: Option<i64>,
+            #[doc = "Frame top origin in DIP (requires newWindow to be true or headless shell)."]
+            #[serde(rename = "top")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub top: Option<i64>,
+            #[doc = "Frame width in DIP (requires newWindow to be true or headless shell)."]
+            #[serde(rename = "width")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub width: Option<i64>,
+            #[doc = "Frame height in DIP (requires newWindow to be true or headless shell)."]
+            #[serde(rename = "height")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub height: Option<i64>,
+            #[doc = "Frame window state (requires newWindow to be true or headless shell).\nDefault is normal."]
+            #[serde(rename = "windowState")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub window_state: Option<WindowState>,
+            #[doc = "The browser context to create the page in."]
+            #[serde(rename = "browserContextId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub browser_context_id: Option<super::browser::BrowserContextId>,
+            #[doc = "Whether BeginFrames for this target will be controlled via DevTools (headless shell only,\nnot supported on MacOS yet, false by default)."]
+            #[serde(rename = "enableBeginFrameControl")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub enable_begin_frame_control: Option<bool>,
+            #[doc = "Whether to create a new Window or Tab (false by default, not supported by headless shell)."]
+            #[serde(rename = "newWindow")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub new_window: Option<bool>,
+            #[doc = "Whether to create the target in background or foreground (false by default, not supported\nby headless shell)."]
+            #[serde(rename = "background")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub background: Option<bool>,
+            #[doc = "Whether to create the target of type \"tab\"."]
+            #[serde(rename = "forTab")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub for_tab: Option<bool>,
+            #[doc = "Whether to create a hidden target. The hidden target is observable via protocol, but not\npresent in the tab UI strip. Cannot be created with `forTab: true`, `newWindow: true` or\n`background: false`. The life-time of the tab is limited to the life-time of the session."]
+            #[serde(rename = "hidden")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub hidden: Option<bool>,
+        }
+        impl CreateTargetParams {
+            pub fn new(url: impl Into<String>) -> Self {
+                Self {
+                    url: url.into(),
+                    left: None,
+                    top: None,
+                    width: None,
+                    height: None,
+                    window_state: None,
+                    browser_context_id: None,
+                    enable_begin_frame_control: None,
+                    new_window: None,
+                    background: None,
+                    for_tab: None,
+                    hidden: None,
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for CreateTargetParams {
+            fn from(url: T) -> Self {
+                CreateTargetParams::new(url)
+            }
+        }
+        impl CreateTargetParams {
+            pub fn builder() -> CreateTargetParamsBuilder {
+                CreateTargetParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CreateTargetParamsBuilder {
+            url: Option<String>,
+            left: Option<i64>,
+            top: Option<i64>,
+            width: Option<i64>,
+            height: Option<i64>,
+            window_state: Option<WindowState>,
+            browser_context_id: Option<super::browser::BrowserContextId>,
+            enable_begin_frame_control: Option<bool>,
+            new_window: Option<bool>,
+            background: Option<bool>,
+            for_tab: Option<bool>,
+            hidden: Option<bool>,
+        }
+        impl CreateTargetParamsBuilder {
+            pub fn url(mut self, url: impl Into<String>) -> Self {
+                self.url = Some(url.into());
+                self
+            }
+            pub fn left(mut self, left: impl Into<i64>) -> Self {
+                self.left = Some(left.into());
+                self
+            }
+            pub fn top(mut self, top: impl Into<i64>) -> Self {
+                self.top = Some(top.into());
+                self
+            }
+            pub fn width(mut self, width: impl Into<i64>) -> Self {
+                self.width = Some(width.into());
+                self
+            }
+            pub fn height(mut self, height: impl Into<i64>) -> Self {
+                self.height = Some(height.into());
+                self
+            }
+            pub fn window_state(mut self, window_state: impl Into<WindowState>) -> Self {
+                self.window_state = Some(window_state.into());
+                self
+            }
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<super::browser::BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn enable_begin_frame_control(
+                mut self,
+                enable_begin_frame_control: impl Into<bool>,
+            ) -> Self {
+                self.enable_begin_frame_control = Some(enable_begin_frame_control.into());
+                self
+            }
+            pub fn new_window(mut self, new_window: impl Into<bool>) -> Self {
+                self.new_window = Some(new_window.into());
+                self
+            }
+            pub fn background(mut self, background: impl Into<bool>) -> Self {
+                self.background = Some(background.into());
+                self
+            }
+            pub fn for_tab(mut self, for_tab: impl Into<bool>) -> Self {
+                self.for_tab = Some(for_tab.into());
+                self
+            }
+            pub fn hidden(mut self, hidden: impl Into<bool>) -> Self {
+                self.hidden = Some(hidden.into());
+                self
+            }
+            pub fn build(self) -> Result<CreateTargetParams, String> {
+                Ok(CreateTargetParams {
+                    url: self
+                        .url
+                        .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
+                    left: self.left,
+                    top: self.top,
+                    width: self.width,
+                    height: self.height,
+                    window_state: self.window_state,
+                    browser_context_id: self.browser_context_id,
+                    enable_begin_frame_control: self.enable_begin_frame_control,
+                    new_window: self.new_window,
+                    background: self.background,
+                    for_tab: self.for_tab,
+                    hidden: self.hidden,
+                })
+            }
+        }
+        impl CreateTargetParams {
+            pub const IDENTIFIER: &'static str = "Target.createTarget";
+        }
+        impl chromiumoxide_types::Method for CreateTargetParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for CreateTargetParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Creates a new page.\n[createTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-createTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct CreateTargetReturns {
+            #[doc = "The id of the page opened."]
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+        }
+        impl CreateTargetReturns {
+            pub fn new(target_id: impl Into<TargetId>) -> Self {
+                Self {
+                    target_id: target_id.into(),
+                }
+            }
+        }
+        impl CreateTargetReturns {
+            pub fn builder() -> CreateTargetReturnsBuilder {
+                CreateTargetReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CreateTargetReturnsBuilder {
+            target_id: Option<TargetId>,
+        }
+        impl CreateTargetReturnsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn build(self) -> Result<CreateTargetReturns, String> {
+                Ok(CreateTargetReturns {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for CreateTargetParams {
+            type Response = CreateTargetReturns;
+        }
+        #[doc = "Detaches session with given id.\n[detachFromTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-detachFromTarget)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DetachFromTargetParams {
+            #[doc = "Session to detach."]
+            #[serde(rename = "sessionId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub session_id: Option<SessionId>,
+        }
+        impl DetachFromTargetParams {
+            pub fn builder() -> DetachFromTargetParamsBuilder {
+                DetachFromTargetParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DetachFromTargetParamsBuilder {
+            session_id: Option<SessionId>,
+        }
+        impl DetachFromTargetParamsBuilder {
+            pub fn session_id(mut self, session_id: impl Into<SessionId>) -> Self {
+                self.session_id = Some(session_id.into());
+                self
+            }
+            pub fn build(self) -> DetachFromTargetParams {
+                DetachFromTargetParams {
+                    session_id: self.session_id,
+                }
+            }
+        }
+        impl DetachFromTargetParams {
+            pub const IDENTIFIER: &'static str = "Target.detachFromTarget";
+        }
+        impl chromiumoxide_types::Method for DetachFromTargetParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DetachFromTargetParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Detaches session with given id.\n[detachFromTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-detachFromTarget)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DetachFromTargetReturns {}
+        impl chromiumoxide_types::Command for DetachFromTargetParams {
+            type Response = DetachFromTargetReturns;
+        }
+        #[doc = "Deletes a BrowserContext. All the belonging pages will be closed without calling their\nbeforeunload hooks.\n[disposeBrowserContext](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-disposeBrowserContext)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct DisposeBrowserContextParams {
+            #[serde(rename = "browserContextId")]
+            pub browser_context_id: super::browser::BrowserContextId,
+        }
+        impl DisposeBrowserContextParams {
+            pub fn new(browser_context_id: impl Into<super::browser::BrowserContextId>) -> Self {
+                Self {
+                    browser_context_id: browser_context_id.into(),
+                }
+            }
+        }
+        impl DisposeBrowserContextParams {
+            pub fn builder() -> DisposeBrowserContextParamsBuilder {
+                DisposeBrowserContextParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct DisposeBrowserContextParamsBuilder {
+            browser_context_id: Option<super::browser::BrowserContextId>,
+        }
+        impl DisposeBrowserContextParamsBuilder {
+            pub fn browser_context_id(
+                mut self,
+                browser_context_id: impl Into<super::browser::BrowserContextId>,
+            ) -> Self {
+                self.browser_context_id = Some(browser_context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<DisposeBrowserContextParams, String> {
+                Ok(DisposeBrowserContextParams {
+                    browser_context_id: self.browser_context_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(browser_context_id)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl DisposeBrowserContextParams {
+            pub const IDENTIFIER: &'static str = "Target.disposeBrowserContext";
+        }
+        impl chromiumoxide_types::Method for DisposeBrowserContextParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisposeBrowserContextParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Deletes a BrowserContext. All the belonging pages will be closed without calling their\nbeforeunload hooks.\n[disposeBrowserContext](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-disposeBrowserContext)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisposeBrowserContextReturns {}
+        impl chromiumoxide_types::Command for DisposeBrowserContextParams {
+            type Response = DisposeBrowserContextReturns;
+        }
+        #[doc = "Returns information about a target.\n[getTargetInfo](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-getTargetInfo)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetTargetInfoParams {
+            #[serde(rename = "targetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub target_id: Option<TargetId>,
+        }
+        impl GetTargetInfoParams {
+            pub fn builder() -> GetTargetInfoParamsBuilder {
+                GetTargetInfoParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetTargetInfoParamsBuilder {
+            target_id: Option<TargetId>,
+        }
+        impl GetTargetInfoParamsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn build(self) -> GetTargetInfoParams {
+                GetTargetInfoParams {
+                    target_id: self.target_id,
+                }
+            }
+        }
+        impl GetTargetInfoParams {
+            pub const IDENTIFIER: &'static str = "Target.getTargetInfo";
+        }
+        impl chromiumoxide_types::Method for GetTargetInfoParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetTargetInfoParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns information about a target.\n[getTargetInfo](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-getTargetInfo)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetTargetInfoReturns {
+            #[serde(rename = "targetInfo")]
+            pub target_info: TargetInfo,
+        }
+        impl GetTargetInfoReturns {
+            pub fn new(target_info: impl Into<TargetInfo>) -> Self {
+                Self {
+                    target_info: target_info.into(),
+                }
+            }
+        }
+        impl GetTargetInfoReturns {
+            pub fn builder() -> GetTargetInfoReturnsBuilder {
+                GetTargetInfoReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetTargetInfoReturnsBuilder {
+            target_info: Option<TargetInfo>,
+        }
+        impl GetTargetInfoReturnsBuilder {
+            pub fn target_info(mut self, target_info: impl Into<TargetInfo>) -> Self {
+                self.target_info = Some(target_info.into());
+                self
+            }
+            pub fn build(self) -> Result<GetTargetInfoReturns, String> {
+                Ok(GetTargetInfoReturns {
+                    target_info: self.target_info.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_info))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetTargetInfoParams {
+            type Response = GetTargetInfoReturns;
+        }
+        #[doc = "Retrieves a list of available targets.\n[getTargets](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-getTargets)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetTargetsParams {
+            #[doc = "Only targets matching filter will be reported. If filter is not specified\nand target discovery is currently enabled, a filter used for target discovery\nis used for consistency."]
+            #[serde(rename = "filter")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub filter: Option<TargetFilter>,
+        }
+        impl GetTargetsParams {
+            pub fn builder() -> GetTargetsParamsBuilder {
+                GetTargetsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetTargetsParamsBuilder {
+            filter: Option<TargetFilter>,
+        }
+        impl GetTargetsParamsBuilder {
+            pub fn filter(mut self, filter: impl Into<TargetFilter>) -> Self {
+                self.filter = Some(filter.into());
+                self
+            }
+            pub fn build(self) -> GetTargetsParams {
+                GetTargetsParams {
+                    filter: self.filter,
+                }
+            }
+        }
+        impl GetTargetsParams {
+            pub const IDENTIFIER: &'static str = "Target.getTargets";
+        }
+        impl chromiumoxide_types::Method for GetTargetsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetTargetsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Retrieves a list of available targets.\n[getTargets](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-getTargets)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetTargetsReturns {
+            #[doc = "The list of targets."]
+            #[serde(rename = "targetInfos")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub target_infos: Vec<TargetInfo>,
+        }
+        impl GetTargetsReturns {
+            pub fn new(target_infos: Vec<TargetInfo>) -> Self {
+                Self { target_infos }
+            }
+        }
+        impl GetTargetsReturns {
+            pub fn builder() -> GetTargetsReturnsBuilder {
+                GetTargetsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetTargetsReturnsBuilder {
+            target_infos: Option<Vec<TargetInfo>>,
+        }
+        impl GetTargetsReturnsBuilder {
+            pub fn target_info(mut self, target_info: impl Into<TargetInfo>) -> Self {
+                let v = self.target_infos.get_or_insert(Vec::new());
+                v.push(target_info.into());
+                self
+            }
+            pub fn target_infos<I, S>(mut self, target_infos: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<TargetInfo>,
+            {
+                let v = self.target_infos.get_or_insert(Vec::new());
+                for val in target_infos {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetTargetsReturns, String> {
+                Ok(GetTargetsReturns {
+                    target_infos: self.target_infos.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_infos))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetTargetsParams {
+            type Response = GetTargetsReturns;
+        }
+        #[doc = "Controls whether to automatically attach to new targets which are considered\nto be directly related to this one (for example, iframes or workers).\nWhen turned on, attaches to all existing related targets as well. When turned off,\nautomatically detaches from all currently attached targets.\nThis also clears all targets added by `autoAttachRelated` from the list of targets to watch\nfor creation of related targets.\nYou might want to call this recursively for auto-attached targets to attach\nto all available targets.\n[setAutoAttach](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-setAutoAttach)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAutoAttachParams {
+            #[doc = "Whether to auto-attach to related targets."]
+            #[serde(rename = "autoAttach")]
+            pub auto_attach: bool,
+            #[doc = "Whether to pause new targets when attaching to them. Use `Runtime.runIfWaitingForDebugger`\nto run paused targets."]
+            #[serde(rename = "waitForDebuggerOnStart")]
+            pub wait_for_debugger_on_start: bool,
+            #[doc = "Enables \"flat\" access to the session via specifying sessionId attribute in the commands.\nWe plan to make this the default, deprecate non-flattened mode,\nand eventually retire it. See crbug.com/991325."]
+            #[serde(rename = "flatten")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub flatten: Option<bool>,
+            #[doc = "Only targets matching filter will be attached."]
+            #[serde(rename = "filter")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub filter: Option<TargetFilter>,
+        }
+        impl SetAutoAttachParams {
+            pub fn new(
+                auto_attach: impl Into<bool>,
+                wait_for_debugger_on_start: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    auto_attach: auto_attach.into(),
+                    wait_for_debugger_on_start: wait_for_debugger_on_start.into(),
+                    flatten: None,
+                    filter: None,
+                }
+            }
+        }
+        impl SetAutoAttachParams {
+            pub fn builder() -> SetAutoAttachParamsBuilder {
+                SetAutoAttachParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAutoAttachParamsBuilder {
+            auto_attach: Option<bool>,
+            wait_for_debugger_on_start: Option<bool>,
+            flatten: Option<bool>,
+            filter: Option<TargetFilter>,
+        }
+        impl SetAutoAttachParamsBuilder {
+            pub fn auto_attach(mut self, auto_attach: impl Into<bool>) -> Self {
+                self.auto_attach = Some(auto_attach.into());
+                self
+            }
+            pub fn wait_for_debugger_on_start(
+                mut self,
+                wait_for_debugger_on_start: impl Into<bool>,
+            ) -> Self {
+                self.wait_for_debugger_on_start = Some(wait_for_debugger_on_start.into());
+                self
+            }
+            pub fn flatten(mut self, flatten: impl Into<bool>) -> Self {
+                self.flatten = Some(flatten.into());
+                self
+            }
+            pub fn filter(mut self, filter: impl Into<TargetFilter>) -> Self {
+                self.filter = Some(filter.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAutoAttachParams, String> {
+                Ok(SetAutoAttachParams {
+                    auto_attach: self.auto_attach.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(auto_attach))
+                    })?,
+                    wait_for_debugger_on_start: self.wait_for_debugger_on_start.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(wait_for_debugger_on_start)
+                            )
+                        },
+                    )?,
+                    flatten: self.flatten,
+                    filter: self.filter,
+                })
+            }
+        }
+        impl SetAutoAttachParams {
+            pub const IDENTIFIER: &'static str = "Target.setAutoAttach";
+        }
+        impl chromiumoxide_types::Method for SetAutoAttachParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAutoAttachParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Controls whether to automatically attach to new targets which are considered\nto be directly related to this one (for example, iframes or workers).\nWhen turned on, attaches to all existing related targets as well. When turned off,\nautomatically detaches from all currently attached targets.\nThis also clears all targets added by `autoAttachRelated` from the list of targets to watch\nfor creation of related targets.\nYou might want to call this recursively for auto-attached targets to attach\nto all available targets.\n[setAutoAttach](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-setAutoAttach)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAutoAttachReturns {}
+        impl chromiumoxide_types::Command for SetAutoAttachParams {
+            type Response = SetAutoAttachReturns;
+        }
+        #[doc = "Adds the specified target to the list of targets that will be monitored for any related target\ncreation (such as child frames, child workers and new versions of service worker) and reported\nthrough `attachedToTarget`. The specified target is also auto-attached.\nThis cancels the effect of any previous `setAutoAttach` and is also cancelled by subsequent\n`setAutoAttach`. Only available at the Browser target.\n[autoAttachRelated](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-autoAttachRelated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AutoAttachRelatedParams {
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+            #[doc = "Whether to pause new targets when attaching to them. Use `Runtime.runIfWaitingForDebugger`\nto run paused targets."]
+            #[serde(rename = "waitForDebuggerOnStart")]
+            pub wait_for_debugger_on_start: bool,
+            #[doc = "Only targets matching filter will be attached."]
+            #[serde(rename = "filter")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub filter: Option<TargetFilter>,
+        }
+        impl AutoAttachRelatedParams {
+            pub fn new(
+                target_id: impl Into<TargetId>,
+                wait_for_debugger_on_start: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    target_id: target_id.into(),
+                    wait_for_debugger_on_start: wait_for_debugger_on_start.into(),
+                    filter: None,
+                }
+            }
+        }
+        impl AutoAttachRelatedParams {
+            pub fn builder() -> AutoAttachRelatedParamsBuilder {
+                AutoAttachRelatedParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AutoAttachRelatedParamsBuilder {
+            target_id: Option<TargetId>,
+            wait_for_debugger_on_start: Option<bool>,
+            filter: Option<TargetFilter>,
+        }
+        impl AutoAttachRelatedParamsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn wait_for_debugger_on_start(
+                mut self,
+                wait_for_debugger_on_start: impl Into<bool>,
+            ) -> Self {
+                self.wait_for_debugger_on_start = Some(wait_for_debugger_on_start.into());
+                self
+            }
+            pub fn filter(mut self, filter: impl Into<TargetFilter>) -> Self {
+                self.filter = Some(filter.into());
+                self
+            }
+            pub fn build(self) -> Result<AutoAttachRelatedParams, String> {
+                Ok(AutoAttachRelatedParams {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                    wait_for_debugger_on_start: self.wait_for_debugger_on_start.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(wait_for_debugger_on_start)
+                            )
+                        },
+                    )?,
+                    filter: self.filter,
+                })
+            }
+        }
+        impl AutoAttachRelatedParams {
+            pub const IDENTIFIER: &'static str = "Target.autoAttachRelated";
+        }
+        impl chromiumoxide_types::Method for AutoAttachRelatedParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AutoAttachRelatedParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Adds the specified target to the list of targets that will be monitored for any related target\ncreation (such as child frames, child workers and new versions of service worker) and reported\nthrough `attachedToTarget`. The specified target is also auto-attached.\nThis cancels the effect of any previous `setAutoAttach` and is also cancelled by subsequent\n`setAutoAttach`. Only available at the Browser target.\n[autoAttachRelated](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-autoAttachRelated)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct AutoAttachRelatedReturns {}
+        impl chromiumoxide_types::Command for AutoAttachRelatedParams {
+            type Response = AutoAttachRelatedReturns;
+        }
+        #[doc = "Controls whether to discover available targets and notify via\n`targetCreated/targetInfoChanged/targetDestroyed` events.\n[setDiscoverTargets](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-setDiscoverTargets)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetDiscoverTargetsParams {
+            #[doc = "Whether to discover available targets."]
+            #[serde(rename = "discover")]
+            pub discover: bool,
+            #[doc = "Only targets matching filter will be attached. If `discover` is false,\n`filter` must be omitted or empty."]
+            #[serde(rename = "filter")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub filter: Option<TargetFilter>,
+        }
+        impl SetDiscoverTargetsParams {
+            pub fn new(discover: impl Into<bool>) -> Self {
+                Self {
+                    discover: discover.into(),
+                    filter: None,
+                }
+            }
+        }
+        impl SetDiscoverTargetsParams {
+            pub fn builder() -> SetDiscoverTargetsParamsBuilder {
+                SetDiscoverTargetsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetDiscoverTargetsParamsBuilder {
+            discover: Option<bool>,
+            filter: Option<TargetFilter>,
+        }
+        impl SetDiscoverTargetsParamsBuilder {
+            pub fn discover(mut self, discover: impl Into<bool>) -> Self {
+                self.discover = Some(discover.into());
+                self
+            }
+            pub fn filter(mut self, filter: impl Into<TargetFilter>) -> Self {
+                self.filter = Some(filter.into());
+                self
+            }
+            pub fn build(self) -> Result<SetDiscoverTargetsParams, String> {
+                Ok(SetDiscoverTargetsParams {
+                    discover: self.discover.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(discover))
+                    })?,
+                    filter: self.filter,
+                })
+            }
+        }
+        impl SetDiscoverTargetsParams {
+            pub const IDENTIFIER: &'static str = "Target.setDiscoverTargets";
+        }
+        impl chromiumoxide_types::Method for SetDiscoverTargetsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetDiscoverTargetsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Controls whether to discover available targets and notify via\n`targetCreated/targetInfoChanged/targetDestroyed` events.\n[setDiscoverTargets](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-setDiscoverTargets)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetDiscoverTargetsReturns {}
+        impl chromiumoxide_types::Command for SetDiscoverTargetsParams {
+            type Response = SetDiscoverTargetsReturns;
+        }
+        #[doc = "Enables target discovery for the specified locations, when `setDiscoverTargets` was set to\n`true`.\n[setRemoteLocations](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-setRemoteLocations)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetRemoteLocationsParams {
+            #[doc = "List of remote locations."]
+            #[serde(rename = "locations")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub locations: Vec<RemoteLocation>,
+        }
+        impl SetRemoteLocationsParams {
+            pub fn new(locations: Vec<RemoteLocation>) -> Self {
+                Self { locations }
+            }
+        }
+        impl SetRemoteLocationsParams {
+            pub fn builder() -> SetRemoteLocationsParamsBuilder {
+                SetRemoteLocationsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetRemoteLocationsParamsBuilder {
+            locations: Option<Vec<RemoteLocation>>,
+        }
+        impl SetRemoteLocationsParamsBuilder {
+            pub fn location(mut self, location: impl Into<RemoteLocation>) -> Self {
+                let v = self.locations.get_or_insert(Vec::new());
+                v.push(location.into());
+                self
+            }
+            pub fn locations<I, S>(mut self, locations: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<RemoteLocation>,
+            {
+                let v = self.locations.get_or_insert(Vec::new());
+                for val in locations {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<SetRemoteLocationsParams, String> {
+                Ok(SetRemoteLocationsParams {
+                    locations: self.locations.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(locations))
+                    })?,
+                })
+            }
+        }
+        impl SetRemoteLocationsParams {
+            pub const IDENTIFIER: &'static str = "Target.setRemoteLocations";
+        }
+        impl chromiumoxide_types::Method for SetRemoteLocationsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetRemoteLocationsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables target discovery for the specified locations, when `setDiscoverTargets` was set to\n`true`.\n[setRemoteLocations](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-setRemoteLocations)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetRemoteLocationsReturns {}
+        impl chromiumoxide_types::Command for SetRemoteLocationsParams {
+            type Response = SetRemoteLocationsReturns;
+        }
+        #[doc = "Gets the targetId of the DevTools page target opened for the given target\n(if any).\n[getDevToolsTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-getDevToolsTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetDevToolsTargetParams {
+            #[doc = "Page or tab target ID."]
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+        }
+        impl GetDevToolsTargetParams {
+            pub fn new(target_id: impl Into<TargetId>) -> Self {
+                Self {
+                    target_id: target_id.into(),
+                }
+            }
+        }
+        impl GetDevToolsTargetParams {
+            pub fn builder() -> GetDevToolsTargetParamsBuilder {
+                GetDevToolsTargetParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDevToolsTargetParamsBuilder {
+            target_id: Option<TargetId>,
+        }
+        impl GetDevToolsTargetParamsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetDevToolsTargetParams, String> {
+                Ok(GetDevToolsTargetParams {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                })
+            }
+        }
+        impl GetDevToolsTargetParams {
+            pub const IDENTIFIER: &'static str = "Target.getDevToolsTarget";
+        }
+        impl chromiumoxide_types::Method for GetDevToolsTargetParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetDevToolsTargetParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets the targetId of the DevTools page target opened for the given target\n(if any).\n[getDevToolsTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-getDevToolsTarget)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetDevToolsTargetReturns {
+            #[doc = "The targetId of DevTools page target if exists."]
+            #[serde(rename = "targetId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub target_id: Option<TargetId>,
+        }
+        impl GetDevToolsTargetReturns {
+            pub fn builder() -> GetDevToolsTargetReturnsBuilder {
+                GetDevToolsTargetReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetDevToolsTargetReturnsBuilder {
+            target_id: Option<TargetId>,
+        }
+        impl GetDevToolsTargetReturnsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn build(self) -> GetDevToolsTargetReturns {
+                GetDevToolsTargetReturns {
+                    target_id: self.target_id,
+                }
+            }
+        }
+        impl chromiumoxide_types::Command for GetDevToolsTargetParams {
+            type Response = GetDevToolsTargetReturns;
+        }
+        #[doc = "Opens a DevTools window for the target.\n[openDevTools](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-openDevTools)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct OpenDevToolsParams {
+            #[doc = "This can be the page or tab target ID."]
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+            #[doc = "The id of the panel we want DevTools to open initially. Currently\nsupported panels are elements, console, network, sources, resources\nand performance."]
+            #[serde(rename = "panelId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub panel_id: Option<String>,
+        }
+        impl OpenDevToolsParams {
+            pub fn new(target_id: impl Into<TargetId>) -> Self {
+                Self {
+                    target_id: target_id.into(),
+                    panel_id: None,
+                }
+            }
+        }
+        impl OpenDevToolsParams {
+            pub fn builder() -> OpenDevToolsParamsBuilder {
+                OpenDevToolsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct OpenDevToolsParamsBuilder {
+            target_id: Option<TargetId>,
+            panel_id: Option<String>,
+        }
+        impl OpenDevToolsParamsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn panel_id(mut self, panel_id: impl Into<String>) -> Self {
+                self.panel_id = Some(panel_id.into());
+                self
+            }
+            pub fn build(self) -> Result<OpenDevToolsParams, String> {
+                Ok(OpenDevToolsParams {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                    panel_id: self.panel_id,
+                })
+            }
+        }
+        impl OpenDevToolsParams {
+            pub const IDENTIFIER: &'static str = "Target.openDevTools";
+        }
+        impl chromiumoxide_types::Method for OpenDevToolsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for OpenDevToolsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Opens a DevTools window for the target.\n[openDevTools](https://chromedevtools.github.io/devtools-protocol/tot/Target/#method-openDevTools)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct OpenDevToolsReturns {
+            #[doc = "The targetId of DevTools page target."]
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+        }
+        impl OpenDevToolsReturns {
+            pub fn new(target_id: impl Into<TargetId>) -> Self {
+                Self {
+                    target_id: target_id.into(),
+                }
+            }
+        }
+        impl OpenDevToolsReturns {
+            pub fn builder() -> OpenDevToolsReturnsBuilder {
+                OpenDevToolsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct OpenDevToolsReturnsBuilder {
+            target_id: Option<TargetId>,
+        }
+        impl OpenDevToolsReturnsBuilder {
+            pub fn target_id(mut self, target_id: impl Into<TargetId>) -> Self {
+                self.target_id = Some(target_id.into());
+                self
+            }
+            pub fn build(self) -> Result<OpenDevToolsReturns, String> {
+                Ok(OpenDevToolsReturns {
+                    target_id: self.target_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(target_id))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for OpenDevToolsParams {
+            type Response = OpenDevToolsReturns;
+        }
+        #[doc = "Issued when attached to target because of auto-attach or `attachToTarget` command.\n[attachedToTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#event-attachedToTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAttachedToTarget {
+            #[doc = "Identifier assigned to the session used to send/receive messages."]
+            #[serde(rename = "sessionId")]
+            pub session_id: SessionId,
+            #[serde(rename = "targetInfo")]
+            pub target_info: TargetInfo,
+            #[serde(rename = "waitingForDebugger")]
+            pub waiting_for_debugger: bool,
+        }
+        impl EventAttachedToTarget {
+            pub const IDENTIFIER: &'static str = "Target.attachedToTarget";
+        }
+        impl chromiumoxide_types::Method for EventAttachedToTarget {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAttachedToTarget {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when detached from target for any reason (including `detachFromTarget` command). Can be\nissued multiple times per target if multiple sessions have been attached to it.\n[detachedFromTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#event-detachedFromTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDetachedFromTarget {
+            #[doc = "Detached session identifier."]
+            #[serde(rename = "sessionId")]
+            pub session_id: SessionId,
+        }
+        impl EventDetachedFromTarget {
+            pub const IDENTIFIER: &'static str = "Target.detachedFromTarget";
+        }
+        impl chromiumoxide_types::Method for EventDetachedFromTarget {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDetachedFromTarget {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies about a new protocol message received from the session (as reported in\n`attachedToTarget` event).\n[receivedMessageFromTarget](https://chromedevtools.github.io/devtools-protocol/tot/Target/#event-receivedMessageFromTarget)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventReceivedMessageFromTarget {
+            #[doc = "Identifier of a session which sends a message."]
+            #[serde(rename = "sessionId")]
+            pub session_id: SessionId,
+            #[serde(rename = "message")]
+            pub message: String,
+        }
+        impl EventReceivedMessageFromTarget {
+            pub const IDENTIFIER: &'static str = "Target.receivedMessageFromTarget";
+        }
+        impl chromiumoxide_types::Method for EventReceivedMessageFromTarget {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventReceivedMessageFromTarget {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when a possible inspection target is created.\n[targetCreated](https://chromedevtools.github.io/devtools-protocol/tot/Target/#event-targetCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventTargetCreated {
+            #[serde(rename = "targetInfo")]
+            pub target_info: TargetInfo,
+        }
+        impl EventTargetCreated {
+            pub const IDENTIFIER: &'static str = "Target.targetCreated";
+        }
+        impl chromiumoxide_types::Method for EventTargetCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventTargetCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when a target is destroyed.\n[targetDestroyed](https://chromedevtools.github.io/devtools-protocol/tot/Target/#event-targetDestroyed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventTargetDestroyed {
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+        }
+        impl EventTargetDestroyed {
+            pub const IDENTIFIER: &'static str = "Target.targetDestroyed";
+        }
+        impl chromiumoxide_types::Method for EventTargetDestroyed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventTargetDestroyed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when a target has crashed.\n[targetCrashed](https://chromedevtools.github.io/devtools-protocol/tot/Target/#event-targetCrashed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventTargetCrashed {
+            #[serde(rename = "targetId")]
+            pub target_id: TargetId,
+            #[doc = "Termination status type."]
+            #[serde(rename = "status")]
+            pub status: String,
+            #[doc = "Termination error code."]
+            #[serde(rename = "errorCode")]
+            pub error_code: i64,
+        }
+        impl EventTargetCrashed {
+            pub const IDENTIFIER: &'static str = "Target.targetCrashed";
+        }
+        impl chromiumoxide_types::Method for EventTargetCrashed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventTargetCrashed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Issued when some information about a target has changed. This only happens between\n`targetCreated` and `targetDestroyed`.\n[targetInfoChanged](https://chromedevtools.github.io/devtools-protocol/tot/Target/#event-targetInfoChanged)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventTargetInfoChanged {
+            #[serde(rename = "targetInfo")]
+            pub target_info: TargetInfo,
+        }
+        impl EventTargetInfoChanged {
+            pub const IDENTIFIER: &'static str = "Target.targetInfoChanged";
+        }
+        impl chromiumoxide_types::Method for EventTargetInfoChanged {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventTargetInfoChanged {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "The Tethering domain defines methods and events for browser port binding."]
+    pub mod tethering {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Request browser port binding.\n[bind](https://chromedevtools.github.io/devtools-protocol/tot/Tethering/#method-bind)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BindParams {
+            #[doc = "Port number to bind."]
+            #[serde(rename = "port")]
+            pub port: i64,
+        }
+        impl BindParams {
+            pub fn new(port: impl Into<i64>) -> Self {
+                Self { port: port.into() }
+            }
+        }
+        impl BindParams {
+            pub fn builder() -> BindParamsBuilder {
+                BindParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BindParamsBuilder {
+            port: Option<i64>,
+        }
+        impl BindParamsBuilder {
+            pub fn port(mut self, port: impl Into<i64>) -> Self {
+                self.port = Some(port.into());
+                self
+            }
+            pub fn build(self) -> Result<BindParams, String> {
+                Ok(BindParams {
+                    port: self.port.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(port))
+                    })?,
+                })
+            }
+        }
+        impl BindParams {
+            pub const IDENTIFIER: &'static str = "Tethering.bind";
+        }
+        impl chromiumoxide_types::Method for BindParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for BindParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Request browser port binding.\n[bind](https://chromedevtools.github.io/devtools-protocol/tot/Tethering/#method-bind)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct BindReturns {}
+        impl chromiumoxide_types::Command for BindParams {
+            type Response = BindReturns;
+        }
+        #[doc = "Request browser port unbinding.\n[unbind](https://chromedevtools.github.io/devtools-protocol/tot/Tethering/#method-unbind)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct UnbindParams {
+            #[doc = "Port number to unbind."]
+            #[serde(rename = "port")]
+            pub port: i64,
+        }
+        impl UnbindParams {
+            pub fn new(port: impl Into<i64>) -> Self {
+                Self { port: port.into() }
+            }
+        }
+        impl UnbindParams {
+            pub fn builder() -> UnbindParamsBuilder {
+                UnbindParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct UnbindParamsBuilder {
+            port: Option<i64>,
+        }
+        impl UnbindParamsBuilder {
+            pub fn port(mut self, port: impl Into<i64>) -> Self {
+                self.port = Some(port.into());
+                self
+            }
+            pub fn build(self) -> Result<UnbindParams, String> {
+                Ok(UnbindParams {
+                    port: self.port.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(port))
+                    })?,
+                })
+            }
+        }
+        impl UnbindParams {
+            pub const IDENTIFIER: &'static str = "Tethering.unbind";
+        }
+        impl chromiumoxide_types::Method for UnbindParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for UnbindParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Request browser port unbinding.\n[unbind](https://chromedevtools.github.io/devtools-protocol/tot/Tethering/#method-unbind)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct UnbindReturns {}
+        impl chromiumoxide_types::Command for UnbindParams {
+            type Response = UnbindReturns;
+        }
+        #[doc = "Informs that port was successfully bound and got a specified connection id.\n[accepted](https://chromedevtools.github.io/devtools-protocol/tot/Tethering/#event-accepted)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAccepted {
+            #[doc = "Port number that was successfully bound."]
+            #[serde(rename = "port")]
+            pub port: i64,
+            #[doc = "Connection id to be used."]
+            #[serde(rename = "connectionId")]
+            pub connection_id: String,
+        }
+        impl EventAccepted {
+            pub const IDENTIFIER: &'static str = "Tethering.accepted";
+        }
+        impl chromiumoxide_types::Method for EventAccepted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAccepted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    pub mod tracing {
+        use serde::{Deserialize, Serialize};
+        #[doc = "Configuration for memory dump. Used only when \"memory-infra\" category is enabled.\n[MemoryDumpConfig](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#type-MemoryDumpConfig)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct MemoryDumpConfig(serde_json::Value);
+        impl MemoryDumpConfig {
+            pub fn new(val: impl Into<serde_json::Value>) -> Self {
+                MemoryDumpConfig(val.into())
+            }
+            pub fn inner(&self) -> &serde_json::Value {
+                &self.0
+            }
+        }
+        impl MemoryDumpConfig {
+            pub const IDENTIFIER: &'static str = "Tracing.MemoryDumpConfig";
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct TraceConfig {
+            #[doc = "Controls how the trace buffer stores data. The default is `recordUntilFull`."]
+            #[serde(rename = "recordMode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub record_mode: Option<TraceConfigRecordMode>,
+            #[doc = "Size of the trace buffer in kilobytes. If not specified or zero is passed, a default value\nof 200 MB would be used."]
+            #[serde(rename = "traceBufferSizeInKb")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub trace_buffer_size_in_kb: Option<f64>,
+            #[doc = "Turns on JavaScript stack sampling."]
+            #[serde(rename = "enableSampling")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub enable_sampling: Option<bool>,
+            #[doc = "Turns on system tracing."]
+            #[serde(rename = "enableSystrace")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub enable_systrace: Option<bool>,
+            #[doc = "Turns on argument filter."]
+            #[serde(rename = "enableArgumentFilter")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub enable_argument_filter: Option<bool>,
+            #[doc = "Included category filters."]
+            #[serde(rename = "includedCategories")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub included_categories: Option<Vec<String>>,
+            #[doc = "Excluded category filters."]
+            #[serde(rename = "excludedCategories")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub excluded_categories: Option<Vec<String>>,
+            #[doc = "Configuration to synthesize the delays in tracing."]
+            #[serde(rename = "syntheticDelays")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub synthetic_delays: Option<Vec<String>>,
+            #[doc = "Configuration for memory dump triggers. Used only when \"memory-infra\" category is enabled."]
+            #[serde(rename = "memoryDumpConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub memory_dump_config: Option<MemoryDumpConfig>,
+        }
+        #[doc = "Controls how the trace buffer stores data. The default is `recordUntilFull`."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum TraceConfigRecordMode {
+            #[serde(rename = "recordUntilFull")]
+            RecordUntilFull,
+            #[serde(rename = "recordContinuously")]
+            RecordContinuously,
+            #[serde(rename = "recordAsMuchAsPossible")]
+            RecordAsMuchAsPossible,
+            #[serde(rename = "echoToConsole")]
+            EchoToConsole,
+        }
+        impl AsRef<str> for TraceConfigRecordMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    TraceConfigRecordMode::RecordUntilFull => "recordUntilFull",
+                    TraceConfigRecordMode::RecordContinuously => "recordContinuously",
+                    TraceConfigRecordMode::RecordAsMuchAsPossible => "recordAsMuchAsPossible",
+                    TraceConfigRecordMode::EchoToConsole => "echoToConsole",
+                }
+            }
+        }
+        impl ::std::str::FromStr for TraceConfigRecordMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "recordUntilFull" | "RecordUntilFull" | "recorduntilfull" => {
+                        Ok(TraceConfigRecordMode::RecordUntilFull)
+                    }
+                    "recordContinuously" | "RecordContinuously" | "recordcontinuously" => {
+                        Ok(TraceConfigRecordMode::RecordContinuously)
+                    }
+                    "recordAsMuchAsPossible"
+                    | "RecordAsMuchAsPossible"
+                    | "recordasmuchaspossible" => Ok(TraceConfigRecordMode::RecordAsMuchAsPossible),
+                    "echoToConsole" | "EchoToConsole" | "echotoconsole" => {
+                        Ok(TraceConfigRecordMode::EchoToConsole)
+                    }
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl TraceConfig {
+            pub fn builder() -> TraceConfigBuilder {
+                TraceConfigBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct TraceConfigBuilder {
+            record_mode: Option<TraceConfigRecordMode>,
+            trace_buffer_size_in_kb: Option<f64>,
+            enable_sampling: Option<bool>,
+            enable_systrace: Option<bool>,
+            enable_argument_filter: Option<bool>,
+            included_categories: Option<Vec<String>>,
+            excluded_categories: Option<Vec<String>>,
+            synthetic_delays: Option<Vec<String>>,
+            memory_dump_config: Option<MemoryDumpConfig>,
+        }
+        impl TraceConfigBuilder {
+            pub fn record_mode(mut self, record_mode: impl Into<TraceConfigRecordMode>) -> Self {
+                self.record_mode = Some(record_mode.into());
+                self
+            }
+            pub fn trace_buffer_size_in_kb(
+                mut self,
+                trace_buffer_size_in_kb: impl Into<f64>,
+            ) -> Self {
+                self.trace_buffer_size_in_kb = Some(trace_buffer_size_in_kb.into());
+                self
+            }
+            pub fn enable_sampling(mut self, enable_sampling: impl Into<bool>) -> Self {
+                self.enable_sampling = Some(enable_sampling.into());
+                self
+            }
+            pub fn enable_systrace(mut self, enable_systrace: impl Into<bool>) -> Self {
+                self.enable_systrace = Some(enable_systrace.into());
+                self
+            }
+            pub fn enable_argument_filter(
+                mut self,
+                enable_argument_filter: impl Into<bool>,
+            ) -> Self {
+                self.enable_argument_filter = Some(enable_argument_filter.into());
+                self
+            }
+            pub fn included_categorie(mut self, included_categorie: impl Into<String>) -> Self {
+                let v = self.included_categories.get_or_insert(Vec::new());
+                v.push(included_categorie.into());
+                self
+            }
+            pub fn included_categories<I, S>(mut self, included_categories: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.included_categories.get_or_insert(Vec::new());
+                for val in included_categories {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn excluded_categorie(mut self, excluded_categorie: impl Into<String>) -> Self {
+                let v = self.excluded_categories.get_or_insert(Vec::new());
+                v.push(excluded_categorie.into());
+                self
+            }
+            pub fn excluded_categories<I, S>(mut self, excluded_categories: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.excluded_categories.get_or_insert(Vec::new());
+                for val in excluded_categories {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn synthetic_delay(mut self, synthetic_delay: impl Into<String>) -> Self {
+                let v = self.synthetic_delays.get_or_insert(Vec::new());
+                v.push(synthetic_delay.into());
+                self
+            }
+            pub fn synthetic_delays<I, S>(mut self, synthetic_delays: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.synthetic_delays.get_or_insert(Vec::new());
+                for val in synthetic_delays {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn memory_dump_config(
+                mut self,
+                memory_dump_config: impl Into<MemoryDumpConfig>,
+            ) -> Self {
+                self.memory_dump_config = Some(memory_dump_config.into());
+                self
+            }
+            pub fn build(self) -> TraceConfig {
+                TraceConfig {
+                    record_mode: self.record_mode,
+                    trace_buffer_size_in_kb: self.trace_buffer_size_in_kb,
+                    enable_sampling: self.enable_sampling,
+                    enable_systrace: self.enable_systrace,
+                    enable_argument_filter: self.enable_argument_filter,
+                    included_categories: self.included_categories,
+                    excluded_categories: self.excluded_categories,
+                    synthetic_delays: self.synthetic_delays,
+                    memory_dump_config: self.memory_dump_config,
+                }
+            }
+        }
+        impl TraceConfig {
+            pub const IDENTIFIER: &'static str = "Tracing.TraceConfig";
+        }
+        #[doc = "Data format of a trace. Can be either the legacy JSON format or the\nprotocol buffer format. Note that the JSON format will be deprecated soon."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum StreamFormat {
+            #[serde(rename = "json")]
+            Json,
+            #[serde(rename = "proto")]
+            Proto,
+        }
+        impl AsRef<str> for StreamFormat {
+            fn as_ref(&self) -> &str {
+                match self {
+                    StreamFormat::Json => "json",
+                    StreamFormat::Proto => "proto",
+                }
+            }
+        }
+        impl ::std::str::FromStr for StreamFormat {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "json" | "Json" => Ok(StreamFormat::Json),
+                    "proto" | "Proto" => Ok(StreamFormat::Proto),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Compression type to use for traces returned via streams."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum StreamCompression {
+            #[serde(rename = "none")]
+            None,
+            #[serde(rename = "gzip")]
+            Gzip,
+        }
+        impl AsRef<str> for StreamCompression {
+            fn as_ref(&self) -> &str {
+                match self {
+                    StreamCompression::None => "none",
+                    StreamCompression::Gzip => "gzip",
+                }
+            }
+        }
+        impl ::std::str::FromStr for StreamCompression {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "none" | "None" => Ok(StreamCompression::None),
+                    "gzip" | "Gzip" => Ok(StreamCompression::Gzip),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Details exposed when memory request explicitly declared.\nKeep consistent with memory_dump_request_args.h and\nmemory_instrumentation.mojom"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum MemoryDumpLevelOfDetail {
+            #[serde(rename = "background")]
+            Background,
+            #[serde(rename = "light")]
+            Light,
+            #[serde(rename = "detailed")]
+            Detailed,
+        }
+        impl AsRef<str> for MemoryDumpLevelOfDetail {
+            fn as_ref(&self) -> &str {
+                match self {
+                    MemoryDumpLevelOfDetail::Background => "background",
+                    MemoryDumpLevelOfDetail::Light => "light",
+                    MemoryDumpLevelOfDetail::Detailed => "detailed",
+                }
+            }
+        }
+        impl ::std::str::FromStr for MemoryDumpLevelOfDetail {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "background" | "Background" => Ok(MemoryDumpLevelOfDetail::Background),
+                    "light" | "Light" => Ok(MemoryDumpLevelOfDetail::Light),
+                    "detailed" | "Detailed" => Ok(MemoryDumpLevelOfDetail::Detailed),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Backend type to use for tracing. `chrome` uses the Chrome-integrated\ntracing service and is supported on all platforms. `system` is only\nsupported on Chrome OS and uses the Perfetto system tracing service.\n`auto` chooses `system` when the perfettoConfig provided to Tracing.start\nspecifies at least one non-Chrome data source; otherwise uses `chrome`."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum TracingBackend {
+            #[serde(rename = "auto")]
+            Auto,
+            #[serde(rename = "chrome")]
+            Chrome,
+            #[serde(rename = "system")]
+            System,
+        }
+        impl AsRef<str> for TracingBackend {
+            fn as_ref(&self) -> &str {
+                match self {
+                    TracingBackend::Auto => "auto",
+                    TracingBackend::Chrome => "chrome",
+                    TracingBackend::System => "system",
+                }
+            }
+        }
+        impl ::std::str::FromStr for TracingBackend {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "auto" | "Auto" => Ok(TracingBackend::Auto),
+                    "chrome" | "Chrome" => Ok(TracingBackend::Chrome),
+                    "system" | "System" => Ok(TracingBackend::System),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Stop trace events collection.\n[end](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-end)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EndParams {}
+        impl EndParams {
+            pub const IDENTIFIER: &'static str = "Tracing.end";
+        }
+        impl chromiumoxide_types::Method for EndParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EndParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Stop trace events collection.\n[end](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-end)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EndReturns {}
+        impl chromiumoxide_types::Command for EndParams {
+            type Response = EndReturns;
+        }
+        #[doc = "Gets supported tracing categories.\n[getCategories](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-getCategories)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetCategoriesParams {}
+        impl GetCategoriesParams {
+            pub const IDENTIFIER: &'static str = "Tracing.getCategories";
+        }
+        impl chromiumoxide_types::Method for GetCategoriesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetCategoriesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Gets supported tracing categories.\n[getCategories](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-getCategories)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCategoriesReturns {
+            #[doc = "A list of supported tracing categories."]
+            #[serde(rename = "categories")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub categories: Vec<String>,
+        }
+        impl GetCategoriesReturns {
+            pub fn new(categories: Vec<String>) -> Self {
+                Self { categories }
+            }
+        }
+        impl GetCategoriesReturns {
+            pub fn builder() -> GetCategoriesReturnsBuilder {
+                GetCategoriesReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCategoriesReturnsBuilder {
+            categories: Option<Vec<String>>,
+        }
+        impl GetCategoriesReturnsBuilder {
+            pub fn categorie(mut self, categorie: impl Into<String>) -> Self {
+                let v = self.categories.get_or_insert(Vec::new());
+                v.push(categorie.into());
+                self
+            }
+            pub fn categories<I, S>(mut self, categories: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<String>,
+            {
+                let v = self.categories.get_or_insert(Vec::new());
+                for val in categories {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetCategoriesReturns, String> {
+                Ok(GetCategoriesReturns {
+                    categories: self.categories.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(categories))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetCategoriesParams {
+            type Response = GetCategoriesReturns;
+        }
+        #[doc = "Return a descriptor for all available tracing categories.\n[getTrackEventDescriptor](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-getTrackEventDescriptor)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct GetTrackEventDescriptorParams {}
+        impl GetTrackEventDescriptorParams {
+            pub const IDENTIFIER: &'static str = "Tracing.getTrackEventDescriptor";
+        }
+        impl chromiumoxide_types::Method for GetTrackEventDescriptorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetTrackEventDescriptorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Return a descriptor for all available tracing categories.\n[getTrackEventDescriptor](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-getTrackEventDescriptor)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetTrackEventDescriptorReturns {
+            #[doc = "Base64-encoded serialized perfetto.protos.TrackEventDescriptor protobuf message."]
+            #[serde(rename = "descriptor")]
+            pub descriptor: chromiumoxide_types::Binary,
+        }
+        impl GetTrackEventDescriptorReturns {
+            pub fn new(descriptor: impl Into<chromiumoxide_types::Binary>) -> Self {
+                Self {
+                    descriptor: descriptor.into(),
+                }
+            }
+        }
+        impl GetTrackEventDescriptorReturns {
+            pub fn builder() -> GetTrackEventDescriptorReturnsBuilder {
+                GetTrackEventDescriptorReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetTrackEventDescriptorReturnsBuilder {
+            descriptor: Option<chromiumoxide_types::Binary>,
+        }
+        impl GetTrackEventDescriptorReturnsBuilder {
+            pub fn descriptor(
+                mut self,
+                descriptor: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.descriptor = Some(descriptor.into());
+                self
+            }
+            pub fn build(self) -> Result<GetTrackEventDescriptorReturns, String> {
+                Ok(GetTrackEventDescriptorReturns {
+                    descriptor: self.descriptor.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(descriptor))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetTrackEventDescriptorParams {
+            type Response = GetTrackEventDescriptorReturns;
+        }
+        #[doc = "Record a clock sync marker in the trace.\n[recordClockSyncMarker](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-recordClockSyncMarker)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RecordClockSyncMarkerParams {
+            #[doc = "The ID of this clock sync marker"]
+            #[serde(rename = "syncId")]
+            pub sync_id: String,
+        }
+        impl RecordClockSyncMarkerParams {
+            pub fn new(sync_id: impl Into<String>) -> Self {
+                Self {
+                    sync_id: sync_id.into(),
+                }
+            }
+        }
+        impl<T: Into<String>> From<T> for RecordClockSyncMarkerParams {
+            fn from(url: T) -> Self {
+                RecordClockSyncMarkerParams::new(url)
+            }
+        }
+        impl RecordClockSyncMarkerParams {
+            pub fn builder() -> RecordClockSyncMarkerParamsBuilder {
+                RecordClockSyncMarkerParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RecordClockSyncMarkerParamsBuilder {
+            sync_id: Option<String>,
+        }
+        impl RecordClockSyncMarkerParamsBuilder {
+            pub fn sync_id(mut self, sync_id: impl Into<String>) -> Self {
+                self.sync_id = Some(sync_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RecordClockSyncMarkerParams, String> {
+                Ok(RecordClockSyncMarkerParams {
+                    sync_id: self.sync_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(sync_id))
+                    })?,
+                })
+            }
+        }
+        impl RecordClockSyncMarkerParams {
+            pub const IDENTIFIER: &'static str = "Tracing.recordClockSyncMarker";
+        }
+        impl chromiumoxide_types::Method for RecordClockSyncMarkerParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RecordClockSyncMarkerParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Record a clock sync marker in the trace.\n[recordClockSyncMarker](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-recordClockSyncMarker)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RecordClockSyncMarkerReturns {}
+        impl chromiumoxide_types::Command for RecordClockSyncMarkerParams {
+            type Response = RecordClockSyncMarkerReturns;
+        }
+        #[doc = "Request a global memory dump.\n[requestMemoryDump](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-requestMemoryDump)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RequestMemoryDumpParams {
+            #[doc = "Enables more deterministic results by forcing garbage collection"]
+            #[serde(rename = "deterministic")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub deterministic: Option<bool>,
+            #[doc = "Specifies level of details in memory dump. Defaults to \"detailed\"."]
+            #[serde(rename = "levelOfDetail")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub level_of_detail: Option<MemoryDumpLevelOfDetail>,
+        }
+        impl RequestMemoryDumpParams {
+            pub fn builder() -> RequestMemoryDumpParamsBuilder {
+                RequestMemoryDumpParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestMemoryDumpParamsBuilder {
+            deterministic: Option<bool>,
+            level_of_detail: Option<MemoryDumpLevelOfDetail>,
+        }
+        impl RequestMemoryDumpParamsBuilder {
+            pub fn deterministic(mut self, deterministic: impl Into<bool>) -> Self {
+                self.deterministic = Some(deterministic.into());
+                self
+            }
+            pub fn level_of_detail(
+                mut self,
+                level_of_detail: impl Into<MemoryDumpLevelOfDetail>,
+            ) -> Self {
+                self.level_of_detail = Some(level_of_detail.into());
+                self
+            }
+            pub fn build(self) -> RequestMemoryDumpParams {
+                RequestMemoryDumpParams {
+                    deterministic: self.deterministic,
+                    level_of_detail: self.level_of_detail,
+                }
+            }
+        }
+        impl RequestMemoryDumpParams {
+            pub const IDENTIFIER: &'static str = "Tracing.requestMemoryDump";
+        }
+        impl chromiumoxide_types::Method for RequestMemoryDumpParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RequestMemoryDumpParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Request a global memory dump.\n[requestMemoryDump](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-requestMemoryDump)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RequestMemoryDumpReturns {
+            #[doc = "GUID of the resulting global memory dump."]
+            #[serde(rename = "dumpGuid")]
+            pub dump_guid: String,
+            #[doc = "True iff the global memory dump succeeded."]
+            #[serde(rename = "success")]
+            pub success: bool,
+        }
+        impl RequestMemoryDumpReturns {
+            pub fn new(dump_guid: impl Into<String>, success: impl Into<bool>) -> Self {
+                Self {
+                    dump_guid: dump_guid.into(),
+                    success: success.into(),
+                }
+            }
+        }
+        impl RequestMemoryDumpReturns {
+            pub fn builder() -> RequestMemoryDumpReturnsBuilder {
+                RequestMemoryDumpReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RequestMemoryDumpReturnsBuilder {
+            dump_guid: Option<String>,
+            success: Option<bool>,
+        }
+        impl RequestMemoryDumpReturnsBuilder {
+            pub fn dump_guid(mut self, dump_guid: impl Into<String>) -> Self {
+                self.dump_guid = Some(dump_guid.into());
+                self
+            }
+            pub fn success(mut self, success: impl Into<bool>) -> Self {
+                self.success = Some(success.into());
+                self
+            }
+            pub fn build(self) -> Result<RequestMemoryDumpReturns, String> {
+                Ok(RequestMemoryDumpReturns {
+                    dump_guid: self.dump_guid.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(dump_guid))
+                    })?,
+                    success: self.success.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(success))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for RequestMemoryDumpParams {
+            type Response = RequestMemoryDumpReturns;
+        }
+        #[doc = "Start trace events collection.\n[start](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-start)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartParams {
+            #[doc = "If set, the agent will issue bufferUsage events at this interval, specified in milliseconds"]
+            #[serde(rename = "bufferUsageReportingInterval")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub buffer_usage_reporting_interval: Option<f64>,
+            #[doc = "Whether to report trace events as series of dataCollected events or to save trace to a\nstream (defaults to `ReportEvents`)."]
+            #[serde(rename = "transferMode")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub transfer_mode: Option<StartTransferMode>,
+            #[doc = "Trace data format to use. This only applies when using `ReturnAsStream`\ntransfer mode (defaults to `json`)."]
+            #[serde(rename = "streamFormat")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub stream_format: Option<StreamFormat>,
+            #[doc = "Compression format to use. This only applies when using `ReturnAsStream`\ntransfer mode (defaults to `none`)"]
+            #[serde(rename = "streamCompression")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub stream_compression: Option<StreamCompression>,
+            #[serde(rename = "traceConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub trace_config: Option<TraceConfig>,
+            #[doc = "Base64-encoded serialized perfetto.protos.TraceConfig protobuf message\nWhen specified, the parameters `categories`, `options`, `traceConfig`\nare ignored."]
+            #[serde(rename = "perfettoConfig")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub perfetto_config: Option<chromiumoxide_types::Binary>,
+            #[doc = "Backend type (defaults to `auto`)"]
+            #[serde(rename = "tracingBackend")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub tracing_backend: Option<TracingBackend>,
+        }
+        #[doc = "Whether to report trace events as series of dataCollected events or to save trace to a\nstream (defaults to `ReportEvents`)."]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum StartTransferMode {
+            #[serde(rename = "ReportEvents")]
+            ReportEvents,
+            #[serde(rename = "ReturnAsStream")]
+            ReturnAsStream,
+        }
+        impl AsRef<str> for StartTransferMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    StartTransferMode::ReportEvents => "ReportEvents",
+                    StartTransferMode::ReturnAsStream => "ReturnAsStream",
+                }
+            }
+        }
+        impl ::std::str::FromStr for StartTransferMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "ReportEvents" | "reportevents" => Ok(StartTransferMode::ReportEvents),
+                    "ReturnAsStream" | "returnasstream" => Ok(StartTransferMode::ReturnAsStream),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        impl StartParams {
+            pub fn builder() -> StartParamsBuilder {
+                StartParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct StartParamsBuilder {
+            buffer_usage_reporting_interval: Option<f64>,
+            transfer_mode: Option<StartTransferMode>,
+            stream_format: Option<StreamFormat>,
+            stream_compression: Option<StreamCompression>,
+            trace_config: Option<TraceConfig>,
+            perfetto_config: Option<chromiumoxide_types::Binary>,
+            tracing_backend: Option<TracingBackend>,
+        }
+        impl StartParamsBuilder {
+            pub fn buffer_usage_reporting_interval(
+                mut self,
+                buffer_usage_reporting_interval: impl Into<f64>,
+            ) -> Self {
+                self.buffer_usage_reporting_interval = Some(buffer_usage_reporting_interval.into());
+                self
+            }
+            pub fn transfer_mode(mut self, transfer_mode: impl Into<StartTransferMode>) -> Self {
+                self.transfer_mode = Some(transfer_mode.into());
+                self
+            }
+            pub fn stream_format(mut self, stream_format: impl Into<StreamFormat>) -> Self {
+                self.stream_format = Some(stream_format.into());
+                self
+            }
+            pub fn stream_compression(
+                mut self,
+                stream_compression: impl Into<StreamCompression>,
+            ) -> Self {
+                self.stream_compression = Some(stream_compression.into());
+                self
+            }
+            pub fn trace_config(mut self, trace_config: impl Into<TraceConfig>) -> Self {
+                self.trace_config = Some(trace_config.into());
+                self
+            }
+            pub fn perfetto_config(
+                mut self,
+                perfetto_config: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.perfetto_config = Some(perfetto_config.into());
+                self
+            }
+            pub fn tracing_backend(mut self, tracing_backend: impl Into<TracingBackend>) -> Self {
+                self.tracing_backend = Some(tracing_backend.into());
+                self
+            }
+            pub fn build(self) -> StartParams {
+                StartParams {
+                    buffer_usage_reporting_interval: self.buffer_usage_reporting_interval,
+                    transfer_mode: self.transfer_mode,
+                    stream_format: self.stream_format,
+                    stream_compression: self.stream_compression,
+                    trace_config: self.trace_config,
+                    perfetto_config: self.perfetto_config,
+                    tracing_backend: self.tracing_backend,
+                }
+            }
+        }
+        impl StartParams {
+            pub const IDENTIFIER: &'static str = "Tracing.start";
+        }
+        impl chromiumoxide_types::Method for StartParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for StartParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Start trace events collection.\n[start](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#method-start)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct StartReturns {}
+        impl chromiumoxide_types::Command for StartParams {
+            type Response = StartReturns;
+        }
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EventBufferUsage {
+            #[doc = "A number in range [0..1] that indicates the used size of event buffer as a fraction of its\ntotal size."]
+            #[serde(rename = "percentFull")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub percent_full: Option<f64>,
+            #[doc = "An approximate number of events in the trace log."]
+            #[serde(rename = "eventCount")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub event_count: Option<f64>,
+            #[doc = "A number in range [0..1] that indicates the used size of event buffer as a fraction of its\ntotal size."]
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub value: Option<f64>,
+        }
+        impl EventBufferUsage {
+            pub const IDENTIFIER: &'static str = "Tracing.bufferUsage";
+        }
+        impl chromiumoxide_types::Method for EventBufferUsage {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventBufferUsage {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Contains a bucket of collected trace events. When tracing is stopped collected events will be\nsent as a sequence of dataCollected events followed by tracingComplete event.\n[dataCollected](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#event-dataCollected)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventDataCollected {
+            #[serde(rename = "value")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub value: Vec<serde_json::Value>,
+        }
+        impl EventDataCollected {
+            pub const IDENTIFIER: &'static str = "Tracing.dataCollected";
+        }
+        impl chromiumoxide_types::Method for EventDataCollected {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventDataCollected {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Signals that tracing is stopped and there is no trace buffers pending flush, all data were\ndelivered via dataCollected events.\n[tracingComplete](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/#event-tracingComplete)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventTracingComplete {
+            #[doc = "Indicates whether some trace data is known to have been lost, e.g. because the trace ring\nbuffer wrapped around."]
+            #[serde(rename = "dataLossOccurred")]
+            pub data_loss_occurred: bool,
+            #[doc = "A handle of the stream that holds resulting trace data."]
+            #[serde(rename = "stream")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub stream: Option<super::io::StreamHandle>,
+            #[doc = "Trace data format of returned stream."]
+            #[serde(rename = "traceFormat")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub trace_format: Option<StreamFormat>,
+            #[doc = "Compression format of returned stream."]
+            #[serde(rename = "streamCompression")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub stream_compression: Option<StreamCompression>,
+        }
+        impl EventTracingComplete {
+            pub const IDENTIFIER: &'static str = "Tracing.tracingComplete";
+        }
+        impl chromiumoxide_types::Method for EventTracingComplete {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventTracingComplete {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "This domain allows inspection of Web Audio API.\nhttps://webaudio.github.io/web-audio-api/"]
+    pub mod web_audio {
+        use serde::{Deserialize, Serialize};
+        #[doc = "An unique ID for a graph object (AudioContext, AudioNode, AudioParam) in Web Audio API\n[GraphObjectId](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#type-GraphObjectId)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct GraphObjectId(String);
+        impl GraphObjectId {
+            pub fn new(val: impl Into<String>) -> Self {
+                GraphObjectId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for GraphObjectId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<GraphObjectId> for String {
+            fn from(el: GraphObjectId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for GraphObjectId {
+            fn from(expr: String) -> Self {
+                GraphObjectId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for GraphObjectId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl GraphObjectId {
+            pub const IDENTIFIER: &'static str = "WebAudio.GraphObjectId";
+        }
+        #[doc = "Enum of BaseAudioContext types"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ContextType {
+            #[serde(rename = "realtime")]
+            Realtime,
+            #[serde(rename = "offline")]
+            Offline,
+        }
+        impl AsRef<str> for ContextType {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ContextType::Realtime => "realtime",
+                    ContextType::Offline => "offline",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ContextType {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "realtime" | "Realtime" => Ok(ContextType::Realtime),
+                    "offline" | "Offline" => Ok(ContextType::Offline),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Enum of AudioContextState from the spec"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ContextState {
+            #[serde(rename = "suspended")]
+            Suspended,
+            #[serde(rename = "running")]
+            Running,
+            #[serde(rename = "closed")]
+            Closed,
+            #[serde(rename = "interrupted")]
+            Interrupted,
+        }
+        impl AsRef<str> for ContextState {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ContextState::Suspended => "suspended",
+                    ContextState::Running => "running",
+                    ContextState::Closed => "closed",
+                    ContextState::Interrupted => "interrupted",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ContextState {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "suspended" | "Suspended" => Ok(ContextState::Suspended),
+                    "running" | "Running" => Ok(ContextState::Running),
+                    "closed" | "Closed" => Ok(ContextState::Closed),
+                    "interrupted" | "Interrupted" => Ok(ContextState::Interrupted),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Enum of AudioNode types\n[NodeType](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#type-NodeType)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct NodeType(String);
+        impl NodeType {
+            pub fn new(val: impl Into<String>) -> Self {
+                NodeType(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for NodeType {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<NodeType> for String {
+            fn from(el: NodeType) -> String {
+                el.0
+            }
+        }
+        impl From<String> for NodeType {
+            fn from(expr: String) -> Self {
+                NodeType(expr)
+            }
+        }
+        impl NodeType {
+            pub const IDENTIFIER: &'static str = "WebAudio.NodeType";
+        }
+        #[doc = "Enum of AudioNode::ChannelCountMode from the spec"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ChannelCountMode {
+            #[serde(rename = "clamped-max")]
+            ClampedMax,
+            #[serde(rename = "explicit")]
+            Explicit,
+            #[serde(rename = "max")]
+            Max,
+        }
+        impl AsRef<str> for ChannelCountMode {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ChannelCountMode::ClampedMax => "clamped-max",
+                    ChannelCountMode::Explicit => "explicit",
+                    ChannelCountMode::Max => "max",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ChannelCountMode {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "clamped-max" | "ClampedMax" => Ok(ChannelCountMode::ClampedMax),
+                    "explicit" | "Explicit" => Ok(ChannelCountMode::Explicit),
+                    "max" | "Max" => Ok(ChannelCountMode::Max),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Enum of AudioNode::ChannelInterpretation from the spec"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum ChannelInterpretation {
+            #[serde(rename = "discrete")]
+            Discrete,
+            #[serde(rename = "speakers")]
+            Speakers,
+        }
+        impl AsRef<str> for ChannelInterpretation {
+            fn as_ref(&self) -> &str {
+                match self {
+                    ChannelInterpretation::Discrete => "discrete",
+                    ChannelInterpretation::Speakers => "speakers",
+                }
+            }
+        }
+        impl ::std::str::FromStr for ChannelInterpretation {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "discrete" | "Discrete" => Ok(ChannelInterpretation::Discrete),
+                    "speakers" | "Speakers" => Ok(ChannelInterpretation::Speakers),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Enum of AudioParam types\n[ParamType](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#type-ParamType)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct ParamType(String);
+        impl ParamType {
+            pub fn new(val: impl Into<String>) -> Self {
+                ParamType(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for ParamType {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<ParamType> for String {
+            fn from(el: ParamType) -> String {
+                el.0
+            }
+        }
+        impl From<String> for ParamType {
+            fn from(expr: String) -> Self {
+                ParamType(expr)
+            }
+        }
+        impl ParamType {
+            pub const IDENTIFIER: &'static str = "WebAudio.ParamType";
+        }
+        #[doc = "Enum of AudioParam::AutomationRate from the spec"]
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AutomationRate {
+            #[serde(rename = "a-rate")]
+            ARate,
+            #[serde(rename = "k-rate")]
+            KRate,
+        }
+        impl AsRef<str> for AutomationRate {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AutomationRate::ARate => "a-rate",
+                    AutomationRate::KRate => "k-rate",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AutomationRate {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "a-rate" | "ARate" => Ok(AutomationRate::ARate),
+                    "k-rate" | "KRate" => Ok(AutomationRate::KRate),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[doc = "Fields in AudioContext that change in real-time.\n[ContextRealtimeData](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#type-ContextRealtimeData)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ContextRealtimeData {
+            #[doc = "The current context time in second in BaseAudioContext."]
+            #[serde(rename = "currentTime")]
+            pub current_time: f64,
+            #[doc = "The time spent on rendering graph divided by render quantum duration,\nand multiplied by 100. 100 means the audio renderer reached the full\ncapacity and glitch may occur."]
+            #[serde(rename = "renderCapacity")]
+            pub render_capacity: f64,
+            #[doc = "A running mean of callback interval."]
+            #[serde(rename = "callbackIntervalMean")]
+            pub callback_interval_mean: f64,
+            #[doc = "A running variance of callback interval."]
+            #[serde(rename = "callbackIntervalVariance")]
+            pub callback_interval_variance: f64,
+        }
+        impl ContextRealtimeData {
+            pub fn new(
+                current_time: impl Into<f64>,
+                render_capacity: impl Into<f64>,
+                callback_interval_mean: impl Into<f64>,
+                callback_interval_variance: impl Into<f64>,
+            ) -> Self {
+                Self {
+                    current_time: current_time.into(),
+                    render_capacity: render_capacity.into(),
+                    callback_interval_mean: callback_interval_mean.into(),
+                    callback_interval_variance: callback_interval_variance.into(),
+                }
+            }
+        }
+        impl ContextRealtimeData {
+            pub fn builder() -> ContextRealtimeDataBuilder {
+                ContextRealtimeDataBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ContextRealtimeDataBuilder {
+            current_time: Option<f64>,
+            render_capacity: Option<f64>,
+            callback_interval_mean: Option<f64>,
+            callback_interval_variance: Option<f64>,
+        }
+        impl ContextRealtimeDataBuilder {
+            pub fn current_time(mut self, current_time: impl Into<f64>) -> Self {
+                self.current_time = Some(current_time.into());
+                self
+            }
+            pub fn render_capacity(mut self, render_capacity: impl Into<f64>) -> Self {
+                self.render_capacity = Some(render_capacity.into());
+                self
+            }
+            pub fn callback_interval_mean(
+                mut self,
+                callback_interval_mean: impl Into<f64>,
+            ) -> Self {
+                self.callback_interval_mean = Some(callback_interval_mean.into());
+                self
+            }
+            pub fn callback_interval_variance(
+                mut self,
+                callback_interval_variance: impl Into<f64>,
+            ) -> Self {
+                self.callback_interval_variance = Some(callback_interval_variance.into());
+                self
+            }
+            pub fn build(self) -> Result<ContextRealtimeData, String> {
+                Ok(ContextRealtimeData {
+                    current_time: self.current_time.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(current_time))
+                    })?,
+                    render_capacity: self.render_capacity.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(render_capacity))
+                    })?,
+                    callback_interval_mean: self.callback_interval_mean.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(callback_interval_mean)
+                        )
+                    })?,
+                    callback_interval_variance: self.callback_interval_variance.ok_or_else(
+                        || {
+                            format!(
+                                "Field `{}` is mandatory.",
+                                std::stringify!(callback_interval_variance)
+                            )
+                        },
+                    )?,
+                })
+            }
+        }
+        impl ContextRealtimeData {
+            pub const IDENTIFIER: &'static str = "WebAudio.ContextRealtimeData";
+        }
+        #[doc = "Protocol object for BaseAudioContext\n[BaseAudioContext](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#type-BaseAudioContext)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct BaseAudioContext {
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+            #[serde(rename = "contextType")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub context_type: ContextType,
+            #[serde(rename = "contextState")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub context_state: ContextState,
+            #[serde(rename = "realtimeData")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub realtime_data: Option<ContextRealtimeData>,
+            #[doc = "Platform-dependent callback buffer size."]
+            #[serde(rename = "callbackBufferSize")]
+            pub callback_buffer_size: f64,
+            #[doc = "Number of output channels supported by audio hardware in use."]
+            #[serde(rename = "maxOutputChannelCount")]
+            pub max_output_channel_count: f64,
+            #[doc = "Context sample rate."]
+            #[serde(rename = "sampleRate")]
+            pub sample_rate: f64,
+        }
+        impl BaseAudioContext {
+            pub fn builder() -> BaseAudioContextBuilder {
+                BaseAudioContextBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct BaseAudioContextBuilder {
+            context_id: Option<GraphObjectId>,
+            context_type: Option<ContextType>,
+            context_state: Option<ContextState>,
+            realtime_data: Option<ContextRealtimeData>,
+            callback_buffer_size: Option<f64>,
+            max_output_channel_count: Option<f64>,
+            sample_rate: Option<f64>,
+        }
+        impl BaseAudioContextBuilder {
+            pub fn context_id(mut self, context_id: impl Into<GraphObjectId>) -> Self {
+                self.context_id = Some(context_id.into());
+                self
+            }
+            pub fn context_type(mut self, context_type: impl Into<ContextType>) -> Self {
+                self.context_type = Some(context_type.into());
+                self
+            }
+            pub fn context_state(mut self, context_state: impl Into<ContextState>) -> Self {
+                self.context_state = Some(context_state.into());
+                self
+            }
+            pub fn realtime_data(mut self, realtime_data: impl Into<ContextRealtimeData>) -> Self {
+                self.realtime_data = Some(realtime_data.into());
+                self
+            }
+            pub fn callback_buffer_size(mut self, callback_buffer_size: impl Into<f64>) -> Self {
+                self.callback_buffer_size = Some(callback_buffer_size.into());
+                self
+            }
+            pub fn max_output_channel_count(
+                mut self,
+                max_output_channel_count: impl Into<f64>,
+            ) -> Self {
+                self.max_output_channel_count = Some(max_output_channel_count.into());
+                self
+            }
+            pub fn sample_rate(mut self, sample_rate: impl Into<f64>) -> Self {
+                self.sample_rate = Some(sample_rate.into());
+                self
+            }
+            pub fn build(self) -> Result<BaseAudioContext, String> {
+                Ok(BaseAudioContext {
+                    context_id: self.context_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(context_id))
+                    })?,
+                    context_type: self.context_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(context_type))
+                    })?,
+                    context_state: self.context_state.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(context_state))
+                    })?,
+                    realtime_data: self.realtime_data,
+                    callback_buffer_size: self.callback_buffer_size.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(callback_buffer_size)
+                        )
+                    })?,
+                    max_output_channel_count: self.max_output_channel_count.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(max_output_channel_count)
+                        )
+                    })?,
+                    sample_rate: self.sample_rate.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(sample_rate))
+                    })?,
+                })
+            }
+        }
+        impl BaseAudioContext {
+            pub const IDENTIFIER: &'static str = "WebAudio.BaseAudioContext";
+        }
+        #[doc = "Protocol object for AudioListener\n[AudioListener](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#type-AudioListener)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AudioListener {
+            #[serde(rename = "listenerId")]
+            pub listener_id: GraphObjectId,
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+        }
+        impl AudioListener {
+            pub fn new(
+                listener_id: impl Into<GraphObjectId>,
+                context_id: impl Into<GraphObjectId>,
+            ) -> Self {
+                Self {
+                    listener_id: listener_id.into(),
+                    context_id: context_id.into(),
+                }
+            }
+        }
+        impl AudioListener {
+            pub fn builder() -> AudioListenerBuilder {
+                AudioListenerBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AudioListenerBuilder {
+            listener_id: Option<GraphObjectId>,
+            context_id: Option<GraphObjectId>,
+        }
+        impl AudioListenerBuilder {
+            pub fn listener_id(mut self, listener_id: impl Into<GraphObjectId>) -> Self {
+                self.listener_id = Some(listener_id.into());
+                self
+            }
+            pub fn context_id(mut self, context_id: impl Into<GraphObjectId>) -> Self {
+                self.context_id = Some(context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AudioListener, String> {
+                Ok(AudioListener {
+                    listener_id: self.listener_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(listener_id))
+                    })?,
+                    context_id: self.context_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(context_id))
+                    })?,
+                })
+            }
+        }
+        impl AudioListener {
+            pub const IDENTIFIER: &'static str = "WebAudio.AudioListener";
+        }
+        #[doc = "Protocol object for AudioNode\n[AudioNode](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#type-AudioNode)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AudioNode {
+            #[serde(rename = "nodeId")]
+            pub node_id: GraphObjectId,
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+            #[serde(rename = "nodeType")]
+            pub node_type: NodeType,
+            #[serde(rename = "numberOfInputs")]
+            pub number_of_inputs: f64,
+            #[serde(rename = "numberOfOutputs")]
+            pub number_of_outputs: f64,
+            #[serde(rename = "channelCount")]
+            pub channel_count: f64,
+            #[serde(rename = "channelCountMode")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub channel_count_mode: ChannelCountMode,
+            #[serde(rename = "channelInterpretation")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub channel_interpretation: ChannelInterpretation,
+        }
+        impl AudioNode {
+            pub fn builder() -> AudioNodeBuilder {
+                AudioNodeBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AudioNodeBuilder {
+            node_id: Option<GraphObjectId>,
+            context_id: Option<GraphObjectId>,
+            node_type: Option<NodeType>,
+            number_of_inputs: Option<f64>,
+            number_of_outputs: Option<f64>,
+            channel_count: Option<f64>,
+            channel_count_mode: Option<ChannelCountMode>,
+            channel_interpretation: Option<ChannelInterpretation>,
+        }
+        impl AudioNodeBuilder {
+            pub fn node_id(mut self, node_id: impl Into<GraphObjectId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn context_id(mut self, context_id: impl Into<GraphObjectId>) -> Self {
+                self.context_id = Some(context_id.into());
+                self
+            }
+            pub fn node_type(mut self, node_type: impl Into<NodeType>) -> Self {
+                self.node_type = Some(node_type.into());
+                self
+            }
+            pub fn number_of_inputs(mut self, number_of_inputs: impl Into<f64>) -> Self {
+                self.number_of_inputs = Some(number_of_inputs.into());
+                self
+            }
+            pub fn number_of_outputs(mut self, number_of_outputs: impl Into<f64>) -> Self {
+                self.number_of_outputs = Some(number_of_outputs.into());
+                self
+            }
+            pub fn channel_count(mut self, channel_count: impl Into<f64>) -> Self {
+                self.channel_count = Some(channel_count.into());
+                self
+            }
+            pub fn channel_count_mode(
+                mut self,
+                channel_count_mode: impl Into<ChannelCountMode>,
+            ) -> Self {
+                self.channel_count_mode = Some(channel_count_mode.into());
+                self
+            }
+            pub fn channel_interpretation(
+                mut self,
+                channel_interpretation: impl Into<ChannelInterpretation>,
+            ) -> Self {
+                self.channel_interpretation = Some(channel_interpretation.into());
+                self
+            }
+            pub fn build(self) -> Result<AudioNode, String> {
+                Ok(AudioNode {
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    context_id: self.context_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(context_id))
+                    })?,
+                    node_type: self.node_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_type))
+                    })?,
+                    number_of_inputs: self.number_of_inputs.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(number_of_inputs)
+                        )
+                    })?,
+                    number_of_outputs: self.number_of_outputs.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(number_of_outputs)
+                        )
+                    })?,
+                    channel_count: self.channel_count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(channel_count))
+                    })?,
+                    channel_count_mode: self.channel_count_mode.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(channel_count_mode)
+                        )
+                    })?,
+                    channel_interpretation: self.channel_interpretation.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(channel_interpretation)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl AudioNode {
+            pub const IDENTIFIER: &'static str = "WebAudio.AudioNode";
+        }
+        #[doc = "Protocol object for AudioParam\n[AudioParam](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#type-AudioParam)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AudioParam {
+            #[serde(rename = "paramId")]
+            pub param_id: GraphObjectId,
+            #[serde(rename = "nodeId")]
+            pub node_id: GraphObjectId,
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+            #[serde(rename = "paramType")]
+            pub param_type: ParamType,
+            #[serde(rename = "rate")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub rate: AutomationRate,
+            #[serde(rename = "defaultValue")]
+            pub default_value: f64,
+            #[serde(rename = "minValue")]
+            pub min_value: f64,
+            #[serde(rename = "maxValue")]
+            pub max_value: f64,
+        }
+        impl AudioParam {
+            pub fn builder() -> AudioParamBuilder {
+                AudioParamBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AudioParamBuilder {
+            param_id: Option<GraphObjectId>,
+            node_id: Option<GraphObjectId>,
+            context_id: Option<GraphObjectId>,
+            param_type: Option<ParamType>,
+            rate: Option<AutomationRate>,
+            default_value: Option<f64>,
+            min_value: Option<f64>,
+            max_value: Option<f64>,
+        }
+        impl AudioParamBuilder {
+            pub fn param_id(mut self, param_id: impl Into<GraphObjectId>) -> Self {
+                self.param_id = Some(param_id.into());
+                self
+            }
+            pub fn node_id(mut self, node_id: impl Into<GraphObjectId>) -> Self {
+                self.node_id = Some(node_id.into());
+                self
+            }
+            pub fn context_id(mut self, context_id: impl Into<GraphObjectId>) -> Self {
+                self.context_id = Some(context_id.into());
+                self
+            }
+            pub fn param_type(mut self, param_type: impl Into<ParamType>) -> Self {
+                self.param_type = Some(param_type.into());
+                self
+            }
+            pub fn rate(mut self, rate: impl Into<AutomationRate>) -> Self {
+                self.rate = Some(rate.into());
+                self
+            }
+            pub fn default_value(mut self, default_value: impl Into<f64>) -> Self {
+                self.default_value = Some(default_value.into());
+                self
+            }
+            pub fn min_value(mut self, min_value: impl Into<f64>) -> Self {
+                self.min_value = Some(min_value.into());
+                self
+            }
+            pub fn max_value(mut self, max_value: impl Into<f64>) -> Self {
+                self.max_value = Some(max_value.into());
+                self
+            }
+            pub fn build(self) -> Result<AudioParam, String> {
+                Ok(AudioParam {
+                    param_id: self.param_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(param_id))
+                    })?,
+                    node_id: self.node_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(node_id))
+                    })?,
+                    context_id: self.context_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(context_id))
+                    })?,
+                    param_type: self.param_type.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(param_type))
+                    })?,
+                    rate: self.rate.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(rate))
+                    })?,
+                    default_value: self.default_value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(default_value))
+                    })?,
+                    min_value: self.min_value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(min_value))
+                    })?,
+                    max_value: self.max_value.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(max_value))
+                    })?,
+                })
+            }
+        }
+        impl AudioParam {
+            pub const IDENTIFIER: &'static str = "WebAudio.AudioParam";
+        }
+        #[doc = "Enables the WebAudio domain and starts sending context lifetime events.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {}
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "WebAudio.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enables the WebAudio domain and starts sending context lifetime events.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Disables the WebAudio domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "WebAudio.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disables the WebAudio domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Fetch the realtime data from the registered contexts.\n[getRealtimeData](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#method-getRealtimeData)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetRealtimeDataParams {
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+        }
+        impl GetRealtimeDataParams {
+            pub fn new(context_id: impl Into<GraphObjectId>) -> Self {
+                Self {
+                    context_id: context_id.into(),
+                }
+            }
+        }
+        impl GetRealtimeDataParams {
+            pub fn builder() -> GetRealtimeDataParamsBuilder {
+                GetRealtimeDataParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetRealtimeDataParamsBuilder {
+            context_id: Option<GraphObjectId>,
+        }
+        impl GetRealtimeDataParamsBuilder {
+            pub fn context_id(mut self, context_id: impl Into<GraphObjectId>) -> Self {
+                self.context_id = Some(context_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetRealtimeDataParams, String> {
+                Ok(GetRealtimeDataParams {
+                    context_id: self.context_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(context_id))
+                    })?,
+                })
+            }
+        }
+        impl GetRealtimeDataParams {
+            pub const IDENTIFIER: &'static str = "WebAudio.getRealtimeData";
+        }
+        impl chromiumoxide_types::Method for GetRealtimeDataParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetRealtimeDataParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Fetch the realtime data from the registered contexts.\n[getRealtimeData](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#method-getRealtimeData)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetRealtimeDataReturns {
+            #[serde(rename = "realtimeData")]
+            pub realtime_data: ContextRealtimeData,
+        }
+        impl GetRealtimeDataReturns {
+            pub fn new(realtime_data: impl Into<ContextRealtimeData>) -> Self {
+                Self {
+                    realtime_data: realtime_data.into(),
+                }
+            }
+        }
+        impl GetRealtimeDataReturns {
+            pub fn builder() -> GetRealtimeDataReturnsBuilder {
+                GetRealtimeDataReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetRealtimeDataReturnsBuilder {
+            realtime_data: Option<ContextRealtimeData>,
+        }
+        impl GetRealtimeDataReturnsBuilder {
+            pub fn realtime_data(mut self, realtime_data: impl Into<ContextRealtimeData>) -> Self {
+                self.realtime_data = Some(realtime_data.into());
+                self
+            }
+            pub fn build(self) -> Result<GetRealtimeDataReturns, String> {
+                Ok(GetRealtimeDataReturns {
+                    realtime_data: self.realtime_data.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(realtime_data))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetRealtimeDataParams {
+            type Response = GetRealtimeDataReturns;
+        }
+        #[doc = "Notifies that a new BaseAudioContext has been created.\n[contextCreated](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-contextCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventContextCreated {
+            #[serde(rename = "context")]
+            pub context: BaseAudioContext,
+        }
+        impl EventContextCreated {
+            pub const IDENTIFIER: &'static str = "WebAudio.contextCreated";
+        }
+        impl chromiumoxide_types::Method for EventContextCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventContextCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that an existing BaseAudioContext will be destroyed.\n[contextWillBeDestroyed](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-contextWillBeDestroyed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventContextWillBeDestroyed {
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+        }
+        impl EventContextWillBeDestroyed {
+            pub const IDENTIFIER: &'static str = "WebAudio.contextWillBeDestroyed";
+        }
+        impl chromiumoxide_types::Method for EventContextWillBeDestroyed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventContextWillBeDestroyed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that existing BaseAudioContext has changed some properties (id stays the same)..\n[contextChanged](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-contextChanged)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventContextChanged {
+            #[serde(rename = "context")]
+            pub context: BaseAudioContext,
+        }
+        impl EventContextChanged {
+            pub const IDENTIFIER: &'static str = "WebAudio.contextChanged";
+        }
+        impl chromiumoxide_types::Method for EventContextChanged {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventContextChanged {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that the construction of an AudioListener has finished.\n[audioListenerCreated](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-audioListenerCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAudioListenerCreated {
+            #[serde(rename = "listener")]
+            pub listener: AudioListener,
+        }
+        impl EventAudioListenerCreated {
+            pub const IDENTIFIER: &'static str = "WebAudio.audioListenerCreated";
+        }
+        impl chromiumoxide_types::Method for EventAudioListenerCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAudioListenerCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that a new AudioListener has been created.\n[audioListenerWillBeDestroyed](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-audioListenerWillBeDestroyed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAudioListenerWillBeDestroyed {
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+            #[serde(rename = "listenerId")]
+            pub listener_id: GraphObjectId,
+        }
+        impl EventAudioListenerWillBeDestroyed {
+            pub const IDENTIFIER: &'static str = "WebAudio.audioListenerWillBeDestroyed";
+        }
+        impl chromiumoxide_types::Method for EventAudioListenerWillBeDestroyed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAudioListenerWillBeDestroyed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that a new AudioNode has been created.\n[audioNodeCreated](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-audioNodeCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAudioNodeCreated {
+            #[serde(rename = "node")]
+            pub node: AudioNode,
+        }
+        impl EventAudioNodeCreated {
+            pub const IDENTIFIER: &'static str = "WebAudio.audioNodeCreated";
+        }
+        impl chromiumoxide_types::Method for EventAudioNodeCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAudioNodeCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that an existing AudioNode has been destroyed.\n[audioNodeWillBeDestroyed](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-audioNodeWillBeDestroyed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAudioNodeWillBeDestroyed {
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+            #[serde(rename = "nodeId")]
+            pub node_id: GraphObjectId,
+        }
+        impl EventAudioNodeWillBeDestroyed {
+            pub const IDENTIFIER: &'static str = "WebAudio.audioNodeWillBeDestroyed";
+        }
+        impl chromiumoxide_types::Method for EventAudioNodeWillBeDestroyed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAudioNodeWillBeDestroyed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that a new AudioParam has been created.\n[audioParamCreated](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-audioParamCreated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAudioParamCreated {
+            #[serde(rename = "param")]
+            pub param: AudioParam,
+        }
+        impl EventAudioParamCreated {
+            pub const IDENTIFIER: &'static str = "WebAudio.audioParamCreated";
+        }
+        impl chromiumoxide_types::Method for EventAudioParamCreated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAudioParamCreated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that an existing AudioParam has been destroyed.\n[audioParamWillBeDestroyed](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-audioParamWillBeDestroyed)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventAudioParamWillBeDestroyed {
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+            #[serde(rename = "nodeId")]
+            pub node_id: GraphObjectId,
+            #[serde(rename = "paramId")]
+            pub param_id: GraphObjectId,
+        }
+        impl EventAudioParamWillBeDestroyed {
+            pub const IDENTIFIER: &'static str = "WebAudio.audioParamWillBeDestroyed";
+        }
+        impl chromiumoxide_types::Method for EventAudioParamWillBeDestroyed {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventAudioParamWillBeDestroyed {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that two AudioNodes are connected.\n[nodesConnected](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-nodesConnected)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventNodesConnected {
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+            #[serde(rename = "sourceId")]
+            pub source_id: GraphObjectId,
+            #[serde(rename = "destinationId")]
+            pub destination_id: GraphObjectId,
+            #[serde(rename = "sourceOutputIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_output_index: Option<f64>,
+            #[serde(rename = "destinationInputIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub destination_input_index: Option<f64>,
+        }
+        impl EventNodesConnected {
+            pub const IDENTIFIER: &'static str = "WebAudio.nodesConnected";
+        }
+        impl chromiumoxide_types::Method for EventNodesConnected {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventNodesConnected {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that AudioNodes are disconnected. The destination can be null, and it means all the outgoing connections from the source are disconnected.\n[nodesDisconnected](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-nodesDisconnected)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventNodesDisconnected {
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+            #[serde(rename = "sourceId")]
+            pub source_id: GraphObjectId,
+            #[serde(rename = "destinationId")]
+            pub destination_id: GraphObjectId,
+            #[serde(rename = "sourceOutputIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_output_index: Option<f64>,
+            #[serde(rename = "destinationInputIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub destination_input_index: Option<f64>,
+        }
+        impl EventNodesDisconnected {
+            pub const IDENTIFIER: &'static str = "WebAudio.nodesDisconnected";
+        }
+        impl chromiumoxide_types::Method for EventNodesDisconnected {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventNodesDisconnected {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that an AudioNode is connected to an AudioParam.\n[nodeParamConnected](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-nodeParamConnected)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventNodeParamConnected {
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+            #[serde(rename = "sourceId")]
+            pub source_id: GraphObjectId,
+            #[serde(rename = "destinationId")]
+            pub destination_id: GraphObjectId,
+            #[serde(rename = "sourceOutputIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_output_index: Option<f64>,
+        }
+        impl EventNodeParamConnected {
+            pub const IDENTIFIER: &'static str = "WebAudio.nodeParamConnected";
+        }
+        impl chromiumoxide_types::Method for EventNodeParamConnected {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventNodeParamConnected {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Notifies that an AudioNode is disconnected to an AudioParam.\n[nodeParamDisconnected](https://chromedevtools.github.io/devtools-protocol/tot/WebAudio/#event-nodeParamDisconnected)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventNodeParamDisconnected {
+            #[serde(rename = "contextId")]
+            pub context_id: GraphObjectId,
+            #[serde(rename = "sourceId")]
+            pub source_id: GraphObjectId,
+            #[serde(rename = "destinationId")]
+            pub destination_id: GraphObjectId,
+            #[serde(rename = "sourceOutputIndex")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub source_output_index: Option<f64>,
+        }
+        impl EventNodeParamDisconnected {
+            pub const IDENTIFIER: &'static str = "WebAudio.nodeParamDisconnected";
+        }
+        impl chromiumoxide_types::Method for EventNodeParamDisconnected {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventNodeParamDisconnected {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+    #[doc = "This domain allows configuring virtual authenticators to test the WebAuthn\nAPI."]
+    pub mod web_authn {
+        use serde::{Deserialize, Serialize};
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, Eq, Hash)]
+        pub struct AuthenticatorId(String);
+        impl AuthenticatorId {
+            pub fn new(val: impl Into<String>) -> Self {
+                AuthenticatorId(val.into())
+            }
+            pub fn inner(&self) -> &String {
+                &self.0
+            }
+        }
+        impl AsRef<str> for AuthenticatorId {
+            fn as_ref(&self) -> &str {
+                self.0.as_str()
+            }
+        }
+        impl From<AuthenticatorId> for String {
+            fn from(el: AuthenticatorId) -> String {
+                el.0
+            }
+        }
+        impl From<String> for AuthenticatorId {
+            fn from(expr: String) -> Self {
+                AuthenticatorId(expr)
+            }
+        }
+        impl std::borrow::Borrow<str> for AuthenticatorId {
+            fn borrow(&self) -> &str {
+                &self.0
+            }
+        }
+        impl AuthenticatorId {
+            pub const IDENTIFIER: &'static str = "WebAuthn.AuthenticatorId";
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AuthenticatorProtocol {
+            #[doc = "Universal 2nd Factor."]
+            #[serde(rename = "u2f")]
+            U2f,
+            #[doc = "Client To Authenticator Protocol 2."]
+            #[serde(rename = "ctap2")]
+            Ctap2,
+        }
+        impl AsRef<str> for AuthenticatorProtocol {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AuthenticatorProtocol::U2f => "u2f",
+                    AuthenticatorProtocol::Ctap2 => "ctap2",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AuthenticatorProtocol {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "u2f" | "U2f" => Ok(AuthenticatorProtocol::U2f),
+                    "ctap2" | "Ctap2" => Ok(AuthenticatorProtocol::Ctap2),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum Ctap2Version {
+            #[serde(rename = "ctap2_0")]
+            Ctap20,
+            #[serde(rename = "ctap2_1")]
+            Ctap21,
+        }
+        impl AsRef<str> for Ctap2Version {
+            fn as_ref(&self) -> &str {
+                match self {
+                    Ctap2Version::Ctap20 => "ctap2_0",
+                    Ctap2Version::Ctap21 => "ctap2_1",
+                }
+            }
+        }
+        impl ::std::str::FromStr for Ctap2Version {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "ctap2_0" | "Ctap20" => Ok(Ctap2Version::Ctap20),
+                    "ctap2_1" | "Ctap21" => Ok(Ctap2Version::Ctap21),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub enum AuthenticatorTransport {
+            #[doc = "Cross-Platform authenticator attachments:"]
+            #[serde(rename = "usb")]
+            Usb,
+            #[serde(rename = "nfc")]
+            Nfc,
+            #[serde(rename = "ble")]
+            Ble,
+            #[serde(rename = "cable")]
+            Cable,
+            #[doc = "Platform authenticator attachment:"]
+            #[serde(rename = "internal")]
+            Internal,
+        }
+        impl AsRef<str> for AuthenticatorTransport {
+            fn as_ref(&self) -> &str {
+                match self {
+                    AuthenticatorTransport::Usb => "usb",
+                    AuthenticatorTransport::Nfc => "nfc",
+                    AuthenticatorTransport::Ble => "ble",
+                    AuthenticatorTransport::Cable => "cable",
+                    AuthenticatorTransport::Internal => "internal",
+                }
+            }
+        }
+        impl ::std::str::FromStr for AuthenticatorTransport {
+            type Err = String;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    "usb" | "Usb" => Ok(AuthenticatorTransport::Usb),
+                    "nfc" | "Nfc" => Ok(AuthenticatorTransport::Nfc),
+                    "ble" | "Ble" => Ok(AuthenticatorTransport::Ble),
+                    "cable" | "Cable" => Ok(AuthenticatorTransport::Cable),
+                    "internal" | "Internal" => Ok(AuthenticatorTransport::Internal),
+                    _ => Err(s.to_string()),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct VirtualAuthenticatorOptions {
+            #[serde(rename = "protocol")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub protocol: AuthenticatorProtocol,
+            #[doc = "Defaults to ctap2_0. Ignored if |protocol| == u2f."]
+            #[serde(rename = "ctap2Version")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            #[serde(default)]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str_optional")]
+            pub ctap2_version: Option<Ctap2Version>,
+            #[serde(rename = "transport")]
+            #[serde(deserialize_with = "super::super::de::deserialize_from_str")]
+            pub transport: AuthenticatorTransport,
+            #[doc = "Defaults to false."]
+            #[serde(rename = "hasResidentKey")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_resident_key: Option<bool>,
+            #[doc = "Defaults to false."]
+            #[serde(rename = "hasUserVerification")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_user_verification: Option<bool>,
+            #[doc = "If set to true, the authenticator will support the largeBlob extension.\nhttps://w3c.github.io/webauthn#largeBlob\nDefaults to false."]
+            #[serde(rename = "hasLargeBlob")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_large_blob: Option<bool>,
+            #[doc = "If set to true, the authenticator will support the credBlob extension.\nhttps://fidoalliance.org/specs/fido-v2.1-rd-20201208/fido-client-to-authenticator-protocol-v2.1-rd-20201208.html#sctn-credBlob-extension\nDefaults to false."]
+            #[serde(rename = "hasCredBlob")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_cred_blob: Option<bool>,
+            #[doc = "If set to true, the authenticator will support the minPinLength extension.\nhttps://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-20210615.html#sctn-minpinlength-extension\nDefaults to false."]
+            #[serde(rename = "hasMinPinLength")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_min_pin_length: Option<bool>,
+            #[doc = "If set to true, the authenticator will support the prf extension.\nhttps://w3c.github.io/webauthn/#prf-extension\nDefaults to false."]
+            #[serde(rename = "hasPrf")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub has_prf: Option<bool>,
+            #[doc = "If set to true, tests of user presence will succeed immediately.\nOtherwise, they will not be resolved. Defaults to true."]
+            #[serde(rename = "automaticPresenceSimulation")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub automatic_presence_simulation: Option<bool>,
+            #[doc = "Sets whether User Verification succeeds or fails for an authenticator.\nDefaults to false."]
+            #[serde(rename = "isUserVerified")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_user_verified: Option<bool>,
+            #[doc = "Credentials created by this authenticator will have the backup\neligibility (BE) flag set to this value. Defaults to false.\nhttps://w3c.github.io/webauthn/#sctn-credential-backup"]
+            #[serde(rename = "defaultBackupEligibility")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub default_backup_eligibility: Option<bool>,
+            #[doc = "Credentials created by this authenticator will have the backup state\n(BS) flag set to this value. Defaults to false.\nhttps://w3c.github.io/webauthn/#sctn-credential-backup"]
+            #[serde(rename = "defaultBackupState")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub default_backup_state: Option<bool>,
+        }
+        impl VirtualAuthenticatorOptions {
+            pub fn new(
+                protocol: impl Into<AuthenticatorProtocol>,
+                transport: impl Into<AuthenticatorTransport>,
+            ) -> Self {
+                Self {
+                    protocol: protocol.into(),
+                    transport: transport.into(),
+                    ctap2_version: None,
+                    has_resident_key: None,
+                    has_user_verification: None,
+                    has_large_blob: None,
+                    has_cred_blob: None,
+                    has_min_pin_length: None,
+                    has_prf: None,
+                    automatic_presence_simulation: None,
+                    is_user_verified: None,
+                    default_backup_eligibility: None,
+                    default_backup_state: None,
+                }
+            }
+        }
+        impl VirtualAuthenticatorOptions {
+            pub fn builder() -> VirtualAuthenticatorOptionsBuilder {
+                VirtualAuthenticatorOptionsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct VirtualAuthenticatorOptionsBuilder {
+            protocol: Option<AuthenticatorProtocol>,
+            ctap2_version: Option<Ctap2Version>,
+            transport: Option<AuthenticatorTransport>,
+            has_resident_key: Option<bool>,
+            has_user_verification: Option<bool>,
+            has_large_blob: Option<bool>,
+            has_cred_blob: Option<bool>,
+            has_min_pin_length: Option<bool>,
+            has_prf: Option<bool>,
+            automatic_presence_simulation: Option<bool>,
+            is_user_verified: Option<bool>,
+            default_backup_eligibility: Option<bool>,
+            default_backup_state: Option<bool>,
+        }
+        impl VirtualAuthenticatorOptionsBuilder {
+            pub fn protocol(mut self, protocol: impl Into<AuthenticatorProtocol>) -> Self {
+                self.protocol = Some(protocol.into());
+                self
+            }
+            pub fn ctap2_version(mut self, ctap2_version: impl Into<Ctap2Version>) -> Self {
+                self.ctap2_version = Some(ctap2_version.into());
+                self
+            }
+            pub fn transport(mut self, transport: impl Into<AuthenticatorTransport>) -> Self {
+                self.transport = Some(transport.into());
+                self
+            }
+            pub fn has_resident_key(mut self, has_resident_key: impl Into<bool>) -> Self {
+                self.has_resident_key = Some(has_resident_key.into());
+                self
+            }
+            pub fn has_user_verification(mut self, has_user_verification: impl Into<bool>) -> Self {
+                self.has_user_verification = Some(has_user_verification.into());
+                self
+            }
+            pub fn has_large_blob(mut self, has_large_blob: impl Into<bool>) -> Self {
+                self.has_large_blob = Some(has_large_blob.into());
+                self
+            }
+            pub fn has_cred_blob(mut self, has_cred_blob: impl Into<bool>) -> Self {
+                self.has_cred_blob = Some(has_cred_blob.into());
+                self
+            }
+            pub fn has_min_pin_length(mut self, has_min_pin_length: impl Into<bool>) -> Self {
+                self.has_min_pin_length = Some(has_min_pin_length.into());
+                self
+            }
+            pub fn has_prf(mut self, has_prf: impl Into<bool>) -> Self {
+                self.has_prf = Some(has_prf.into());
+                self
+            }
+            pub fn automatic_presence_simulation(
+                mut self,
+                automatic_presence_simulation: impl Into<bool>,
+            ) -> Self {
+                self.automatic_presence_simulation = Some(automatic_presence_simulation.into());
+                self
+            }
+            pub fn is_user_verified(mut self, is_user_verified: impl Into<bool>) -> Self {
+                self.is_user_verified = Some(is_user_verified.into());
+                self
+            }
+            pub fn default_backup_eligibility(
+                mut self,
+                default_backup_eligibility: impl Into<bool>,
+            ) -> Self {
+                self.default_backup_eligibility = Some(default_backup_eligibility.into());
+                self
+            }
+            pub fn default_backup_state(mut self, default_backup_state: impl Into<bool>) -> Self {
+                self.default_backup_state = Some(default_backup_state.into());
+                self
+            }
+            pub fn build(self) -> Result<VirtualAuthenticatorOptions, String> {
+                Ok(VirtualAuthenticatorOptions {
+                    protocol: self.protocol.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(protocol))
+                    })?,
+                    ctap2_version: self.ctap2_version,
+                    transport: self.transport.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(transport))
+                    })?,
+                    has_resident_key: self.has_resident_key,
+                    has_user_verification: self.has_user_verification,
+                    has_large_blob: self.has_large_blob,
+                    has_cred_blob: self.has_cred_blob,
+                    has_min_pin_length: self.has_min_pin_length,
+                    has_prf: self.has_prf,
+                    automatic_presence_simulation: self.automatic_presence_simulation,
+                    is_user_verified: self.is_user_verified,
+                    default_backup_eligibility: self.default_backup_eligibility,
+                    default_backup_state: self.default_backup_state,
+                })
+            }
+        }
+        impl VirtualAuthenticatorOptions {
+            pub const IDENTIFIER: &'static str = "WebAuthn.VirtualAuthenticatorOptions";
+        }
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct Credential {
+            #[serde(rename = "credentialId")]
+            pub credential_id: chromiumoxide_types::Binary,
+            #[serde(rename = "isResidentCredential")]
+            pub is_resident_credential: bool,
+            #[doc = "Relying Party ID the credential is scoped to. Must be set when adding a\ncredential."]
+            #[serde(rename = "rpId")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub rp_id: Option<String>,
+            #[doc = "The ECDSA P-256 private key in PKCS#8 format."]
+            #[serde(rename = "privateKey")]
+            pub private_key: chromiumoxide_types::Binary,
+            #[doc = "An opaque byte sequence with a maximum size of 64 bytes mapping the\ncredential to a specific user."]
+            #[serde(rename = "userHandle")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub user_handle: Option<chromiumoxide_types::Binary>,
+            #[doc = "Signature counter. This is incremented by one for each successful\nassertion.\nSee https://w3c.github.io/webauthn/#signature-counter"]
+            #[serde(rename = "signCount")]
+            pub sign_count: i64,
+            #[doc = "The large blob associated with the credential.\nSee https://w3c.github.io/webauthn/#sctn-large-blob-extension"]
+            #[serde(rename = "largeBlob")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub large_blob: Option<chromiumoxide_types::Binary>,
+            #[doc = "Assertions returned by this credential will have the backup eligibility\n(BE) flag set to this value. Defaults to the authenticator's\ndefaultBackupEligibility value."]
+            #[serde(rename = "backupEligibility")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backup_eligibility: Option<bool>,
+            #[doc = "Assertions returned by this credential will have the backup state (BS)\nflag set to this value. Defaults to the authenticator's\ndefaultBackupState value."]
+            #[serde(rename = "backupState")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backup_state: Option<bool>,
+            #[doc = "The credential's user.name property. Equivalent to empty if not set.\nhttps://w3c.github.io/webauthn/#dom-publickeycredentialentity-name"]
+            #[serde(rename = "userName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub user_name: Option<String>,
+            #[doc = "The credential's user.displayName property. Equivalent to empty if\nnot set.\nhttps://w3c.github.io/webauthn/#dom-publickeycredentialuserentity-displayname"]
+            #[serde(rename = "userDisplayName")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub user_display_name: Option<String>,
+        }
+        impl Credential {
+            pub fn new(
+                credential_id: impl Into<chromiumoxide_types::Binary>,
+                is_resident_credential: impl Into<bool>,
+                private_key: impl Into<chromiumoxide_types::Binary>,
+                sign_count: impl Into<i64>,
+            ) -> Self {
+                Self {
+                    credential_id: credential_id.into(),
+                    is_resident_credential: is_resident_credential.into(),
+                    private_key: private_key.into(),
+                    sign_count: sign_count.into(),
+                    rp_id: None,
+                    user_handle: None,
+                    large_blob: None,
+                    backup_eligibility: None,
+                    backup_state: None,
+                    user_name: None,
+                    user_display_name: None,
+                }
+            }
+        }
+        impl Credential {
+            pub fn builder() -> CredentialBuilder {
+                CredentialBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct CredentialBuilder {
+            credential_id: Option<chromiumoxide_types::Binary>,
+            is_resident_credential: Option<bool>,
+            rp_id: Option<String>,
+            private_key: Option<chromiumoxide_types::Binary>,
+            user_handle: Option<chromiumoxide_types::Binary>,
+            sign_count: Option<i64>,
+            large_blob: Option<chromiumoxide_types::Binary>,
+            backup_eligibility: Option<bool>,
+            backup_state: Option<bool>,
+            user_name: Option<String>,
+            user_display_name: Option<String>,
+        }
+        impl CredentialBuilder {
+            pub fn credential_id(
+                mut self,
+                credential_id: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.credential_id = Some(credential_id.into());
+                self
+            }
+            pub fn is_resident_credential(
+                mut self,
+                is_resident_credential: impl Into<bool>,
+            ) -> Self {
+                self.is_resident_credential = Some(is_resident_credential.into());
+                self
+            }
+            pub fn rp_id(mut self, rp_id: impl Into<String>) -> Self {
+                self.rp_id = Some(rp_id.into());
+                self
+            }
+            pub fn private_key(
+                mut self,
+                private_key: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.private_key = Some(private_key.into());
+                self
+            }
+            pub fn user_handle(
+                mut self,
+                user_handle: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.user_handle = Some(user_handle.into());
+                self
+            }
+            pub fn sign_count(mut self, sign_count: impl Into<i64>) -> Self {
+                self.sign_count = Some(sign_count.into());
+                self
+            }
+            pub fn large_blob(
+                mut self,
+                large_blob: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.large_blob = Some(large_blob.into());
+                self
+            }
+            pub fn backup_eligibility(mut self, backup_eligibility: impl Into<bool>) -> Self {
+                self.backup_eligibility = Some(backup_eligibility.into());
+                self
+            }
+            pub fn backup_state(mut self, backup_state: impl Into<bool>) -> Self {
+                self.backup_state = Some(backup_state.into());
+                self
+            }
+            pub fn user_name(mut self, user_name: impl Into<String>) -> Self {
+                self.user_name = Some(user_name.into());
+                self
+            }
+            pub fn user_display_name(mut self, user_display_name: impl Into<String>) -> Self {
+                self.user_display_name = Some(user_display_name.into());
+                self
+            }
+            pub fn build(self) -> Result<Credential, String> {
+                Ok(Credential {
+                    credential_id: self.credential_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(credential_id))
+                    })?,
+                    is_resident_credential: self.is_resident_credential.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(is_resident_credential)
+                        )
+                    })?,
+                    rp_id: self.rp_id,
+                    private_key: self.private_key.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(private_key))
+                    })?,
+                    user_handle: self.user_handle,
+                    sign_count: self.sign_count.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(sign_count))
+                    })?,
+                    large_blob: self.large_blob,
+                    backup_eligibility: self.backup_eligibility,
+                    backup_state: self.backup_state,
+                    user_name: self.user_name,
+                    user_display_name: self.user_display_name,
+                })
+            }
+        }
+        impl Credential {
+            pub const IDENTIFIER: &'static str = "WebAuthn.Credential";
+        }
+        #[doc = "Enable the WebAuthn domain and start intercepting credential storage and\nretrieval with a virtual authenticator.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableParams {
+            #[doc = "Whether to enable the WebAuthn user interface. Enabling the UI is\nrecommended for debugging and demo purposes, as it is closer to the real\nexperience. Disabling the UI is recommended for automated testing.\nSupported at the embedder's discretion if UI is available.\nDefaults to false."]
+            #[serde(rename = "enableUI")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub enable_ui: Option<bool>,
+        }
+        impl EnableParams {
+            pub fn builder() -> EnableParamsBuilder {
+                EnableParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct EnableParamsBuilder {
+            enable_ui: Option<bool>,
+        }
+        impl EnableParamsBuilder {
+            pub fn enable_ui(mut self, enable_ui: impl Into<bool>) -> Self {
+                self.enable_ui = Some(enable_ui.into());
+                self
+            }
+            pub fn build(self) -> EnableParams {
+                EnableParams {
+                    enable_ui: self.enable_ui,
+                }
+            }
+        }
+        impl EnableParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.enable";
+        }
+        impl chromiumoxide_types::Method for EnableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EnableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Enable the WebAuthn domain and start intercepting credential storage and\nretrieval with a virtual authenticator.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-enable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct EnableReturns {}
+        impl chromiumoxide_types::Command for EnableParams {
+            type Response = EnableReturns;
+        }
+        #[doc = "Disable the WebAuthn domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableParams {}
+        impl DisableParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.disable";
+        }
+        impl chromiumoxide_types::Method for DisableParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for DisableParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Disable the WebAuthn domain.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-disable)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct DisableReturns {}
+        impl chromiumoxide_types::Command for DisableParams {
+            type Response = DisableReturns;
+        }
+        #[doc = "Creates and adds a virtual authenticator.\n[addVirtualAuthenticator](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-addVirtualAuthenticator)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddVirtualAuthenticatorParams {
+            #[serde(rename = "options")]
+            pub options: VirtualAuthenticatorOptions,
+        }
+        impl AddVirtualAuthenticatorParams {
+            pub fn new(options: impl Into<VirtualAuthenticatorOptions>) -> Self {
+                Self {
+                    options: options.into(),
+                }
+            }
+        }
+        impl AddVirtualAuthenticatorParams {
+            pub fn builder() -> AddVirtualAuthenticatorParamsBuilder {
+                AddVirtualAuthenticatorParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddVirtualAuthenticatorParamsBuilder {
+            options: Option<VirtualAuthenticatorOptions>,
+        }
+        impl AddVirtualAuthenticatorParamsBuilder {
+            pub fn options(mut self, options: impl Into<VirtualAuthenticatorOptions>) -> Self {
+                self.options = Some(options.into());
+                self
+            }
+            pub fn build(self) -> Result<AddVirtualAuthenticatorParams, String> {
+                Ok(AddVirtualAuthenticatorParams {
+                    options: self.options.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(options))
+                    })?,
+                })
+            }
+        }
+        impl AddVirtualAuthenticatorParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.addVirtualAuthenticator";
+        }
+        impl chromiumoxide_types::Method for AddVirtualAuthenticatorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddVirtualAuthenticatorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Creates and adds a virtual authenticator.\n[addVirtualAuthenticator](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-addVirtualAuthenticator)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddVirtualAuthenticatorReturns {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+        }
+        impl AddVirtualAuthenticatorReturns {
+            pub fn new(authenticator_id: impl Into<AuthenticatorId>) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                }
+            }
+        }
+        impl AddVirtualAuthenticatorReturns {
+            pub fn builder() -> AddVirtualAuthenticatorReturnsBuilder {
+                AddVirtualAuthenticatorReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddVirtualAuthenticatorReturnsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+        }
+        impl AddVirtualAuthenticatorReturnsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn build(self) -> Result<AddVirtualAuthenticatorReturns, String> {
+                Ok(AddVirtualAuthenticatorReturns {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for AddVirtualAuthenticatorParams {
+            type Response = AddVirtualAuthenticatorReturns;
+        }
+        #[doc = "Resets parameters isBogusSignature, isBadUV, isBadUP to false if they are not present.\n[setResponseOverrideBits](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-setResponseOverrideBits)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetResponseOverrideBitsParams {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[doc = "If isBogusSignature is set, overrides the signature in the authenticator response to be zero.\nDefaults to false."]
+            #[serde(rename = "isBogusSignature")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_bogus_signature: Option<bool>,
+            #[doc = "If isBadUV is set, overrides the UV bit in the flags in the authenticator response to\nbe zero. Defaults to false."]
+            #[serde(rename = "isBadUV")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_bad_uv: Option<bool>,
+            #[doc = "If isBadUP is set, overrides the UP bit in the flags in the authenticator response to\nbe zero. Defaults to false."]
+            #[serde(rename = "isBadUP")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub is_bad_up: Option<bool>,
+        }
+        impl SetResponseOverrideBitsParams {
+            pub fn new(authenticator_id: impl Into<AuthenticatorId>) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                    is_bogus_signature: None,
+                    is_bad_uv: None,
+                    is_bad_up: None,
+                }
+            }
+        }
+        impl SetResponseOverrideBitsParams {
+            pub fn builder() -> SetResponseOverrideBitsParamsBuilder {
+                SetResponseOverrideBitsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetResponseOverrideBitsParamsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+            is_bogus_signature: Option<bool>,
+            is_bad_uv: Option<bool>,
+            is_bad_up: Option<bool>,
+        }
+        impl SetResponseOverrideBitsParamsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn is_bogus_signature(mut self, is_bogus_signature: impl Into<bool>) -> Self {
+                self.is_bogus_signature = Some(is_bogus_signature.into());
+                self
+            }
+            pub fn is_bad_uv(mut self, is_bad_uv: impl Into<bool>) -> Self {
+                self.is_bad_uv = Some(is_bad_uv.into());
+                self
+            }
+            pub fn is_bad_up(mut self, is_bad_up: impl Into<bool>) -> Self {
+                self.is_bad_up = Some(is_bad_up.into());
+                self
+            }
+            pub fn build(self) -> Result<SetResponseOverrideBitsParams, String> {
+                Ok(SetResponseOverrideBitsParams {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                    is_bogus_signature: self.is_bogus_signature,
+                    is_bad_uv: self.is_bad_uv,
+                    is_bad_up: self.is_bad_up,
+                })
+            }
+        }
+        impl SetResponseOverrideBitsParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.setResponseOverrideBits";
+        }
+        impl chromiumoxide_types::Method for SetResponseOverrideBitsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetResponseOverrideBitsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Resets parameters isBogusSignature, isBadUV, isBadUP to false if they are not present.\n[setResponseOverrideBits](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-setResponseOverrideBits)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetResponseOverrideBitsReturns {}
+        impl chromiumoxide_types::Command for SetResponseOverrideBitsParams {
+            type Response = SetResponseOverrideBitsReturns;
+        }
+        #[doc = "Removes the given authenticator.\n[removeVirtualAuthenticator](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-removeVirtualAuthenticator)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveVirtualAuthenticatorParams {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+        }
+        impl RemoveVirtualAuthenticatorParams {
+            pub fn new(authenticator_id: impl Into<AuthenticatorId>) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                }
+            }
+        }
+        impl RemoveVirtualAuthenticatorParams {
+            pub fn builder() -> RemoveVirtualAuthenticatorParamsBuilder {
+                RemoveVirtualAuthenticatorParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveVirtualAuthenticatorParamsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+        }
+        impl RemoveVirtualAuthenticatorParamsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveVirtualAuthenticatorParams, String> {
+                Ok(RemoveVirtualAuthenticatorParams {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl RemoveVirtualAuthenticatorParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.removeVirtualAuthenticator";
+        }
+        impl chromiumoxide_types::Method for RemoveVirtualAuthenticatorParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveVirtualAuthenticatorParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes the given authenticator.\n[removeVirtualAuthenticator](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-removeVirtualAuthenticator)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveVirtualAuthenticatorReturns {}
+        impl chromiumoxide_types::Command for RemoveVirtualAuthenticatorParams {
+            type Response = RemoveVirtualAuthenticatorReturns;
+        }
+        #[doc = "Adds the credential to the specified authenticator.\n[addCredential](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-addCredential)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct AddCredentialParams {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[serde(rename = "credential")]
+            pub credential: Credential,
+        }
+        impl AddCredentialParams {
+            pub fn new(
+                authenticator_id: impl Into<AuthenticatorId>,
+                credential: impl Into<Credential>,
+            ) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                    credential: credential.into(),
+                }
+            }
+        }
+        impl AddCredentialParams {
+            pub fn builder() -> AddCredentialParamsBuilder {
+                AddCredentialParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct AddCredentialParamsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+            credential: Option<Credential>,
+        }
+        impl AddCredentialParamsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn credential(mut self, credential: impl Into<Credential>) -> Self {
+                self.credential = Some(credential.into());
+                self
+            }
+            pub fn build(self) -> Result<AddCredentialParams, String> {
+                Ok(AddCredentialParams {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                    credential: self.credential.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(credential))
+                    })?,
+                })
+            }
+        }
+        impl AddCredentialParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.addCredential";
+        }
+        impl chromiumoxide_types::Method for AddCredentialParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for AddCredentialParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Adds the credential to the specified authenticator.\n[addCredential](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-addCredential)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct AddCredentialReturns {}
+        impl chromiumoxide_types::Command for AddCredentialParams {
+            type Response = AddCredentialReturns;
+        }
+        #[doc = "Returns a single credential stored in the given virtual authenticator that\nmatches the credential ID.\n[getCredential](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-getCredential)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCredentialParams {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[serde(rename = "credentialId")]
+            pub credential_id: chromiumoxide_types::Binary,
+        }
+        impl GetCredentialParams {
+            pub fn new(
+                authenticator_id: impl Into<AuthenticatorId>,
+                credential_id: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                    credential_id: credential_id.into(),
+                }
+            }
+        }
+        impl GetCredentialParams {
+            pub fn builder() -> GetCredentialParamsBuilder {
+                GetCredentialParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCredentialParamsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+            credential_id: Option<chromiumoxide_types::Binary>,
+        }
+        impl GetCredentialParamsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn credential_id(
+                mut self,
+                credential_id: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.credential_id = Some(credential_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetCredentialParams, String> {
+                Ok(GetCredentialParams {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                    credential_id: self.credential_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(credential_id))
+                    })?,
+                })
+            }
+        }
+        impl GetCredentialParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.getCredential";
+        }
+        impl chromiumoxide_types::Method for GetCredentialParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetCredentialParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns a single credential stored in the given virtual authenticator that\nmatches the credential ID.\n[getCredential](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-getCredential)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCredentialReturns {
+            #[serde(rename = "credential")]
+            pub credential: Credential,
+        }
+        impl GetCredentialReturns {
+            pub fn new(credential: impl Into<Credential>) -> Self {
+                Self {
+                    credential: credential.into(),
+                }
+            }
+        }
+        impl GetCredentialReturns {
+            pub fn builder() -> GetCredentialReturnsBuilder {
+                GetCredentialReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCredentialReturnsBuilder {
+            credential: Option<Credential>,
+        }
+        impl GetCredentialReturnsBuilder {
+            pub fn credential(mut self, credential: impl Into<Credential>) -> Self {
+                self.credential = Some(credential.into());
+                self
+            }
+            pub fn build(self) -> Result<GetCredentialReturns, String> {
+                Ok(GetCredentialReturns {
+                    credential: self.credential.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(credential))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetCredentialParams {
+            type Response = GetCredentialReturns;
+        }
+        #[doc = "Returns all the credentials stored in the given virtual authenticator.\n[getCredentials](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-getCredentials)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCredentialsParams {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+        }
+        impl GetCredentialsParams {
+            pub fn new(authenticator_id: impl Into<AuthenticatorId>) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                }
+            }
+        }
+        impl GetCredentialsParams {
+            pub fn builder() -> GetCredentialsParamsBuilder {
+                GetCredentialsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCredentialsParamsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+        }
+        impl GetCredentialsParamsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn build(self) -> Result<GetCredentialsParams, String> {
+                Ok(GetCredentialsParams {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl GetCredentialsParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.getCredentials";
+        }
+        impl chromiumoxide_types::Method for GetCredentialsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for GetCredentialsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Returns all the credentials stored in the given virtual authenticator.\n[getCredentials](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-getCredentials)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct GetCredentialsReturns {
+            #[serde(rename = "credentials")]
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            pub credentials: Vec<Credential>,
+        }
+        impl GetCredentialsReturns {
+            pub fn new(credentials: Vec<Credential>) -> Self {
+                Self { credentials }
+            }
+        }
+        impl GetCredentialsReturns {
+            pub fn builder() -> GetCredentialsReturnsBuilder {
+                GetCredentialsReturnsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct GetCredentialsReturnsBuilder {
+            credentials: Option<Vec<Credential>>,
+        }
+        impl GetCredentialsReturnsBuilder {
+            pub fn credential(mut self, credential: impl Into<Credential>) -> Self {
+                let v = self.credentials.get_or_insert(Vec::new());
+                v.push(credential.into());
+                self
+            }
+            pub fn credentials<I, S>(mut self, credentials: I) -> Self
+            where
+                I: IntoIterator<Item = S>,
+                S: Into<Credential>,
+            {
+                let v = self.credentials.get_or_insert(Vec::new());
+                for val in credentials {
+                    v.push(val.into());
+                }
+                self
+            }
+            pub fn build(self) -> Result<GetCredentialsReturns, String> {
+                Ok(GetCredentialsReturns {
+                    credentials: self.credentials.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(credentials))
+                    })?,
+                })
+            }
+        }
+        impl chromiumoxide_types::Command for GetCredentialsParams {
+            type Response = GetCredentialsReturns;
+        }
+        #[doc = "Removes a credential from the authenticator.\n[removeCredential](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-removeCredential)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct RemoveCredentialParams {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[serde(rename = "credentialId")]
+            pub credential_id: chromiumoxide_types::Binary,
+        }
+        impl RemoveCredentialParams {
+            pub fn new(
+                authenticator_id: impl Into<AuthenticatorId>,
+                credential_id: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                    credential_id: credential_id.into(),
+                }
+            }
+        }
+        impl RemoveCredentialParams {
+            pub fn builder() -> RemoveCredentialParamsBuilder {
+                RemoveCredentialParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct RemoveCredentialParamsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+            credential_id: Option<chromiumoxide_types::Binary>,
+        }
+        impl RemoveCredentialParamsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn credential_id(
+                mut self,
+                credential_id: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.credential_id = Some(credential_id.into());
+                self
+            }
+            pub fn build(self) -> Result<RemoveCredentialParams, String> {
+                Ok(RemoveCredentialParams {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                    credential_id: self.credential_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(credential_id))
+                    })?,
+                })
+            }
+        }
+        impl RemoveCredentialParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.removeCredential";
+        }
+        impl chromiumoxide_types::Method for RemoveCredentialParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for RemoveCredentialParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Removes a credential from the authenticator.\n[removeCredential](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-removeCredential)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct RemoveCredentialReturns {}
+        impl chromiumoxide_types::Command for RemoveCredentialParams {
+            type Response = RemoveCredentialReturns;
+        }
+        #[doc = "Clears all the credentials from the specified device.\n[clearCredentials](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-clearCredentials)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct ClearCredentialsParams {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+        }
+        impl ClearCredentialsParams {
+            pub fn new(authenticator_id: impl Into<AuthenticatorId>) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                }
+            }
+        }
+        impl ClearCredentialsParams {
+            pub fn builder() -> ClearCredentialsParamsBuilder {
+                ClearCredentialsParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct ClearCredentialsParamsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+        }
+        impl ClearCredentialsParamsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn build(self) -> Result<ClearCredentialsParams, String> {
+                Ok(ClearCredentialsParams {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl ClearCredentialsParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.clearCredentials";
+        }
+        impl chromiumoxide_types::Method for ClearCredentialsParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for ClearCredentialsParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Clears all the credentials from the specified device.\n[clearCredentials](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-clearCredentials)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct ClearCredentialsReturns {}
+        impl chromiumoxide_types::Command for ClearCredentialsParams {
+            type Response = ClearCredentialsReturns;
+        }
+        #[doc = "Sets whether User Verification succeeds or fails for an authenticator.\nThe default is true.\n[setUserVerified](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-setUserVerified)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetUserVerifiedParams {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[serde(rename = "isUserVerified")]
+            pub is_user_verified: bool,
+        }
+        impl SetUserVerifiedParams {
+            pub fn new(
+                authenticator_id: impl Into<AuthenticatorId>,
+                is_user_verified: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                    is_user_verified: is_user_verified.into(),
+                }
+            }
+        }
+        impl SetUserVerifiedParams {
+            pub fn builder() -> SetUserVerifiedParamsBuilder {
+                SetUserVerifiedParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetUserVerifiedParamsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+            is_user_verified: Option<bool>,
+        }
+        impl SetUserVerifiedParamsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn is_user_verified(mut self, is_user_verified: impl Into<bool>) -> Self {
+                self.is_user_verified = Some(is_user_verified.into());
+                self
+            }
+            pub fn build(self) -> Result<SetUserVerifiedParams, String> {
+                Ok(SetUserVerifiedParams {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                    is_user_verified: self.is_user_verified.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(is_user_verified)
+                        )
+                    })?,
+                })
+            }
+        }
+        impl SetUserVerifiedParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.setUserVerified";
+        }
+        impl chromiumoxide_types::Method for SetUserVerifiedParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetUserVerifiedParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets whether User Verification succeeds or fails for an authenticator.\nThe default is true.\n[setUserVerified](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-setUserVerified)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetUserVerifiedReturns {}
+        impl chromiumoxide_types::Command for SetUserVerifiedParams {
+            type Response = SetUserVerifiedReturns;
+        }
+        #[doc = "Sets whether tests of user presence will succeed immediately (if true) or fail to resolve (if false) for an authenticator.\nThe default is true.\n[setAutomaticPresenceSimulation](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-setAutomaticPresenceSimulation)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetAutomaticPresenceSimulationParams {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[serde(rename = "enabled")]
+            pub enabled: bool,
+        }
+        impl SetAutomaticPresenceSimulationParams {
+            pub fn new(
+                authenticator_id: impl Into<AuthenticatorId>,
+                enabled: impl Into<bool>,
+            ) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                    enabled: enabled.into(),
+                }
+            }
+        }
+        impl SetAutomaticPresenceSimulationParams {
+            pub fn builder() -> SetAutomaticPresenceSimulationParamsBuilder {
+                SetAutomaticPresenceSimulationParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetAutomaticPresenceSimulationParamsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+            enabled: Option<bool>,
+        }
+        impl SetAutomaticPresenceSimulationParamsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
+                self.enabled = Some(enabled.into());
+                self
+            }
+            pub fn build(self) -> Result<SetAutomaticPresenceSimulationParams, String> {
+                Ok(SetAutomaticPresenceSimulationParams {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                    enabled: self.enabled.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(enabled))
+                    })?,
+                })
+            }
+        }
+        impl SetAutomaticPresenceSimulationParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.setAutomaticPresenceSimulation";
+        }
+        impl chromiumoxide_types::Method for SetAutomaticPresenceSimulationParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetAutomaticPresenceSimulationParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Sets whether tests of user presence will succeed immediately (if true) or fail to resolve (if false) for an authenticator.\nThe default is true.\n[setAutomaticPresenceSimulation](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-setAutomaticPresenceSimulation)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetAutomaticPresenceSimulationReturns {}
+        impl chromiumoxide_types::Command for SetAutomaticPresenceSimulationParams {
+            type Response = SetAutomaticPresenceSimulationReturns;
+        }
+        #[doc = "Allows setting credential properties.\nhttps://w3c.github.io/webauthn/#sctn-automation-set-credential-properties\n[setCredentialProperties](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-setCredentialProperties)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct SetCredentialPropertiesParams {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[serde(rename = "credentialId")]
+            pub credential_id: chromiumoxide_types::Binary,
+            #[serde(rename = "backupEligibility")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backup_eligibility: Option<bool>,
+            #[serde(rename = "backupState")]
+            #[serde(skip_serializing_if = "Option::is_none")]
+            pub backup_state: Option<bool>,
+        }
+        impl SetCredentialPropertiesParams {
+            pub fn new(
+                authenticator_id: impl Into<AuthenticatorId>,
+                credential_id: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                Self {
+                    authenticator_id: authenticator_id.into(),
+                    credential_id: credential_id.into(),
+                    backup_eligibility: None,
+                    backup_state: None,
+                }
+            }
+        }
+        impl SetCredentialPropertiesParams {
+            pub fn builder() -> SetCredentialPropertiesParamsBuilder {
+                SetCredentialPropertiesParamsBuilder::default()
+            }
+        }
+        #[derive(Default, Clone)]
+        pub struct SetCredentialPropertiesParamsBuilder {
+            authenticator_id: Option<AuthenticatorId>,
+            credential_id: Option<chromiumoxide_types::Binary>,
+            backup_eligibility: Option<bool>,
+            backup_state: Option<bool>,
+        }
+        impl SetCredentialPropertiesParamsBuilder {
+            pub fn authenticator_id(
+                mut self,
+                authenticator_id: impl Into<AuthenticatorId>,
+            ) -> Self {
+                self.authenticator_id = Some(authenticator_id.into());
+                self
+            }
+            pub fn credential_id(
+                mut self,
+                credential_id: impl Into<chromiumoxide_types::Binary>,
+            ) -> Self {
+                self.credential_id = Some(credential_id.into());
+                self
+            }
+            pub fn backup_eligibility(mut self, backup_eligibility: impl Into<bool>) -> Self {
+                self.backup_eligibility = Some(backup_eligibility.into());
+                self
+            }
+            pub fn backup_state(mut self, backup_state: impl Into<bool>) -> Self {
+                self.backup_state = Some(backup_state.into());
+                self
+            }
+            pub fn build(self) -> Result<SetCredentialPropertiesParams, String> {
+                Ok(SetCredentialPropertiesParams {
+                    authenticator_id: self.authenticator_id.ok_or_else(|| {
+                        format!(
+                            "Field `{}` is mandatory.",
+                            std::stringify!(authenticator_id)
+                        )
+                    })?,
+                    credential_id: self.credential_id.ok_or_else(|| {
+                        format!("Field `{}` is mandatory.", std::stringify!(credential_id))
+                    })?,
+                    backup_eligibility: self.backup_eligibility,
+                    backup_state: self.backup_state,
+                })
+            }
+        }
+        impl SetCredentialPropertiesParams {
+            pub const IDENTIFIER: &'static str = "WebAuthn.setCredentialProperties";
+        }
+        impl chromiumoxide_types::Method for SetCredentialPropertiesParams {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for SetCredentialPropertiesParams {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Allows setting credential properties.\nhttps://w3c.github.io/webauthn/#sctn-automation-set-credential-properties\n[setCredentialProperties](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#method-setCredentialProperties)"]
+        #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+        pub struct SetCredentialPropertiesReturns {}
+        impl chromiumoxide_types::Command for SetCredentialPropertiesParams {
+            type Response = SetCredentialPropertiesReturns;
+        }
+        #[doc = "Triggered when a credential is added to an authenticator.\n[credentialAdded](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#event-credentialAdded)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventCredentialAdded {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[serde(rename = "credential")]
+            pub credential: Credential,
+        }
+        impl EventCredentialAdded {
+            pub const IDENTIFIER: &'static str = "WebAuthn.credentialAdded";
+        }
+        impl chromiumoxide_types::Method for EventCredentialAdded {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventCredentialAdded {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Triggered when a credential is deleted, e.g. through\nPublicKeyCredential.signalUnknownCredential().\n[credentialDeleted](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#event-credentialDeleted)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventCredentialDeleted {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[serde(rename = "credentialId")]
+            pub credential_id: chromiumoxide_types::Binary,
+        }
+        impl EventCredentialDeleted {
+            pub const IDENTIFIER: &'static str = "WebAuthn.credentialDeleted";
+        }
+        impl chromiumoxide_types::Method for EventCredentialDeleted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventCredentialDeleted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Triggered when a credential is updated, e.g. through\nPublicKeyCredential.signalCurrentUserDetails().\n[credentialUpdated](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#event-credentialUpdated)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventCredentialUpdated {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[serde(rename = "credential")]
+            pub credential: Credential,
+        }
+        impl EventCredentialUpdated {
+            pub const IDENTIFIER: &'static str = "WebAuthn.credentialUpdated";
+        }
+        impl chromiumoxide_types::Method for EventCredentialUpdated {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventCredentialUpdated {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+        #[doc = "Triggered when a credential is used in a webauthn assertion.\n[credentialAsserted](https://chromedevtools.github.io/devtools-protocol/tot/WebAuthn/#event-credentialAsserted)"]
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        pub struct EventCredentialAsserted {
+            #[serde(rename = "authenticatorId")]
+            pub authenticator_id: AuthenticatorId,
+            #[serde(rename = "credential")]
+            pub credential: Credential,
+        }
+        impl EventCredentialAsserted {
+            pub const IDENTIFIER: &'static str = "WebAuthn.credentialAsserted";
+        }
+        impl chromiumoxide_types::Method for EventCredentialAsserted {
+            fn identifier(&self) -> chromiumoxide_types::MethodId {
+                Self::IDENTIFIER.into()
+            }
+        }
+        impl chromiumoxide_types::MethodType for EventCredentialAsserted {
+            fn method_id() -> chromiumoxide_types::MethodId
+            where
+                Self: Sized,
+            {
+                Self::IDENTIFIER.into()
+            }
+        }
+    }
+}
+pub mod de {
+    use serde::{de, Deserialize, Deserializer};
+    use std::str::FromStr;
+    #[doc = r" Use the `FromStr` implementation to serialize an optional value"]
+    pub fn deserialize_from_str_optional<'de, D, T>(data: D) -> Result<Option<T>, D::Error>
+    where
+        D: Deserializer<'de>,
+        T: FromStr<Err = String>,
+    {
+        deserialize_from_str(data).map(Some)
+    }
+    #[doc = r" Use the `FromStr` implementation to serialize a value"]
+    pub fn deserialize_from_str<'de, D, T>(data: D) -> Result<T, D::Error>
+    where
+        D: Deserializer<'de>,
+        T: FromStr<Err = String>,
+    {
+        let s: String = Deserialize::deserialize(data)?;
+        T::from_str(&s).map_err(de::Error::custom)
+    }
+}
diff --git a/vendor/chromiumoxide_cdp/src/lib.rs b/vendor/chromiumoxide_cdp/src/lib.rs
new file mode 100644
index 0000000..7552b76
--- /dev/null
+++ b/vendor/chromiumoxide_cdp/src/lib.rs
@@ -0,0 +1,168 @@
+use std::fmt;
+
+use crate::cdp::browser_protocol::fetch;
+use crate::cdp::browser_protocol::network::{self, CookieParam, DeleteCookiesParams};
+use crate::cdp::browser_protocol::target::CreateTargetParams;
+use crate::cdp::js_protocol::runtime::{
+    CallFunctionOnParams, EvaluateParams, ExceptionDetails, StackTrace,
+};
+use crate::revision::Revision;
+
+#[allow(clippy::multiple_bound_locations)]
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[allow(unreachable_patterns)]
+#[allow(deprecated)]
+#[rustfmt::skip]
+pub mod cdp;
+pub mod revision;
+
+// The CDP is not a stable API, it changes from time to time and sometimes
+// in backward incompatible ways.
+//
+// When the CDP changes, the chromium team pushes a commit to the repository
+// https://github.com/ChromeDevTools/devtools-protocol. There you can find
+// valid CDP revisions. That number corresponds to a chromium revision.
+// It is a monotonic version number referring to the chromium master commit position.
+//
+// To map a revision to a chromium version you can use the site
+// https://chromiumdash.appspot.com/commits. We should not necessarily
+// always use the latest revision, as this will mean only the newest chromium
+// browser can be used. Apart from breaking changes, using an older CDP
+// is generally a good idea.
+
+/// Currently built CDP revision
+pub const CURRENT_REVISION: Revision = Revision(1566079);
+
+/// convenience fixups
+impl Default for CreateTargetParams {
+    fn default() -> Self {
+        "about:blank".into()
+    }
+}
+
+/// RequestId conversion
+impl From<fetch::RequestId> for network::RequestId {
+    fn from(req: fetch::RequestId) -> Self {
+        let s: String = req.into();
+        s.into()
+    }
+}
+
+impl From<network::RequestId> for fetch::RequestId {
+    fn from(req: network::RequestId) -> Self {
+        let s: String = req.into();
+        s.into()
+    }
+}
+
+impl From<network::InterceptionId> for fetch::RequestId {
+    fn from(req: network::InterceptionId) -> Self {
+        let s: String = req.into();
+        s.into()
+    }
+}
+
+impl From<network::InterceptionId> for network::RequestId {
+    fn from(req: network::InterceptionId) -> Self {
+        let s: String = req.into();
+        s.into()
+    }
+}
+
+impl From<fetch::RequestId> for network::InterceptionId {
+    fn from(req: fetch::RequestId) -> Self {
+        let s: String = req.into();
+        s.into()
+    }
+}
+
+impl From<network::RequestId> for network::InterceptionId {
+    fn from(req: network::RequestId) -> Self {
+        let s: String = req.into();
+        s.into()
+    }
+}
+
+impl DeleteCookiesParams {
+    /// Create a new instance from a `CookieParam`
+    pub fn from_cookie(param: &CookieParam) -> Self {
+        DeleteCookiesParams {
+            name: param.name.clone(),
+            url: param.url.clone(),
+            domain: param.domain.clone(),
+            path: param.path.clone(),
+            partition_key: param.partition_key.clone(),
+        }
+    }
+}
+
+impl From<EvaluateParams> for CallFunctionOnParams {
+    fn from(params: EvaluateParams) -> CallFunctionOnParams {
+        CallFunctionOnParams {
+            function_declaration: params.expression,
+            object_id: None,
+            arguments: None,
+            silent: params.silent,
+            return_by_value: params.return_by_value,
+            generate_preview: params.generate_preview,
+            user_gesture: params.user_gesture,
+            await_promise: params.await_promise,
+            execution_context_id: params.context_id,
+            object_group: params.object_group,
+            throw_on_side_effect: None,
+            unique_context_id: None,
+            serialization_options: None,
+        }
+    }
+}
+
+impl fmt::Display for ExceptionDetails {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(
+            f,
+            "{}:{}: {}",
+            self.line_number, self.column_number, self.text
+        )?;
+
+        if let Some(stack) = self.stack_trace.as_ref() {
+            stack.fmt(f)?
+        }
+        Ok(())
+    }
+}
+
+impl std::error::Error for ExceptionDetails {}
+
+impl fmt::Display for StackTrace {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(desc) = self.description.as_ref() {
+            writeln!(f, "{desc}")?;
+        }
+        for frame in &self.call_frames {
+            writeln!(
+                f,
+                "{}@{}:{}:{}",
+                frame.function_name, frame.url, frame.line_number, frame.column_number
+            )?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use chromiumoxide_types::Message;
+
+    use super::cdp::CdpEventMessage;
+
+    // This makes sure we can parse arbitrary numbers (timestamp) as f64
+    // and that the Message untagged union works core
+    #[test]
+    fn test_event_deserialize_f64() {
+        let raw = r#"{"method":"Page.lifecycleEvent","params":{"frameId":"B0FCF18A982213C9947D313EAA8F934A","loaderId":"547DA6CC3D4A41314EA08A88BFA62B21","name":"commit","timestamp":1531.878478},"sessionId":"E0BCD37484373226136272710B8CB432"}"#;
+
+        let event = serde_json::from_str::<Message<CdpEventMessage>>(raw).unwrap();
+
+        assert!(matches!(event, Message::Event(_)));
+    }
+}
diff --git a/vendor/chromiumoxide_cdp/src/revision.rs b/vendor/chromiumoxide_cdp/src/revision.rs
new file mode 100644
index 0000000..4c55850
--- /dev/null
+++ b/vendor/chromiumoxide_cdp/src/revision.rs
@@ -0,0 +1,17 @@
+use std::fmt;
+
+/// A [`Revision`] represents a version of CDP.
+#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub struct Revision(pub(crate) u32);
+
+impl From<u32> for Revision {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl fmt::Display for Revision {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "v0.0.{}", self.0)
+    }
+}

From 2b2a7cbf19885799ce0a2f3ae6348196aab5b325 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Wed, 3 Jun 2026 15:29:52 +0200
Subject: [PATCH 26/42] Fix local browser shutdown in headless mode

---
 browser/src/participant/local/session.rs | 134 +++++++++++++++++++----
 browser/src/participant/mod.rs           | 123 ++++++++++++++++++++-
 2 files changed, 236 insertions(+), 21 deletions(-)

diff --git a/browser/src/participant/local/session.rs b/browser/src/participant/local/session.rs
index 85e0686..aacaeff 100644
--- a/browser/src/participant/local/session.rs
+++ b/browser/src/participant/local/session.rs
@@ -55,7 +55,13 @@ use std::{
         Path,
         PathBuf,
     },
-    sync::Arc,
+    sync::{
+        atomic::{
+            AtomicBool,
+            Ordering,
+        },
+        Arc,
+    },
     time::Duration,
 };
 use tokio::{
@@ -64,6 +70,7 @@ use tokio::{
         watch,
     },
     task::JoinHandle,
+    time::timeout,
 };
 
 pub(crate) struct LocalChromiumSession {
@@ -78,6 +85,7 @@ pub(crate) struct LocalChromiumSession {
     detached_target_task: Option<JoinHandle<()>>,
     termination_tx: watch::Sender<Option<DriverTermination>>,
     termination_rx: watch::Receiver<Option<DriverTermination>>,
+    closing: Arc<AtomicBool>,
 }
 
 impl LocalChromiumSession {
@@ -90,6 +98,7 @@ impl LocalChromiumSession {
     ) -> Self {
         let frontend_builder = FrontendAuth::for_kind(launch_spec.frontend_kind, auth, cookie_manager);
         let (termination_tx, termination_rx) = watch::channel(None);
+        let closing = Arc::new(AtomicBool::new(false));
 
         Self {
             launch_spec,
@@ -103,26 +112,31 @@ impl LocalChromiumSession {
             detached_target_task: None,
             termination_tx,
             termination_rx,
+            closing,
         }
     }
 
     fn log_message(&self, level: &str, message: impl ToString) {
-        let log_message = ParticipantLogMessage::new(level, &self.launch_spec.username, message);
-        log_message.write();
-        if let Err(err) = self.sender.send(log_message) {
-            trace!(
-                participant = %self.launch_spec.username,
-                "Failed to send local driver log message: {err}"
-            );
-        }
+        log_local_message(&self.sender, &self.launch_spec.username, level, message);
     }
 
     async fn start_inner(&mut self) -> Result<()> {
+        self.closing.store(false, Ordering::SeqCst);
         let (mut browser, handler) = create_browser(&self.browser_config).await?;
-        let browser_event_task = drive_browser_events(&self.launch_spec.username, handler, self.termination_tx.clone());
+        let browser_event_task = drive_browser_events(
+            &self.launch_spec.username,
+            handler,
+            self.termination_tx.clone(),
+            Arc::clone(&self.closing),
+        );
         let page = create_page_retry(&self.launch_spec, &mut browser).await?;
-        let detached_target_task =
-            drive_detached_target_events(&self.launch_spec.username, &mut browser, self.termination_tx.clone()).await?;
+        let detached_target_task = drive_detached_target_events(
+            &self.launch_spec.username,
+            &mut browser,
+            self.termination_tx.clone(),
+            Arc::clone(&self.closing),
+        )
+        .await?;
 
         let auth = self
             .frontend_builder
@@ -159,6 +173,8 @@ impl LocalChromiumSession {
     }
 
     async fn close_inner(&mut self) -> Result<()> {
+        self.closing.store(true, Ordering::SeqCst);
+
         if let Some(handle) = self.detached_target_task.take() {
             handle.abort();
         }
@@ -188,15 +204,53 @@ impl LocalChromiumSession {
             }
         }
 
-        if let Some(page) = self.page.take() {
-            if let Err(err) = page.close().await {
-                self.log_message("error", format!("Error closing page: {err}"));
-            }
-        }
+        self.page = None;
 
         if let Some(browser) = self.browser.as_mut() {
-            browser.close().await?;
-            browser.wait().await?;
+            let sender = self.sender.clone();
+            let participant_name = self.launch_spec.username.clone();
+
+            match timeout(BROWSER_CLOSE_COMMAND_TIMEOUT, browser.close()).await {
+                Ok(Ok(_)) => {}
+                Ok(Err(err)) => {
+                    log_local_message(
+                        &sender,
+                        &participant_name,
+                        "debug",
+                        format!("Browser close command failed during shutdown: {err}"),
+                    );
+                }
+                Err(_) => {
+                    log_local_message(
+                        &sender,
+                        &participant_name,
+                        "debug",
+                        "Timed out waiting for browser close command response, waiting for browser process exit",
+                    );
+                }
+            }
+
+            match timeout(BROWSER_EXIT_TIMEOUT, browser.wait()).await {
+                Ok(Ok(_)) => {}
+                Ok(Err(err)) => {
+                    log_local_message(
+                        &sender,
+                        &participant_name,
+                        "error",
+                        format!("Failed waiting for browser process to exit: {err}"),
+                    );
+                    self.kill_browser().await;
+                }
+                Err(_) => {
+                    log_local_message(
+                        &sender,
+                        &participant_name,
+                        "warn",
+                        "Timed out waiting for browser process to exit, killing browser",
+                    );
+                    self.kill_browser().await;
+                }
+            }
         }
 
         if let Some(handle) = self.browser_event_task.take() {
@@ -212,6 +266,8 @@ impl LocalChromiumSession {
     }
 
     async fn kill_browser(&mut self) {
+        self.closing.store(true, Ordering::SeqCst);
+
         if let Some(handle) = self.detached_target_task.take() {
             handle.abort();
         }
@@ -273,6 +329,8 @@ impl ParticipantDriverSession for LocalChromiumSession {
 }
 
 const CHROME_BINARY_NAMES: &[&str] = &["chromium", "google-chrome", "google-chrome-stable", "chrome"];
+const BROWSER_CLOSE_COMMAND_TIMEOUT: Duration = Duration::from_secs(1);
+const BROWSER_EXIT_TIMEOUT: Duration = Duration::from_secs(2);
 #[cfg(any(test, target_os = "macos"))]
 const MACOS_GOOGLE_CHROME_APP_BINARY: &str = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
 #[cfg(any(test, target_os = "macos"))]
@@ -366,6 +424,22 @@ fn is_executable_file(path: &Path) -> bool {
     }
 }
 
+fn log_local_message(
+    sender: &UnboundedSender<ParticipantLogMessage>,
+    participant_name: &str,
+    level: &str,
+    message: impl ToString,
+) {
+    let log_message = ParticipantLogMessage::new(level, participant_name, message);
+    log_message.write();
+    if let Err(err) = sender.send(log_message) {
+        trace!(
+            participant = %participant_name,
+            "Failed to send local driver log message: {err}"
+        );
+    }
+}
+
 async fn create_browser(browser_config: &BrowserConfig) -> Result<(Browser, Handler)> {
     let binary = get_binary()?;
 
@@ -564,13 +638,22 @@ fn drive_browser_events(
     name: &str,
     mut handler: Handler,
     termination_tx: watch::Sender<Option<DriverTermination>>,
+    closing: Arc<AtomicBool>,
 ) -> JoinHandle<()> {
     let participant_name = name.to_string();
     tokio::spawn(async move {
         while let Some(event) = handler.next().await {
             if let Err(err) = event {
+                if closing.load(Ordering::SeqCst) {
+                    debug!(
+                        participant = %participant_name,
+                        "Browser event handler stopped during shutdown: {err:?}"
+                    );
+                    break;
+                }
+
                 if err.to_string().contains("ResetWithoutClosingHandshake") {
-                    error!(participant = %participant_name, "Browser unexpectedly closed");
+                    warn!(participant = %participant_name, "Browser unexpectedly closed");
                     signal_termination(
                         &termination_tx,
                         DriverTermination::new("warn", "Browser unexpectedly closed"),
@@ -579,6 +662,11 @@ fn drive_browser_events(
                 }
 
                 error!(participant = %participant_name, "error in browser handler: {err:?}");
+                signal_termination(
+                    &termination_tx,
+                    DriverTermination::new("error", format!("error in browser handler: {err:?}")),
+                );
+                break;
             }
         }
 
@@ -590,6 +678,7 @@ async fn drive_detached_target_events(
     name: &str,
     browser: &mut Browser,
     termination_tx: watch::Sender<Option<DriverTermination>>,
+    closing: Arc<AtomicBool>,
 ) -> Result<JoinHandle<()>> {
     let participant_name = Arc::new(name.to_string());
     let mut detached_event = browser
@@ -599,6 +688,11 @@ async fn drive_detached_target_events(
 
     Ok(tokio::spawn(async move {
         if detached_event.next().await.is_some() {
+            if closing.load(Ordering::SeqCst) {
+                debug!(participant = %participant_name, "Browser target detached during shutdown");
+                return;
+            }
+
             warn!(participant = %participant_name, "Browser unexpectedly closed");
             signal_termination(
                 &termination_tx,
diff --git a/browser/src/participant/mod.rs b/browser/src/participant/mod.rs
index 8ce3f09..84b232b 100644
--- a/browser/src/participant/mod.rs
+++ b/browser/src/participant/mod.rs
@@ -66,6 +66,7 @@ pub struct Participant {
     pub state: watch::Receiver<ParticipantState>,
     _participant_task_guard: Arc<DropGuard>,
     sender: UnboundedSender<ParticipantMessage>,
+    close_strategy: CloseStrategy,
 }
 
 impl PartialEq for Participant {
@@ -74,6 +75,12 @@ impl PartialEq for Participant {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum CloseStrategy {
+    DriverCloseOnly,
+    LeaveBeforeClose,
+}
+
 impl Participant {
     pub fn spawn_with_app_config(config: &Config, cookie_manager: HyperSessionCookieManger) -> Result<Self> {
         let (participant, _) = Self::spawn_with_app_config_and_receiver(config, cookie_manager)?;
@@ -128,6 +135,7 @@ impl Participant {
                 state: state_receiver,
                 _participant_task_guard: task_guard,
                 sender: sender_tx,
+                close_strategy: CloseStrategy::DriverCloseOnly,
             },
             receiver_rx,
         ))
@@ -157,6 +165,7 @@ impl Participant {
             state: state_receiver,
             _participant_task_guard: task_guard,
             sender,
+            close_strategy: CloseStrategy::DriverCloseOnly,
         })
     }
 
@@ -194,6 +203,7 @@ impl Participant {
             state: state_receiver,
             _participant_task_guard: task_guard,
             sender,
+            close_strategy: CloseStrategy::LeaveBeforeClose,
         })
     }
 
@@ -254,6 +264,7 @@ impl Participant {
             state: state_receiver,
             _participant_task_guard: task_guard,
             sender,
+            close_strategy: CloseStrategy::DriverCloseOnly,
         })
     }
 }
@@ -310,7 +321,7 @@ impl Participant {
             return;
         }
 
-        if initial_state.joined {
+        if self.close_strategy == CloseStrategy::LeaveBeforeClose && initial_state.joined {
             if self.sender.send(ParticipantMessage::Leave).is_err() {
                 error!(participant = %self.name, "Was not able to send ParticipantMessage::Leave message");
             } else {
@@ -426,3 +437,113 @@ impl Participant {
         self.send_message(ParticipantMessage::ToggleBackgroundBlur);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::participant::shared::{
+        DriverTermination,
+        ParticipantState,
+    };
+    use futures::{
+        future::BoxFuture,
+        FutureExt as _,
+    };
+    use std::{
+        future::pending,
+        sync::{
+            atomic::{
+                AtomicUsize,
+                Ordering,
+            },
+            Arc,
+            Mutex,
+        },
+    };
+    use tokio::sync::mpsc::unbounded_channel;
+
+    struct RecordingCloseDriver {
+        commands: Arc<Mutex<Vec<ParticipantMessage>>>,
+        close_count: Arc<AtomicUsize>,
+    }
+
+    impl ParticipantDriverSession for RecordingCloseDriver {
+        fn participant_name(&self) -> &str {
+            "sim-user"
+        }
+
+        fn start(&mut self) -> BoxFuture<'_, Result<()>> {
+            async move { Ok(()) }.boxed()
+        }
+
+        fn handle_command(&mut self, message: ParticipantMessage) -> BoxFuture<'_, Result<()>> {
+            async move {
+                self.commands.lock().unwrap().push(message);
+                Ok(())
+            }
+            .boxed()
+        }
+
+        fn refresh_state(&mut self) -> BoxFuture<'_, Result<ParticipantState>> {
+            async move {
+                Ok(ParticipantState {
+                    username: "sim-user".to_string(),
+                    running: true,
+                    joined: true,
+                    ..Default::default()
+                })
+            }
+            .boxed()
+        }
+
+        fn close(&mut self) -> BoxFuture<'_, Result<()>> {
+            async move {
+                self.close_count.fetch_add(1, Ordering::SeqCst);
+                Ok(())
+            }
+            .boxed()
+        }
+
+        fn wait_for_termination(&mut self) -> BoxFuture<'_, DriverTermination> {
+            async move { pending::<DriverTermination>().await }.boxed()
+        }
+    }
+
+    #[tokio::test]
+    async fn close_uses_driver_close_without_sending_leave_first() {
+        let (command_tx, command_rx) = unbounded_channel();
+        let (log_tx, _log_rx) = unbounded_channel();
+        let commands = Arc::new(Mutex::new(Vec::new()));
+        let close_count = Arc::new(AtomicUsize::new(0));
+        let (state, task_guard) = spawn_session(
+            "sim-user".to_string(),
+            command_rx,
+            log_tx,
+            RecordingCloseDriver {
+                commands: Arc::clone(&commands),
+                close_count: Arc::clone(&close_count),
+            },
+        );
+
+        let participant = Participant {
+            name: "sim-user".to_string(),
+            created: Utc::now(),
+            state,
+            _participant_task_guard: task_guard,
+            sender: command_tx,
+            close_strategy: CloseStrategy::DriverCloseOnly,
+        };
+
+        participant
+            .state
+            .clone()
+            .wait_for(|state| state.running && state.joined)
+            .await
+            .unwrap();
+
+        participant.close().await;
+
+        assert_eq!(close_count.load(Ordering::SeqCst), 1);
+        assert!(commands.lock().unwrap().is_empty());
+    }
+}

From acb3e7237e2194a3d9db6dd36e121e1e1cddd57b Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Wed, 3 Jun 2026 15:41:55 +0200
Subject: [PATCH 27/42] Add headless simulator project skill

---
 .codex/skills/run-headless-simulator/SKILL.md | 150 ++++++++++++++++++
 .../run-headless-simulator/agents/openai.yaml |   4 +
 2 files changed, 154 insertions(+)
 create mode 100644 .codex/skills/run-headless-simulator/SKILL.md
 create mode 100644 .codex/skills/run-headless-simulator/agents/openai.yaml

diff --git a/.codex/skills/run-headless-simulator/SKILL.md b/.codex/skills/run-headless-simulator/SKILL.md
new file mode 100644
index 0000000..96abc54
--- /dev/null
+++ b/.codex/skills/run-headless-simulator/SKILL.md
@@ -0,0 +1,150 @@
+---
+name: run-headless-simulator
+description: Run hyper-client-simulator participants from the CLI without the TUI. Use for agent-friendly headless smoke tests, multi-participant runs, and backend startup checks.
+---
+
+# Run Headless Simulator
+
+## Overview
+
+Use the `headless` subcommand when an agent or script needs to run simulator participants without the interactive TUI. In the repo, prefer the development command through Cargo; for an installed release, call the binary directly.
+
+```sh
+cargo run -- headless [OPTIONS]
+hyper-client-simulator headless [OPTIONS]
+```
+
+Run from the Nix devshell when possible so Chromium, FFmpeg, native libraries, and the Rust toolchain match the repository environment.
+
+## Basic Usage
+
+Start one participant from global CLI settings:
+
+```sh
+cargo run -- headless \
+  --url https://latest.dev.hyper.video/0Y6-6FZ-20J \
+  --backend local \
+  --headless true \
+  --audio-enabled true \
+  --video-enabled true
+```
+
+Start one backend-only smoke test that does not require Chromium:
+
+```sh
+cargo run -- headless \
+  --url https://example.com/lite/demo \
+  --participant '{"backend":"remote-stub","audio_enabled":false}'
+```
+
+Start multiple participants by repeating `--participant`:
+
+```sh
+cargo run -- headless \
+  --url https://latest.dev.hyper.video/F27-T5F-DXY \
+  --participant '{"backend":"local","audio_enabled":false}' \
+  --participant '{"backend":"cloudflare","audio_enabled":true}'
+```
+
+## Configuration Model
+
+- Global CLI flags apply to the base config loaded by the simulator.
+- If no `--participant` values are passed, `headless` starts one participant from the effective global config.
+- Each repeated `--participant` JSON value clones the effective global config and applies only that participant's overrides.
+- CLI overrides and participant JSON overrides are in-memory only; `headless` does not persist them back to the config file.
+- Logs print through normal tracing output rather than the TUI logger.
+- First `Ctrl-C` requests shutdown and waits for participants to stop; a second `Ctrl-C` exits with code `130`.
+
+## Options
+
+Global CLI option names use kebab-case:
+
+- `--url URL`
+- `--backend BACKEND`
+- `--headless true|false`
+- `--audio-enabled true|false`
+- `--video-enabled true|false`
+- `--screenshare-enabled true|false`
+- `--auto-gain-control true|false`
+- `--noise-suppression MODEL`
+- `--transport MODE`
+- `--video-constraint-publish-webcam CONSTRAINT`
+- `--video-constraint-subscribe CONSTRAINT`
+- `--video-max-concurrent-tracks TRACKS`
+- `--blur true|false`
+- `--participant JSON`
+
+Participant JSON field names use snake_case:
+
+- `url`
+- `backend`
+- `headless`
+- `audio_enabled`
+- `video_enabled`
+- `screenshare_enabled`
+- `auto_gain_control`
+- `noise_suppression`
+- `transport`
+- `video_constraint_publish_webcam`
+- `video_constraint_subscribe`
+- `video_max_concurrent_tracks`
+- `blur`
+
+Participant JSON denies unknown fields. Treat typos as command errors, not ignored settings.
+
+## Values
+
+Backend values:
+
+- `local`
+- `cloudflare`
+- `remote-stub`
+- `aws-device-farm`
+
+Transport values:
+
+- `webtransport`
+- `webrtc`
+
+Video constraint values:
+
+- `none`
+- `90p`
+- `144p`
+- `240p`
+- `360p`
+- `480p`
+- `720p`
+- `1080p`
+- `1440p`
+- `2160p`
+
+Noise suppression values:
+
+- `none`
+- `deepfilternet`
+- `rnnoise`
+- `iris-carthy`
+- `krisp-high`
+- `krisp-medium`
+- `krisp-low`
+- `krisp-high-with-bvc`
+- `krisp-medium-with-bvc`
+- `ai-coustics-sparrow-xxs`
+- `ai-coustics-sparrow-xs`
+- `ai-coustics-sparrow-s`
+- `ai-coustics-sparrow-l`
+- `ai-coustics-sparrow-xxs-48khz`
+- `ai-coustics-sparrow-xs-48khz`
+- `ai-coustics-rook-s-48khz`
+- `ai-coustics-rook-l-48khz`
+
+Use an integer for `--video-max-concurrent-tracks` or JSON `video_max_concurrent_tracks`. In participant JSON, `null` is treated as absent and therefore inherits the global value; it does not clear a global track limit.
+
+## Agent Workflow
+
+1. Prefer `remote-stub` for a fast smoke test when browser automation is not the thing under test.
+2. Use `local` for real Chromium-driven joining, and confirm the target Hyper frontend exposes the media settings used by video constraints.
+3. Put common settings in global CLI flags, then use repeated `--participant` JSON for per-participant differences.
+4. Keep JSON compact and quote it with single quotes in shell commands.
+5. Check `cargo run -- headless --help` or `hyper-client-simulator headless --help` if the command rejects a flag.
diff --git a/.codex/skills/run-headless-simulator/agents/openai.yaml b/.codex/skills/run-headless-simulator/agents/openai.yaml
new file mode 100644
index 0000000..d18f22a
--- /dev/null
+++ b/.codex/skills/run-headless-simulator/agents/openai.yaml
@@ -0,0 +1,4 @@
+interface:
+  display_name: "Run Headless Simulator"
+  short_description: "Run simulator participants without the TUI"
+  default_prompt: "Use $run-headless-simulator to run hyper-client-simulator participants directly from the CLI with the headless command."

From 7f0197360eeac3d265bc436d51cdc27e375c4fce Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Wed, 3 Jun 2026 15:42:28 +0200
Subject: [PATCH 28/42] untrack 2026-06-01-no-tui-mode.md,
 2026-06-02-new-video-constraints-support.org

---
 2026-06-01-no-tui-mode.md                    |  460 ------
 2026-06-02-new-video-constraints-support.org | 1429 ------------------
 2 files changed, 1889 deletions(-)
 delete mode 100644 2026-06-01-no-tui-mode.md
 delete mode 100644 2026-06-02-new-video-constraints-support.org

diff --git a/2026-06-01-no-tui-mode.md b/2026-06-01-no-tui-mode.md
deleted file mode 100644
index 4729f99..0000000
--- a/2026-06-01-no-tui-mode.md
+++ /dev/null
@@ -1,460 +0,0 @@
-# Headless Command Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development or superpowers:executing-plans to implement this plan task-by-task.
-
-**Goal:** Add `hyper-client-simulator headless` so simulator participants can be started from CLI arguments without entering the TUI or saving runtime options back to the app config.
-
-**Architecture:** Keep headless behavior local to the root binary. Load the existing `Config` once through the current config path, apply typed CLI overrides in memory, clone that config per participant, apply each participant JSON override in memory, spawn participants through `ParticipantStore`, and handle shutdown with a small `tokio::select!` loop.
-
-**Tech Stack:** Rust 2021, `clap`, `serde`, `serde_json`, `tokio`, `tracing-subscriber`, existing `client-simulator-config` and `client-simulator-browser` crates.
-
----
-
-## Scope
-
-Initial participant JSON supports stable launch fields:
-
-- `url`
-- `backend`
-- `headless`
-- `audio_enabled`
-- `video_enabled`
-- `screenshare_enabled`
-- `auto_gain_control`
-- `noise_suppression`
-- `transport`
-- `resolution`
-- `blur`
-
-Nested backend service configs such as `cloudflare` and `device_farm` stay out of the initial implementation. Existing app config/global defaults still provide those values. Add nested per-participant backend overrides later only if a concrete workflow needs them.
-
-If no `--participant` is supplied, start one participant using the global effective config. If one or more `--participant` values are supplied, start exactly one participant per JSON object.
-
----
-
-### Task 1: Add Headless CLI Types and Override Logic
-
-**Files:**
-- Modify: `Cargo.toml`
-- Create: `src/headless.rs`
-
-1. Add root-crate dependencies if missing:
-
-```toml
-serde.workspace = true
-```
-
-2. Create `src/headless.rs` with headless args, participant JSON overrides, and direct apply helpers.
-
-Use typed fields. Prefer clap parsers that accept the intended UX:
-
-```rust
-#[derive(clap::Args, Debug, Clone, Default)]
-pub struct HeadlessArgs {
-    #[clap(long, value_name = "URL")]
-    pub url: Option<url::Url>,
-
-    #[clap(long, value_name = "BACKEND")]
-    pub backend: Option<client_simulator_config::ParticipantBackendKind>,
-
-    #[clap(long = "headless", value_parser = clap::builder::BoolishValueParser::new())]
-    pub headless: Option<bool>,
-
-    #[clap(long = "audio-enabled", value_parser = clap::builder::BoolishValueParser::new())]
-    pub audio_enabled: Option<bool>,
-
-    #[clap(long = "video-enabled", value_parser = clap::builder::BoolishValueParser::new())]
-    pub video_enabled: Option<bool>,
-
-    #[clap(long = "screenshare-enabled", value_parser = clap::builder::BoolishValueParser::new())]
-    pub screenshare_enabled: Option<bool>,
-
-    #[clap(long = "auto-gain-control", value_parser = clap::builder::BoolishValueParser::new())]
-    pub auto_gain_control: Option<bool>,
-
-    #[clap(long = "noise-suppression", value_name = "MODEL")]
-    pub noise_suppression: Option<client_simulator_config::NoiseSuppression>,
-
-    #[clap(long, value_name = "MODE")]
-    pub transport: Option<client_simulator_config::TransportMode>,
-
-    #[clap(long, value_name = "RESOLUTION")]
-    pub resolution: Option<client_simulator_config::WebcamResolution>,
-
-    #[clap(long, value_parser = clap::builder::BoolishValueParser::new())]
-    pub blur: Option<bool>,
-
-    #[clap(long = "participant", value_name = "JSON")]
-    pub participants: Vec<String>,
-}
-```
-
-If one of the config enums does not satisfy clap's `FromStr` bounds cleanly, keep that field as `Option<String>` and parse it with the enum's existing `FromStr` implementation inside `apply_cli_overrides`, returning an `eyre` error with the flag name.
-
-3. Add the participant override type:
-
-```rust
-#[derive(Debug, Clone, Default, serde::Deserialize)]
-#[serde(default, deny_unknown_fields)]
-struct ParticipantOverride {
-    url: Option<url::Url>,
-    backend: Option<client_simulator_config::ParticipantBackendKind>,
-    headless: Option<bool>,
-    audio_enabled: Option<bool>,
-    video_enabled: Option<bool>,
-    screenshare_enabled: Option<bool>,
-    auto_gain_control: Option<bool>,
-    noise_suppression: Option<client_simulator_config::NoiseSuppression>,
-    transport: Option<client_simulator_config::TransportMode>,
-    resolution: Option<client_simulator_config::WebcamResolution>,
-    blur: Option<bool>,
-}
-```
-
-4. Add direct override helpers:
-
-```rust
-fn apply_cli_overrides(config: &mut client_simulator_config::Config, args: &HeadlessArgs) {
-    if let Some(url) = &args.url {
-        config.url = Some(url.clone());
-    }
-    if let Some(backend) = args.backend {
-        config.backend = backend;
-    }
-    if let Some(headless) = args.headless {
-        config.headless = headless;
-    }
-    if let Some(audio_enabled) = args.audio_enabled {
-        config.audio_enabled = audio_enabled;
-    }
-    if let Some(video_enabled) = args.video_enabled {
-        config.video_enabled = video_enabled;
-    }
-    if let Some(screenshare_enabled) = args.screenshare_enabled {
-        config.screenshare_enabled = screenshare_enabled;
-    }
-    if let Some(auto_gain_control) = args.auto_gain_control {
-        config.auto_gain_control = auto_gain_control;
-    }
-    if let Some(noise_suppression) = args.noise_suppression {
-        config.noise_suppression = noise_suppression;
-    }
-    if let Some(transport) = args.transport {
-        config.transport = transport;
-    }
-    if let Some(resolution) = args.resolution {
-        config.resolution = resolution;
-    }
-    if let Some(blur) = args.blur {
-        config.blur = blur;
-    }
-}
-
-fn apply_participant_override(
-    mut config: client_simulator_config::Config,
-    override_: ParticipantOverride,
-) -> client_simulator_config::Config {
-    if let Some(url) = override_.url {
-        config.url = Some(url);
-    }
-    if let Some(backend) = override_.backend {
-        config.backend = backend;
-    }
-    if let Some(headless) = override_.headless {
-        config.headless = headless;
-    }
-    if let Some(audio_enabled) = override_.audio_enabled {
-        config.audio_enabled = audio_enabled;
-    }
-    if let Some(video_enabled) = override_.video_enabled {
-        config.video_enabled = video_enabled;
-    }
-    if let Some(screenshare_enabled) = override_.screenshare_enabled {
-        config.screenshare_enabled = screenshare_enabled;
-    }
-    if let Some(auto_gain_control) = override_.auto_gain_control {
-        config.auto_gain_control = auto_gain_control;
-    }
-    if let Some(noise_suppression) = override_.noise_suppression {
-        config.noise_suppression = noise_suppression;
-    }
-    if let Some(transport) = override_.transport {
-        config.transport = transport;
-    }
-    if let Some(resolution) = override_.resolution {
-        config.resolution = resolution;
-    }
-    if let Some(blur) = override_.blur {
-        config.blur = blur;
-    }
-    config
-}
-```
-
-5. Add focused tests in `src/headless.rs`:
-
-- CLI parsing accepts the user-shaped command with repeated `--participant`.
-- CLI bool options accept explicit values, for example `--headless false`.
-- participant JSON overrides global config.
-- unknown participant JSON field returns an error.
-- empty participant list returns one effective config.
-
-Run:
-
-```bash
-cargo test -p hyper-client-simulator headless
-```
-
----
-
-### Task 2: Implement the Headless Runner
-
-**Files:**
-- Modify: `src/headless.rs`
-
-1. Add `run(args, debug) -> eyre::Result<i32>`.
-
-Implementation shape:
-
-```rust
-pub async fn run(args: HeadlessArgs, debug: u8) -> eyre::Result<i32> {
-    init_logging(debug)?;
-
-    let mut global_config = client_simulator_config::Config::new(client_simulator_config::TuiArgs::default())?;
-    apply_cli_overrides(&mut global_config, &args);
-
-    let participant_configs = build_participant_configs(global_config.clone(), &args.participants)?;
-    let store = client_simulator_browser::participant::ParticipantStore::new(global_config.data_dir());
-
-    for config in &participant_configs {
-        store.spawn(config)?;
-    }
-
-    Ok(wait_for_exit(store).await)
-}
-```
-
-This uses the existing config/default loading path but never calls `Config::save()` or `Config::update_from_args()`.
-
-2. Add `build_participant_configs`:
-
-```rust
-fn build_participant_configs(
-    global_config: client_simulator_config::Config,
-    participants: &[String],
-) -> eyre::Result<Vec<client_simulator_config::Config>> {
-    if participants.is_empty() {
-        return Ok(vec![global_config]);
-    }
-
-    participants
-        .iter()
-        .map(|json| {
-            let override_: ParticipantOverride = serde_json::from_str(json)?;
-            Ok(apply_participant_override(global_config.clone(), override_))
-        })
-        .collect()
-}
-```
-
-Wrap JSON errors with context containing `--participant` so invalid input is easy to diagnose.
-
-3. Add logging with normal `tracing_subscriber`, not `tui_logger`:
-
-```rust
-fn init_logging(debug: u8) -> eyre::Result<()> {
-    use tracing_subscriber::{
-        fmt::{
-            self,
-            writer::MakeWriterExt as _,
-        },
-        prelude::*,
-        EnvFilter,
-    };
-
-    let filter = match debug {
-        0 => "info",
-        1 => "debug",
-        _ => "trace",
-    };
-    let writer = std::io::stderr
-        .with_min_level(tracing::Level::WARN)
-        .or_else(std::io::stdout);
-
-    tracing_subscriber::registry()
-        .with(tracing_error::ErrorLayer::default())
-        .with(fmt::layer().with_writer(writer).with_filter(EnvFilter::builder().parse_lossy(filter)))
-        .try_init()?;
-
-    Ok(())
-}
-```
-
-4. Add shutdown behavior:
-
-```rust
-async fn wait_for_exit(store: client_simulator_browser::participant::ParticipantStore) -> i32 {
-    tokio::select! {
-        _ = wait_for_all_stopped(&store) => 0,
-        _ = wait_for_ctrl_c() => {
-            tracing::info!("Shutting down participants. Press Ctrl-C again to force exit.");
-            tokio::select! {
-                _ = store.shutdown_all() => 0,
-                _ = wait_for_ctrl_c() => 130,
-            }
-        }
-    }
-}
-
-async fn wait_for_ctrl_c() {
-    if let Err(err) = tokio::signal::ctrl_c().await {
-        tracing::error!("Failed to listen for Ctrl-C: {err}");
-    }
-}
-
-async fn wait_for_all_stopped(store: &client_simulator_browser::participant::ParticipantStore) {
-    let mut states = store
-        .values()
-        .into_iter()
-        .map(|participant| participant.state.clone())
-        .collect::<Vec<_>>();
-
-    for state in &mut states {
-        let _ = state.wait_for(|current| !current.running).await;
-    }
-}
-```
-
-5. Add a small pure shutdown-coordination test if desired. Do not spawn local Chromium in unit tests. Use injected futures or channels to verify "first signal starts shutdown" and "second signal returns 130".
-
-Run:
-
-```bash
-cargo test -p hyper-client-simulator headless
-```
-
----
-
-### Task 3: Wire the Command in `main`
-
-**Files:**
-- Modify: `src/main.rs`
-
-1. Add the module:
-
-```rust
-mod headless;
-```
-
-2. Add the subcommand:
-
-```rust
-#[derive(Subcommand, Debug)]
-enum Command {
-    /// Start the TUI application
-    Tui(TuiArgs),
-    /// Start simulator participants without the TUI
-    Headless(headless::HeadlessArgs),
-    /// Connect to the hyper server to get a hyper session cookie
-    Cookie(CookieArgs),
-}
-```
-
-3. Route the command:
-
-```rust
-Some(Command::Headless(args)) => {
-    let code = headless::run(args, debug).await?;
-    std::process::exit(code);
-}
-```
-
-4. Add or keep a CLI parsing test proving the example shape works:
-
-```rust
-#[test]
-fn parses_headless_command_with_repeated_participants() {
-    let args = CliArgs::parse_from([
-        "hyper-client-simulator",
-        "--debug",
-        "headless",
-        "--url",
-        "https://latest.dev.hyper.video/F27-T5F-DXY",
-        "--participant",
-        r#"{"audio_enabled": false, "backend": "local"}"#,
-        "--participant",
-        r#"{"audio_enabled": true, "backend": "cloudflare"}"#,
-    ]);
-
-    match args.command {
-        Some(Command::Headless(headless)) => {
-            assert_eq!(args.debug, 1);
-            assert_eq!(headless.url.as_ref().map(url::Url::as_str), Some("https://latest.dev.hyper.video/F27-T5F-DXY"));
-            assert_eq!(headless.participants.len(), 2);
-        }
-        other => panic!("expected headless command, got {other:?}"),
-    }
-}
-```
-
-Run:
-
-```bash
-cargo test -p hyper-client-simulator parses_headless_command_with_repeated_participants
-```
-
----
-
-### Task 4: Verify End to End
-
-**Files:**
-- No new files.
-
-Run formatting, linting, and tests:
-
-```bash
-just fmt
-just clippy
-just test
-```
-
-Manual smoke test with a backend that does not require Chromium:
-
-```bash
-cargo run -- headless \
-  --url "https://example.com/lite/demo" \
-  --participant '{"backend": "remote-stub", "audio_enabled": false}'
-```
-
-Expected:
-
-- logs print in the terminal without entering TUI mode
-- no config file is written from CLI overrides
-- first `Ctrl-C` starts participant shutdown and exits cleanly
-- second `Ctrl-C` exits with code `130`
-
-Manual example matching the requested command shape:
-
-```bash
-cargo run -- headless \
-  --url "https://latest.dev.hyper.video/F27-T5F-DXY" \
-  --participant '{"audio_enabled": false, "backend": "local"}' \
-  --participant '{"audio_enabled": true, "backend": "cloudflare"}'
-```
-
-Expected:
-
-- two participants start
-- each participant receives the global URL
-- each participant JSON overrides its own audio/backend settings
-- logs stream to stdout/stderr through tracing
-
----
-
-## Non-Goals
-
-- No TUI changes.
-- No config crate changes unless implementation proves a small `Config::load()` helper is necessary.
-- No config persistence from `headless`.
-- No nested per-participant `cloudflare` or `device_farm` overrides in the first version.
-- No broad refactor of participant spawning or logging.
diff --git a/2026-06-02-new-video-constraints-support.org b/2026-06-02-new-video-constraints-support.org
deleted file mode 100644
index 361db74..0000000
--- a/2026-06-02-new-video-constraints-support.org
+++ /dev/null
@@ -1,1429 +0,0 @@
-#+TITLE: New Video Constraints Support Implementation Plan
-#+DATE: [2026-06-02 Tue]
-#+FILETAGS: :implementation_plan:video_constraints:
-
-#+BEGIN_QUOTE
-For agentic workers: REQUIRED SUB-SKILL: Use =superpowers:subagent-driven-development= (recommended) or =superpowers:executing-plans= to implement this plan task-by-task. Steps use checkbox syntax for tracking.
-#+END_QUOTE
-
-* Goal
-
-Replace simulator support for the removed Hyper Core webcam encoder resolution setting with the current media settings:
-
-- =videoConstraintPublishWebcam=: outgoing webcam max-resolution option.
-- =videoConstraintSubscribe=: incoming max-resolution option.
-- =videoMaxConcurrentTracks=: max number of outgoing video tracks per local video stream, or =null= for unlimited.
-
-This spans TWO repositories:
-
-1. The simulator: [[file:/Users/robert/projects/shuttle/simulator/hyper-browser-simulator][hyper-browser-simulator]] (this repo).
-2. The Cloudflare worker: [[file:/Users/robert/projects/shuttle/simulator/cloudflare-browser-simulator][cloudflare-browser-simulator]] (sibling repo) — the remote backend the simulator's =cloudflare= participant type talks to. The worker is currently broken against the live Hyper SDK anyway: it still calls the removed =hyper.settings.videoCodec.actions.setVideoResolutionForWebcamEncoder= API, so it must be updated regardless.
-
-* Decisions (resolved during planning)
-
-- *Worker:* update the worker repo too, for full parity. The simulator's bundled OpenAPI is generated output, vendored from the worker.
-- *OpenAPI sync:* worker-first. Change worker Zod + controls, run =just export-openapi= (chanfana), then *full re-vendor* of the regenerated JSON into the simulator. The simulator's vendored copy is already stale (=0.3.0= vs worker =0.4.1=), so re-vendoring moves it to the current version and may surface unrelated drift that needs simulator-side fixups.
-- *Deploy:* all worker + simulator code changes and regenerated artifacts land in this work. The outward-facing =just deploy-worker= and the live =cloudflare=-backend smoke test are a MANUAL step the maintainer runs/approves — do not deploy automatically.
-- *Wire casing:* standardize on =1080p= (digits-then-=p=) everywhere — worker Zod, OpenAPI, browser commands. This is the literal string the page's =setVideoConstraintPublishWebcam= expects. Drop the old =p1080= (=p=-then-digits) casing.
-- *Default:* =none= / =none= / =null= (unconstrained), matching the SDK. Closest equivalent to the old =auto=.
-- *Nullable semantics:* =null= = absent = "no override". Fields are plain =Option<usize>= (NOT double-option). Consequence: a participant cannot force a numeric global back to unlimited via CLI/JSON; to get unlimited, omit the field / rely on the default.
-- *Max-tracks presets (TUI):* drop the unreachable =Custom=. Presets are =Unlimited / 1 / 2 / 3 / 4=. Off-list live values (e.g. =8= from config) fall back to =Unlimited= for the selector's preselection only; the table still displays the true number.
-- *Participants table:* replace the single =Resolution= column with ONE combined column (12 columns total, not 14). Format =out:480p in:720p t:2=; unlimited shows =t:∞=. Header "Video constraints".
-- *TUI per-participant edit:* the single =r= key opens a small chooser sub-menu (Outgoing / Incoming / Track limit), then opens the value list for the chosen setting.
-
-* Architecture
-
-Treat the new controls as media settings, not video codec settings. The active local-browser JavaScript API should read and write =window.hyper.settings.media= through =setVideoConstraintPublishWebcam=, =setVideoConstraintSubscribe=, and =setVideoMaxConcurrentTracks=.
-
-Replace the simulator's old single =resolution= setting throughout the active config, participant launch settings, participant state, headless CLI, remote-stub backend, and TUI surfaces. Keep the Cloudflare backend in sync by updating the worker's Zod schemas + controls, regenerating the OpenAPI, and re-vendoring it into the simulator so the progenitor-generated client carries the same three setting values.
-
-* Tech Stack
-
-Rust 2021, =serde=, =strum=, =clap=, =tokio=, =chromiumoxide=, =thirtyfour=, generated =cloudflare-worker-client= types from =progenitor= (built by =build.rs= over the vendored OpenAPI), and the existing =just= recipes. Worker repo: TypeScript, =zod=, =chanfana= (Zod→OpenAPI), =wrangler=.
-
-* Source Context
-
-The linked Hyper design note is [[file:/Users/robert/projects/shuttle/hyper.video-3/2026-06-02_manual-simulcast-video-stream-control.org][2026-06-02_manual-simulcast-video-stream-control.org]].
-
-The current Hyper SDK settings are defined in [[file:/Users/robert/projects/shuttle/hyper.video-3/frontend/web/sdk/src/remote-config/media-settings.ts][media-settings.ts]]:
-
-#+BEGIN_SRC typescript
-export type VideoConstraint = keyof typeof VIDEO_CONSTRAINT_NONE | keyof typeof VIDEO_CONSTRAINT_OPTIONS;
-
-export const VIDEO_CONSTRAINT_NONE = {
-    none: { label: "None" },
-};
-export const VIDEO_CONSTRAINT_OPTIONS = {
-    "90p": { label: "90p", width: 160, height: 90 },
-    "144p": { label: "144p", width: 256, height: 144 },
-    "240p": { label: "240p", width: 426, height: 240 },
-    "360p": { label: "360p", width: 640, height: 360 },
-    "480p": { label: "480p", width: 854, height: 480 },
-    "720p": { label: "720p", width: 1280, height: 720 },
-    "1080p": { label: "1080p", width: 1920, height: 1080 },
-    "1440p": { label: "1440p", width: 2560, height: 1440 },
-    "2160p": { label: "2160p", width: 3840, height: 2160 },
-} as const;
-#+END_SRC
-
-Note vs the old =WebcamResolution=: the new =VideoConstraint= *adds* =90p=, *drops* =4320p= (8K), and replaces =auto= with =none=. Match the SDK exactly.
-
-The active runtime actions are in [[file:/Users/robert/projects/shuttle/hyper.video-3/frontend/web/sdk/src/media/state/media-settings.tsx][media-settings.tsx]]:
-
-#+BEGIN_SRC typescript
-setVideoConstraintPublishWebcam: (constraint) => {
-    updateBase({ videoConstraintPublishWebcam: constraint });
-},
-setVideoConstraintSubscribe: (constraint) => {
-    updateBase({ videoConstraintSubscribe: constraint });
-},
-setVideoMaxConcurrentTracks: (maxConcurrentTracks) => {
-    updateBase({ videoMaxConcurrentTracks: maxConcurrentTracks });
-},
-#+END_SRC
-
-The simulator currently calls the removed API in [[file:browser/src/participant/frontend/commands.rs][browser/src/participant/frontend/commands.rs]]:
-
-#+BEGIN_SRC rust
-const CAMERA_RES_GET: &str = "return hyper.settings.videoCodec.videoResolutionForWebcamEncoder.name;";
-const CAMERA_RES_SET: &str = "hyper.settings.videoCodec.actions.setVideoResolutionForWebcamEncoder(arguments[0]);";
-#+END_SRC
-
-*Precondition for the live smoke tests:* =latest.dev.hyper.video= must run a Hyper build that exposes =hyper.settings.media.actions.setVideoConstraintPublishWebcam= (and the subscribe / max-tracks actions). If the deployed SDK is behind, the live runs in Task 7 will fail even with correct code — confirm the deployed SDK version first.
-
-* File Map
-
-** Simulator repo
-
-- Modify [[file:config/src/client_config.rs][config/src/client_config.rs]]: add =VideoConstraint= and a CLI/TUI-friendly =VideoMaxConcurrentTracksPreset= helper; remove =WebcamResolution=.
-- Modify [[file:config/src/lib.rs][config/src/lib.rs]]: replace =Config.resolution= with =video_constraint_publish_webcam=, =video_constraint_subscribe=, and =video_max_concurrent_tracks=; update the exported names.
-- Modify [[file:config/src/default-config.yaml][config/src/default-config.yaml]]: default both constraints to =none= and omit =video_max_concurrent_tracks=.
-- Modify [[file:browser/src/participant/frontend/commands.rs][browser/src/participant/frontend/commands.rs]]: replace camera resolution commands with media setting commands and unit tests over a fake =BrowserDriver=.
-- Modify [[file:browser/src/participant/frontend/core.rs][browser/src/participant/frontend/core.rs]]: apply and refresh the three new settings; dispatch the three new commands.
-- Modify [[file:browser/src/participant/frontend/lite.rs][browser/src/participant/frontend/lite.rs]]: warn-unsupported on the three commands AND replace the hardcoded =refresh_state_inner= resolution default with the three new defaulted fields.
-- Modify [[file:browser/src/participant/shared/spec.rs][spec.rs]], [[file:browser/src/participant/shared/state.rs][state.rs]], [[file:browser/src/participant/shared/messages.rs][messages.rs]], [[file:browser/src/participant/shared/runtime.rs][runtime.rs]], [[file:browser/src/participant/remote_stub.rs][remote_stub.rs]], and [[file:browser/src/participant/mod.rs][mod.rs]]: thread the new setting names through participant state and commands. =runtime.rs= has an exhaustive =ParticipantMessage= match (test mock) that must be updated. =mod.rs= must drop the =set_webcam_resolution= singular alias.
-- Modify [[file:src/headless.rs][src/headless.rs]]: replace =--resolution= and participant JSON =resolution= with the three new fields (plain =Option<usize>= for the track limit).
-- Modify [[file:tui/src/tui/components/browser_start.rs][tui/src/tui/components/browser_start.rs]] and [[file:tui/src/tui/components/participants.rs][participants.rs]]: replace the camera resolution selector/table cell with outgoing constraint, incoming constraint, and track-limit controls (start screen: three fields; participants table: one combined column + chooser sub-menu).
-- Modify [[file:cloudflare-worker-client/openapi/cloudflare-browser-simulator.json][cloudflare-worker-client/openapi/cloudflare-browser-simulator.json]] (re-vendored, not hand-edited), [[file:cloudflare-worker-client/src/client.rs][client.rs]], [[file:browser/src/participant/cloudflare/mod.rs][browser/src/participant/cloudflare/mod.rs]], and [[file:browser/tests/cloudflare_driver.rs][browser/tests/cloudflare_driver.rs]].
-
-** Worker repo (=../cloudflare-browser-simulator=)
-
-- Modify =worker/src/api/schemas.ts=: replace =WebcamResolutionSchema= with =VideoConstraintSchema=; replace =resolution= / =webcamResolution= in =ParticipantSettings= and =ParticipantState= with the three new fields; replace the =set-webcam-resolution= command schema with three new ones and add them to the command union.
-- Modify =worker/src/frontend/core.ts=: replace =setWebcamResolution= in =CoreControls= with three methods that call =hyper.settings.media.actions.*=; update the command switch, the pre-join apply, the state readback (read bare strings + number|null from =hyper.settings.media=), and =buildParticipantState= defaults.
-- Modify =worker/src/frontend/lite.ts=: replace the =setWebcamResolution= stub with three no-op stubs; update the unsupported log, the command cases, and =buildLiteParticipantState= defaults.
-- Modify worker unit tests (=worker/src/*.test.ts=) and the worker CLI smoke test (=cli/src/commands/smoke_test.rs=) fixtures.
-- Regenerate =cli/openapi/cloudflare-browser-simulator.json= and =worker/worker-configuration.d.ts= via the justfile recipes.
-
-* Task 1: Add Config Types and Replace Active Config Fields
-
-** Files
-
-- Modify: [[file:config/src/client_config.rs][config/src/client_config.rs]]
-- Modify: [[file:config/src/lib.rs][config/src/lib.rs]]
-- Modify: [[file:config/src/default-config.yaml][config/src/default-config.yaml]]
-
-** Steps
-
-- [ ] Step 1: Write failing config type tests.
-
-Replace the existing =tests= module in =config/src/client_config.rs= with:
-
-#+BEGIN_SRC rust
-#[cfg(test)]
-mod tests {
-    use super::{
-        ParticipantBackendKind,
-        VideoConstraint,
-        VideoMaxConcurrentTracksPreset,
-    };
-    use std::str::FromStr as _;
-
-    #[test]
-    fn video_constraint_round_trips_hyper_media_setting_names() {
-        let values = [
-            ("none", VideoConstraint::None),
-            ("90p", VideoConstraint::P90),
-            ("144p", VideoConstraint::P144),
-            ("240p", VideoConstraint::P240),
-            ("360p", VideoConstraint::P360),
-            ("480p", VideoConstraint::P480),
-            ("720p", VideoConstraint::P720),
-            ("1080p", VideoConstraint::P1080),
-            ("1440p", VideoConstraint::P1440),
-            ("2160p", VideoConstraint::P2160),
-        ];
-
-        for (raw, expected) in values {
-            assert_eq!(VideoConstraint::from_str(raw).unwrap(), expected);
-            assert_eq!(expected.to_string(), raw);
-            assert_eq!(serde_json::to_value(expected).unwrap(), raw);
-            assert_eq!(serde_json::from_value::<VideoConstraint>(raw.into()).unwrap(), expected);
-        }
-    }
-
-    #[test]
-    fn video_track_limit_presets_convert_to_nullable_track_counts() {
-        assert_eq!(VideoMaxConcurrentTracksPreset::Unlimited.to_option(), None);
-        assert_eq!(VideoMaxConcurrentTracksPreset::One.to_option(), Some(1));
-        assert_eq!(VideoMaxConcurrentTracksPreset::Two.to_option(), Some(2));
-        assert_eq!(VideoMaxConcurrentTracksPreset::Three.to_option(), Some(3));
-        assert_eq!(VideoMaxConcurrentTracksPreset::Four.to_option(), Some(4));
-        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(None), VideoMaxConcurrentTracksPreset::Unlimited);
-        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(1)), VideoMaxConcurrentTracksPreset::One);
-        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(4)), VideoMaxConcurrentTracksPreset::Four);
-        // Off-list live values fall back to Unlimited for TUI preselection only;
-        // the participants table displays the real number separately.
-        assert_eq!(VideoMaxConcurrentTracksPreset::from_option(Some(8)), VideoMaxConcurrentTracksPreset::Unlimited);
-    }
-
-    #[test]
-    fn aws_device_farm_round_trips_kebab_case() {
-        let kind = ParticipantBackendKind::from_str("aws-device-farm").unwrap();
-        assert_eq!(kind, ParticipantBackendKind::AwsDeviceFarm);
-        assert_eq!(kind.to_string(), "aws-device-farm");
-        assert!(!kind.is_local());
-    }
-}
-#+END_SRC
-
-- [ ] Step 2: Run the failing config type tests.
-
-#+BEGIN_SRC bash
-cargo test -p client-simulator-config video_constraint_round_trips_hyper_media_setting_names video_track_limit_presets_convert_to_nullable_track_counts
-#+END_SRC
-
-Expected: fails because =VideoConstraint= and =VideoMaxConcurrentTracksPreset= do not exist.
-
-- [ ] Step 3: Add the new config enums and remove =WebcamResolution=.
-
-In =config/src/client_config.rs=, delete the =WebcamResolution= enum and add:
-
-#+BEGIN_SRC rust
-#[derive(Debug, Default, Clone, Copy, Display, EnumIter, EnumString, Serialize, Deserialize, PartialEq, Eq)]
-pub enum VideoConstraint {
-    #[default]
-    #[strum(to_string = "none")]
-    #[serde(rename = "none")]
-    None,
-    #[strum(to_string = "90p")]
-    #[serde(rename = "90p")]
-    P90,
-    #[strum(to_string = "144p")]
-    #[serde(rename = "144p")]
-    P144,
-    #[strum(to_string = "240p")]
-    #[serde(rename = "240p")]
-    P240,
-    #[strum(to_string = "360p")]
-    #[serde(rename = "360p")]
-    P360,
-    #[strum(to_string = "480p")]
-    #[serde(rename = "480p")]
-    P480,
-    #[strum(to_string = "720p")]
-    #[serde(rename = "720p")]
-    P720,
-    #[strum(to_string = "1080p")]
-    #[serde(rename = "1080p")]
-    P1080,
-    #[strum(to_string = "1440p")]
-    #[serde(rename = "1440p")]
-    P1440,
-    #[strum(to_string = "2160p")]
-    #[serde(rename = "2160p")]
-    P2160,
-}
-
-#[derive(Debug, Default, Clone, Copy, Display, EnumIter, EnumString, PartialEq, Eq)]
-pub enum VideoMaxConcurrentTracksPreset {
-    #[default]
-    #[strum(to_string = "unlimited")]
-    Unlimited,
-    #[strum(to_string = "1")]
-    One,
-    #[strum(to_string = "2")]
-    Two,
-    #[strum(to_string = "3")]
-    Three,
-    #[strum(to_string = "4")]
-    Four,
-}
-
-impl VideoMaxConcurrentTracksPreset {
-    pub const fn to_option(self) -> Option<usize> {
-        match self {
-            Self::Unlimited => None,
-            Self::One => Some(1),
-            Self::Two => Some(2),
-            Self::Three => Some(3),
-            Self::Four => Some(4),
-        }
-    }
-
-    pub const fn from_option(value: Option<usize>) -> Self {
-        match value {
-            None => Self::Unlimited,
-            Some(1) => Self::One,
-            Some(2) => Self::Two,
-            Some(3) => Self::Three,
-            Some(4) => Self::Four,
-            // Off-list values (e.g. set via config/CLI) have no preset; the TUI
-            // selector falls back to Unlimited, while the table shows the real value.
-            Some(_) => Self::Unlimited,
-        }
-    }
-}
-#+END_SRC
-
-(=WebcamResolution= is removed entirely; nothing keeps it during the transition because Task 6 also replaces the Cloudflare mappings.)
-
-- [ ] Step 4: Update the exports.
-
-In =config/src/lib.rs=, replace =WebcamResolution, WebcamResolutionIter= in the =pub use client_config= block with:
-
-#+BEGIN_SRC rust
-pub use client_config::{
-    NoiseSuppression,
-    NoiseSuppressionIter,
-    ParticipantBackendKind,
-    TransportMode,
-    TransportModeIter,
-    VideoConstraint,
-    VideoConstraintIter,
-    VideoMaxConcurrentTracksPreset,
-    VideoMaxConcurrentTracksPresetIter,
-};
-#+END_SRC
-
-- [ ] Step 5: Replace the active config fields.
-
-In =config/src/lib.rs=, replace:
-
-#+BEGIN_SRC rust
-#[serde(default)]
-pub resolution: WebcamResolution,
-#+END_SRC
-
-with:
-
-#+BEGIN_SRC rust
-#[serde(default)]
-pub video_constraint_publish_webcam: VideoConstraint,
-#[serde(default)]
-pub video_constraint_subscribe: VideoConstraint,
-#[serde(default, skip_serializing_if = "Option::is_none")]
-pub video_max_concurrent_tracks: Option<usize>,
-#+END_SRC
-
-In =impl config::Source for Config=, replace the =resolution= insert with:
-
-#+BEGIN_SRC rust
-cache.insert(
-    "video_constraint_publish_webcam".to_string(),
-    self.video_constraint_publish_webcam.to_string().into(),
-);
-cache.insert(
-    "video_constraint_subscribe".to_string(),
-    self.video_constraint_subscribe.to_string().into(),
-);
-if let Some(value) = self.video_max_concurrent_tracks {
-    cache.insert("video_max_concurrent_tracks".to_string(), (value as i64).into());
-}
-#+END_SRC
-
-- [ ] Step 6: Update default YAML.
-
-In =config/src/default-config.yaml=, replace =resolution: auto= with:
-
-#+BEGIN_SRC yaml
-video_constraint_publish_webcam: none
-video_constraint_subscribe: none
-video_max_concurrent_tracks:
-#+END_SRC
-
-- [ ] Step 7: Add config deserialization tests.
-
-Add to the =tests= module in =config/src/lib.rs=:
-
-#+BEGIN_SRC rust
-#[test]
-fn parses_new_video_constraint_settings() {
-    let config: Config = config::Config::builder()
-        .add_source(Config::default())
-        .add_source(config::File::from_str(
-            r#"
-video_constraint_publish_webcam: 480p
-video_constraint_subscribe: 720p
-video_max_concurrent_tracks: 2
-"#,
-            config::FileFormat::Yaml,
-        ))
-        .build()
-        .expect("failed to build config")
-        .try_deserialize()
-        .expect("failed to deserialize config");
-
-    assert_eq!(config.video_constraint_publish_webcam, VideoConstraint::P480);
-    assert_eq!(config.video_constraint_subscribe, VideoConstraint::P720);
-    assert_eq!(config.video_max_concurrent_tracks, Some(2));
-}
-
-#[test]
-fn default_video_max_concurrent_tracks_is_unlimited() {
-    let config = Config::default();
-
-    assert_eq!(config.video_constraint_publish_webcam, VideoConstraint::None);
-    assert_eq!(config.video_constraint_subscribe, VideoConstraint::None);
-    assert_eq!(config.video_max_concurrent_tracks, None);
-}
-#+END_SRC
-
-- [ ] Step 8: Run config tests.
-
-#+BEGIN_SRC bash
-cargo test -p client-simulator-config
-#+END_SRC
-
-Expected: all =client-simulator-config= tests pass.
-
-* Task 2: Replace Local Browser JavaScript Commands
-
-** Files
-
-- Modify: [[file:browser/src/participant/frontend/commands.rs][browser/src/participant/frontend/commands.rs]]
-
-** Steps
-
-- [ ] Step 1: Write failing command tests with a fake driver.
-
-Add a =#[cfg(test)]= module in =browser/src/participant/frontend/commands.rs=. Use a recording driver so the tests prove exact JavaScript bodies and serialized arguments.
-
-#+BEGIN_SRC rust
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use eyre::Result;
-    use futures::{
-        future::BoxFuture,
-        FutureExt as _,
-    };
-    use serde_json::json;
-    use std::{
-        sync::Mutex,
-        time::Duration,
-    };
-
-    #[derive(Default)]
-    struct RecordingDriver {
-        calls: Mutex<Vec<(String, Option<serde_json::Value>)>>,
-        next_result: Mutex<serde_json::Value>,
-    }
-
-    impl RecordingDriver {
-        fn with_result(value: serde_json::Value) -> Self {
-            Self {
-                calls: Mutex::new(Vec::new()),
-                next_result: Mutex::new(value),
-            }
-        }
-
-        fn calls(&self) -> Vec<(String, Option<serde_json::Value>)> {
-            self.calls.lock().unwrap().clone()
-        }
-    }
-
-    impl BrowserDriver for RecordingDriver {
-        fn goto(&self, _url: &str) -> BoxFuture<'_, Result<()>> {
-            async { Ok(()) }.boxed()
-        }
-
-        fn exists(&self, _selector: &str) -> BoxFuture<'_, Result<bool>> {
-            async { Ok(false) }.boxed()
-        }
-
-        fn wait_for(&self, _selector: &str, _timeout: Duration) -> BoxFuture<'_, Result<()>> {
-            async { Ok(()) }.boxed()
-        }
-
-        fn click(&self, _selector: &str) -> BoxFuture<'_, Result<()>> {
-            async { Ok(()) }.boxed()
-        }
-
-        fn fill(&self, _selector: &str, _text: &str) -> BoxFuture<'_, Result<()>> {
-            async { Ok(()) }.boxed()
-        }
-
-        fn attribute(&self, _selector: &str, _name: &str) -> BoxFuture<'_, Result<Option<String>>> {
-            async { Ok(None) }.boxed()
-        }
-
-        fn eval(&self, js_body: &str, arg: Option<serde_json::Value>) -> BoxFuture<'_, Result<serde_json::Value>> {
-            self.calls.lock().unwrap().push((js_body.to_string(), arg));
-            let value = self.next_result.lock().unwrap().clone();
-            async move { Ok(value) }.boxed()
-        }
-
-        fn set_cookie(&self, _domain: &str, _name: &str, _value: &str) -> BoxFuture<'_, Result<()>> {
-            async { Ok(()) }.boxed()
-        }
-    }
-
-    #[tokio::test]
-    async fn sets_video_constraints_through_media_settings_api() {
-        let driver = RecordingDriver::default();
-
-        set_video_constraint_publish_webcam(&driver, VideoConstraint::P480).await.unwrap();
-        set_video_constraint_subscribe(&driver, VideoConstraint::P720).await.unwrap();
-        set_video_max_concurrent_tracks(&driver, Some(2)).await.unwrap();
-        set_video_max_concurrent_tracks(&driver, None).await.unwrap();
-
-        assert_eq!(
-            driver.calls(),
-            vec![
-                (
-                    "hyper.settings.media.actions.setVideoConstraintPublishWebcam(arguments[0]);".to_string(),
-                    Some(json!("480p")),
-                ),
-                (
-                    "hyper.settings.media.actions.setVideoConstraintSubscribe(arguments[0]);".to_string(),
-                    Some(json!("720p")),
-                ),
-                (
-                    "hyper.settings.media.actions.setVideoMaxConcurrentTracks(arguments[0]);".to_string(),
-                    Some(json!(2)),
-                ),
-                (
-                    "hyper.settings.media.actions.setVideoMaxConcurrentTracks(arguments[0]);".to_string(),
-                    Some(serde_json::Value::Null),
-                ),
-            ],
-        );
-    }
-
-    #[tokio::test]
-    async fn gets_video_constraints_from_media_settings_api() {
-        let driver = RecordingDriver::with_result(json!("360p"));
-
-        let value = get_video_constraint_publish_webcam(&driver).await.unwrap();
-
-        assert_eq!(value, VideoConstraint::P360);
-        assert_eq!(
-            driver.calls(),
-            vec![(
-                "return hyper.settings.media.videoConstraintPublishWebcam;".to_string(),
-                None,
-            )],
-        );
-    }
-
-    #[tokio::test]
-    async fn gets_nullable_video_max_concurrent_tracks() {
-        let driver = RecordingDriver::with_result(serde_json::Value::Null);
-
-        let value = get_video_max_concurrent_tracks(&driver).await.unwrap();
-
-        assert_eq!(value, None);
-        assert_eq!(
-            driver.calls(),
-            vec![(
-                "return hyper.settings.media.videoMaxConcurrentTracks;".to_string(),
-                None,
-            )],
-        );
-    }
-
-    #[tokio::test]
-    async fn reads_integer_valued_max_concurrent_tracks_even_as_float() {
-        // The page may hand back a JSON number that serde sees as a float (e.g. 2.0).
-        let driver = RecordingDriver::with_result(json!(2.0));
-
-        let value = get_video_max_concurrent_tracks(&driver).await.unwrap();
-
-        assert_eq!(value, Some(2));
-    }
-}
-#+END_SRC
-
-- [ ] Step 2: Run the failing browser command tests.
-
-#+BEGIN_SRC bash
-cargo test -p client-simulator-browser sets_video_constraints_through_media_settings_api gets_video_constraints_from_media_settings_api gets_nullable_video_max_concurrent_tracks reads_integer_valued_max_concurrent_tracks_even_as_float
-#+END_SRC
-
-Expected: fails because the new functions and imported types do not exist.
-
-- [ ] Step 3: Replace the command constants and functions.
-
-Import =VideoConstraint= instead of =WebcamResolution=:
-
-#+BEGIN_SRC rust
-use client_simulator_config::{
-    NoiseSuppression,
-    VideoConstraint,
-};
-#+END_SRC
-
-Remove =CAMERA_RES_GET= and =CAMERA_RES_SET=. Add:
-
-#+BEGIN_SRC rust
-const VIDEO_CONSTRAINT_PUBLISH_GET: &str = "return hyper.settings.media.videoConstraintPublishWebcam;";
-const VIDEO_CONSTRAINT_PUBLISH_SET: &str =
-    "hyper.settings.media.actions.setVideoConstraintPublishWebcam(arguments[0]);";
-const VIDEO_CONSTRAINT_SUBSCRIBE_GET: &str = "return hyper.settings.media.videoConstraintSubscribe;";
-const VIDEO_CONSTRAINT_SUBSCRIBE_SET: &str =
-    "hyper.settings.media.actions.setVideoConstraintSubscribe(arguments[0]);";
-const VIDEO_MAX_CONCURRENT_TRACKS_GET: &str = "return hyper.settings.media.videoMaxConcurrentTracks;";
-const VIDEO_MAX_CONCURRENT_TRACKS_SET: &str =
-    "hyper.settings.media.actions.setVideoMaxConcurrentTracks(arguments[0]);";
-#+END_SRC
-
-Replace =get_outgoing_camera_resolution= / =set_outgoing_camera_resolution= with:
-
-#+BEGIN_SRC rust
-pub(super) async fn get_video_constraint_publish_webcam(driver: &dyn BrowserDriver) -> Result<VideoConstraint> {
-    get_string(driver, VIDEO_CONSTRAINT_PUBLISH_GET)
-        .await?
-        .parse::<VideoConstraint>()
-        .context("failed to parse videoConstraintPublishWebcam from string")
-}
-
-pub(super) async fn set_video_constraint_publish_webcam(
-    driver: &dyn BrowserDriver,
-    value: VideoConstraint,
-) -> Result<()> {
-    set_value(driver, VIDEO_CONSTRAINT_PUBLISH_SET, value.to_string()).await
-}
-
-pub(super) async fn get_video_constraint_subscribe(driver: &dyn BrowserDriver) -> Result<VideoConstraint> {
-    get_string(driver, VIDEO_CONSTRAINT_SUBSCRIBE_GET)
-        .await?
-        .parse::<VideoConstraint>()
-        .context("failed to parse videoConstraintSubscribe from string")
-}
-
-pub(super) async fn set_video_constraint_subscribe(driver: &dyn BrowserDriver, value: VideoConstraint) -> Result<()> {
-    set_value(driver, VIDEO_CONSTRAINT_SUBSCRIBE_SET, value.to_string()).await
-}
-
-pub(super) async fn get_video_max_concurrent_tracks(driver: &dyn BrowserDriver) -> Result<Option<usize>> {
-    // Read as a nullable float to tolerate the page returning e.g. `2.0`, then cast.
-    let value = driver.eval(VIDEO_MAX_CONCURRENT_TRACKS_GET, None).await?;
-    let as_f64: Option<f64> =
-        serde_json::from_value(value).context("failed to read videoMaxConcurrentTracks from eval result")?;
-    Ok(as_f64.map(|value| value as usize))
-}
-
-pub(super) async fn set_video_max_concurrent_tracks(
-    driver: &dyn BrowserDriver,
-    value: Option<usize>,
-) -> Result<()> {
-    set_value(driver, VIDEO_MAX_CONCURRENT_TRACKS_SET, value).await
-}
-#+END_SRC
-
-- [ ] Step 4: Run browser command tests.
-
-#+BEGIN_SRC bash
-cargo test -p client-simulator-browser video_constraint
-#+END_SRC
-
-Expected: command tests pass; no remaining references to =videoResolutionForWebcamEncoder=.
-
-* Task 3: Thread New Settings Through Participant Runtime
-
-** Files
-
-- Modify: [[file:browser/src/participant/shared/spec.rs][browser/src/participant/shared/spec.rs]]
-- Modify: [[file:browser/src/participant/shared/state.rs][browser/src/participant/shared/state.rs]]
-- Modify: [[file:browser/src/participant/shared/messages.rs][browser/src/participant/shared/messages.rs]]
-- Modify: [[file:browser/src/participant/shared/runtime.rs][browser/src/participant/shared/runtime.rs]]
-- Modify: [[file:browser/src/participant/frontend/core.rs][browser/src/participant/frontend/core.rs]]
-- Modify: [[file:browser/src/participant/frontend/lite.rs][browser/src/participant/frontend/lite.rs]]
-- Modify: [[file:browser/src/participant/remote_stub.rs][browser/src/participant/remote_stub.rs]]
-- Modify: [[file:browser/src/participant/mod.rs][browser/src/participant/mod.rs]]
-
-** Steps
-
-- [ ] Step 1: Write failing launch-spec and state tests.
-
-Update the =spec.rs= test =converts_participant_config_to_launch_spec= so its config and assertions use all three new fields:
-
-#+BEGIN_SRC rust
-let participant_config = ParticipantConfig {
-    username: "robert".to_string(),
-    session_url: Url::parse("https://example.com/m/demo").unwrap(),
-    app_config: Config {
-        audio_enabled: true,
-        video_enabled: false,
-        screenshare_enabled: true,
-        auto_gain_control: true,
-        noise_suppression: NoiseSuppression::RNNoise,
-        transport: TransportMode::WebRTC,
-        video_constraint_publish_webcam: VideoConstraint::P480,
-        video_constraint_subscribe: VideoConstraint::P720,
-        video_max_concurrent_tracks: Some(2),
-        blur: true,
-        ..Default::default()
-    },
-};
-
-let spec = ParticipantLaunchSpec::from(participant_config);
-
-assert_eq!(spec.settings.video_constraint_publish_webcam, VideoConstraint::P480);
-assert_eq!(spec.settings.video_constraint_subscribe, VideoConstraint::P720);
-assert_eq!(spec.settings.video_max_concurrent_tracks, Some(2));
-#+END_SRC
-
-- [ ] Step 2: Run the failing launch-spec test.
-
-#+BEGIN_SRC bash
-cargo test -p client-simulator-browser converts_participant_config_to_launch_spec
-#+END_SRC
-
-Expected: fails because =ParticipantSettings= still has =resolution=.
-
-- [ ] Step 3: Replace participant setting and state fields.
-
-In =spec.rs=, replace =pub(in crate::participant) resolution: WebcamResolution,= with:
-
-#+BEGIN_SRC rust
-pub(in crate::participant) video_constraint_publish_webcam: VideoConstraint,
-pub(in crate::participant) video_constraint_subscribe: VideoConstraint,
-pub(in crate::participant) video_max_concurrent_tracks: Option<usize>,
-#+END_SRC
-
-In =ParticipantSettings::from=, assign the three new fields from =app_config=.
-
-In =state.rs=, replace =pub webcam_resolution: WebcamResolution,= with:
-
-#+BEGIN_SRC rust
-pub video_constraint_publish_webcam: VideoConstraint,
-pub video_constraint_subscribe: VideoConstraint,
-pub video_max_concurrent_tracks: Option<usize>,
-#+END_SRC
-
-- [ ] Step 4: Replace participant commands and the public API.
-
-In =messages.rs=, replace =SetWebcamResolutions(WebcamResolution),= with:
-
-#+BEGIN_SRC rust
-SetVideoConstraintPublishWebcam(VideoConstraint),
-SetVideoConstraintSubscribe(VideoConstraint),
-SetVideoMaxConcurrentTracks(Option<usize>),
-#+END_SRC
-
-In =mod.rs=, *delete* both =set_webcam_resolutions= and the =set_webcam_resolution= singular alias, and add:
-
-#+BEGIN_SRC rust
-pub fn set_video_constraint_publish_webcam(&self, value: client_simulator_config::VideoConstraint) {
-    self.send_message(ParticipantMessage::SetVideoConstraintPublishWebcam(value));
-}
-
-pub fn set_video_constraint_subscribe(&self, value: client_simulator_config::VideoConstraint) {
-    self.send_message(ParticipantMessage::SetVideoConstraintSubscribe(value));
-}
-
-pub fn set_video_max_concurrent_tracks(&self, value: Option<usize>) {
-    self.send_message(ParticipantMessage::SetVideoMaxConcurrentTracks(value));
-}
-#+END_SRC
-
-In =runtime.rs=, update the exhaustive =ParticipantMessage= match in the test-mock =handle_command= (it currently lists =SetWebcamResolutions(_)= among the no-op arms) so it lists the three new variants instead. This is required for the crate to compile.
-
-- [ ] Step 5: Apply and refresh new settings in Hyper Core (=core.rs=).
-
-Update imports to the new command functions. In =apply_all_settings=, replace the outgoing-resolution setter with:
-
-#+BEGIN_SRC rust
-set_video_constraint_publish_webcam(driver, settings.video_constraint_publish_webcam)
-    .await
-    .context("failed to set outgoing webcam video constraint")?;
-set_video_constraint_subscribe(driver, settings.video_constraint_subscribe)
-    .await
-    .context("failed to set incoming video constraint")?;
-set_video_max_concurrent_tracks(driver, settings.video_max_concurrent_tracks)
-    .await
-    .context("failed to set max concurrent video tracks")?;
-#+END_SRC
-
-Replace =set_webcam_resolutions_inner= with three focused setters:
-
-#+BEGIN_SRC rust
-async fn set_video_constraint_publish_webcam_inner(&self, value: VideoConstraint) -> Result<()> {
-    info!(participant = %self.participant_name(), "Changing outgoing webcam video constraint to {value}");
-    set_video_constraint_publish_webcam(self.context.driver.as_ref(), value)
-        .await
-        .context("Failed to set outgoing webcam video constraint")
-}
-
-async fn set_video_constraint_subscribe_inner(&self, value: VideoConstraint) -> Result<()> {
-    info!(participant = %self.participant_name(), "Changing incoming video constraint to {value}");
-    set_video_constraint_subscribe(self.context.driver.as_ref(), value)
-        .await
-        .context("Failed to set incoming video constraint")
-}
-
-async fn set_video_max_concurrent_tracks_inner(&self, value: Option<usize>) -> Result<()> {
-    info!(participant = %self.participant_name(), ?value, "Changing max concurrent video tracks");
-    set_video_max_concurrent_tracks(self.context.driver.as_ref(), value)
-        .await
-        .context("Failed to set max concurrent video tracks")
-}
-#+END_SRC
-
-In =refresh_state_inner=, populate the new state fields (keep the existing =if let Ok(...)= soft-fail pattern):
-
-#+BEGIN_SRC rust
-if let Ok(value) = get_video_constraint_publish_webcam(driver).await {
-    state.video_constraint_publish_webcam = value;
-}
-
-if let Ok(value) = get_video_constraint_subscribe(driver).await {
-    state.video_constraint_subscribe = value;
-}
-
-if let Ok(value) = get_video_max_concurrent_tracks(driver).await {
-    state.video_max_concurrent_tracks = value;
-}
-#+END_SRC
-
-Update =handle_command= to dispatch the three new =ParticipantMessage= variants to the three inner setters.
-
-- [ ] Step 6: Update Hyper Lite (=lite.rs=).
-
-Replace =set_webcam_resolutions_inner= with three no-op inner methods that warn, matching the existing lite pattern:
-
-#+BEGIN_SRC rust
-warn!(
-    participant = %self.participant_name(),
-    "Video constraint changes not supported in lite frontend"
-);
-#+END_SRC
-
-Update =handle_command= to dispatch the three new variants to those no-ops.
-
-Also update lite's =refresh_state_inner= — it currently hardcodes =webcam_resolution: WebcamResolution::default()=. Replace that single field with the three new fields, defaulted:
-
-#+BEGIN_SRC rust
-video_constraint_publish_webcam: VideoConstraint::default(),
-video_constraint_subscribe: VideoConstraint::default(),
-video_max_concurrent_tracks: None,
-#+END_SRC
-
-- [ ] Step 7: Update the remote stub (=remote_stub.rs=).
-
-Initialize the three new state fields from =launch_spec.settings=:
-
-#+BEGIN_SRC rust
-video_constraint_publish_webcam: self.launch_spec.settings.video_constraint_publish_webcam,
-video_constraint_subscribe: self.launch_spec.settings.video_constraint_subscribe,
-video_max_concurrent_tracks: self.launch_spec.settings.video_max_concurrent_tracks,
-#+END_SRC
-
-and handle the three commands:
-
-#+BEGIN_SRC rust
-ParticipantMessage::SetVideoConstraintPublishWebcam(value) => {
-    self.state.video_constraint_publish_webcam = value;
-    self.log_message("debug", format!("remote stub set outgoing webcam video constraint to {value}"));
-}
-ParticipantMessage::SetVideoConstraintSubscribe(value) => {
-    self.state.video_constraint_subscribe = value;
-    self.log_message("debug", format!("remote stub set incoming video constraint to {value}"));
-}
-ParticipantMessage::SetVideoMaxConcurrentTracks(value) => {
-    self.state.video_max_concurrent_tracks = value;
-    self.log_message("debug", format!("remote stub set max concurrent video tracks to {value:?}"));
-}
-#+END_SRC
-
-- [ ] Step 8: Run browser runtime tests.
-
-#+BEGIN_SRC bash
-cargo test -p client-simulator-browser converts_participant_config_to_launch_spec remote_stub
-#+END_SRC
-
-Expected: tests pass or expose remaining =WebcamResolution= references that need replacement.
-
-* Task 4: Replace Headless CLI and Participant JSON Fields
-
-Note: =null= = absent = "no override" (plain =Option<usize>=). No double-option, no =serde_with=, no custom parser. A participant cannot force unlimited via CLI/JSON when a numeric value is in play; to get unlimited, omit the field / rely on the default.
-
-** Files
-
-- Modify: [[file:src/headless.rs][src/headless.rs]]
-
-** Steps
-
-- [ ] Step 1: Write failing headless parsing and override tests.
-
-#+BEGIN_SRC rust
-#[test]
-fn cli_parsing_accepts_video_constraint_options() {
-    let cli = TestHeadlessCli::parse_from([
-        "headless",
-        "--video-constraint-publish-webcam",
-        "480p",
-        "--video-constraint-subscribe",
-        "720p",
-        "--video-max-concurrent-tracks",
-        "2",
-        "--participant",
-        r#"{"video_constraint_publish_webcam":"360p","video_constraint_subscribe":"none","video_max_concurrent_tracks":1}"#,
-    ]);
-    let args = cli.args;
-
-    assert_eq!(args.video_constraint_publish_webcam, Some(VideoConstraint::P480));
-    assert_eq!(args.video_constraint_subscribe, Some(VideoConstraint::P720));
-    assert_eq!(args.video_max_concurrent_tracks, Some(2));
-    assert_eq!(args.participants.len(), 1);
-}
-
-#[test]
-fn participant_json_overrides_video_constraints_and_treats_null_tracks_as_absent() {
-    let global_config = Config {
-        video_constraint_publish_webcam: VideoConstraint::P720,
-        video_constraint_subscribe: VideoConstraint::P720,
-        video_max_concurrent_tracks: Some(2),
-        ..Default::default()
-    };
-
-    let configs = build_participant_configs(
-        global_config,
-        &[r#"{"video_constraint_publish_webcam":"360p","video_max_concurrent_tracks":null}"#.to_string()],
-    )
-    .expect("participant configs");
-
-    // publish overridden; subscribe omitted -> inherits global;
-    // max tracks null is treated as absent -> inherits global Some(2).
-    assert_eq!(configs[0].video_constraint_publish_webcam, VideoConstraint::P360);
-    assert_eq!(configs[0].video_constraint_subscribe, VideoConstraint::P720);
-    assert_eq!(configs[0].video_max_concurrent_tracks, Some(2));
-}
-
-#[test]
-fn participant_json_numeric_tracks_override_global() {
-    let global_config = Config {
-        video_max_concurrent_tracks: None,
-        ..Default::default()
-    };
-
-    let configs = build_participant_configs(
-        global_config,
-        &[r#"{"video_max_concurrent_tracks":3}"#.to_string()],
-    )
-    .expect("participant configs");
-
-    assert_eq!(configs[0].video_max_concurrent_tracks, Some(3));
-}
-#+END_SRC
-
-- [ ] Step 2: Run the failing headless tests.
-
-#+BEGIN_SRC bash
-cargo test -p hyper-client-simulator headless::tests::cli_parsing_accepts_video_constraint_options headless::tests::participant_json_overrides_video_constraints_and_treats_null_tracks_as_absent headless::tests::participant_json_numeric_tracks_override_global
-#+END_SRC
-
-Expected: fails because =HeadlessArgs= and =ParticipantOverride= still use =resolution=.
-
-- [ ] Step 3: Replace =HeadlessArgs= fields.
-
-Replace the import of =WebcamResolution= with =VideoConstraint=. Replace:
-
-#+BEGIN_SRC rust
-#[clap(long, value_name = "RESOLUTION")]
-pub resolution: Option<WebcamResolution>,
-#+END_SRC
-
-with:
-
-#+BEGIN_SRC rust
-#[clap(long = "video-constraint-publish-webcam", value_name = "CONSTRAINT")]
-pub video_constraint_publish_webcam: Option<VideoConstraint>,
-
-#[clap(long = "video-constraint-subscribe", value_name = "CONSTRAINT")]
-pub video_constraint_subscribe: Option<VideoConstraint>,
-
-#[clap(long = "video-max-concurrent-tracks", value_name = "TRACKS")]
-pub video_max_concurrent_tracks: Option<usize>,
-#+END_SRC
-
-(No custom =value_parser=; a bare integer parses into =usize=. To run unlimited, omit the flag.)
-
-- [ ] Step 4: Replace participant JSON override fields and apply logic.
-
-In =ParticipantOverride=, replace =resolution= with:
-
-#+BEGIN_SRC rust
-video_constraint_publish_webcam: Option<VideoConstraint>,
-video_constraint_subscribe: Option<VideoConstraint>,
-video_max_concurrent_tracks: Option<usize>,
-#+END_SRC
-
-In =apply_cli_overrides= and =apply_participant_override=, set the three =Config= fields with the same =if let Some(value)= pattern as the other fields (JSON =null= deserializes to =None= and is skipped):
-
-#+BEGIN_SRC rust
-if let Some(value) = args.video_constraint_publish_webcam {
-    config.video_constraint_publish_webcam = value;
-}
-if let Some(value) = args.video_constraint_subscribe {
-    config.video_constraint_subscribe = value;
-}
-if let Some(value) = args.video_max_concurrent_tracks {
-    config.video_max_concurrent_tracks = Some(value);
-}
-#+END_SRC
-
-(and the analogous block reading from =override_= in =apply_participant_override=.)
-
-- [ ] Step 5: Remove old =resolution= headless support.
-
-Delete =resolution= from =HeadlessArgs=, =ParticipantOverride=, =apply_cli_overrides=, =apply_participant_override=, and old tests. Then:
-
-#+BEGIN_SRC bash
-rg -n "\bresolution\b|WebcamResolution" src/headless.rs
-#+END_SRC
-
-Expected: no matches.
-
-- [ ] Step 6: Run headless tests.
-
-#+BEGIN_SRC bash
-cargo test -p hyper-client-simulator headless
-#+END_SRC
-
-Expected: all headless tests pass.
-
-* Task 5: Replace TUI Surfaces
-
-** Files
-
-- Modify: [[file:tui/src/tui/components/browser_start.rs][tui/src/tui/components/browser_start.rs]]
-- Modify: [[file:tui/src/tui/components/participants.rs][tui/src/tui/components/participants.rs]]
-
-** Steps
-
-- [ ] Step 1: Replace imports and the start-screen field model.
-
-In both files, replace the =WebcamResolution= import with:
-
-#+BEGIN_SRC rust
-use client_simulator_config::{
-    Config,
-    NoiseSuppression,
-    VideoConstraint,
-    VideoConstraintIter,
-    VideoMaxConcurrentTracksPreset,
-    VideoMaxConcurrentTracksPresetIter,
-};
-#+END_SRC
-
-In =browser_start.rs=, replace the single =SelectedField::Resolution= variant with three variants in the same navigation position (between =Transport= and =BackgroundBlur=):
-
-#+BEGIN_SRC rust
-VideoConstraintPublishWebcam,
-VideoConstraintSubscribe,
-VideoMaxConcurrentTracks,
-#+END_SRC
-
-Update the exhaustive =MoveUp= / =MoveDown= match arms (the circular field order), the per-field render rows (two more =Constraint::Length(1)= rows and two more render blocks), and replace the =resolution_list= field with three list fields:
-
-#+BEGIN_SRC rust
-video_constraint_publish_webcam_list: Option<EnumListInput<VideoConstraint>>,
-video_constraint_subscribe_list: Option<EnumListInput<VideoConstraint>>,
-video_max_concurrent_tracks_list: Option<EnumListInput<VideoMaxConcurrentTracksPreset>>,
-#+END_SRC
-
-- [ ] Step 2: Update start-screen labels and selection handlers.
-
-Help text:
-
-#+BEGIN_SRC rust
-SelectedField::VideoConstraintPublishWebcam => " Select outgoing webcam max resolution. <enter> to select. ",
-SelectedField::VideoConstraintSubscribe => " Select incoming max resolution. <enter> to select. ",
-SelectedField::VideoMaxConcurrentTracks => " Select max concurrent webcam tracks. <enter> to select. ",
-#+END_SRC
-
-The two constraint lists are seeded from =self.config.video_constraint_*= via =VideoConstraint::iter()=. The track-limit list is seeded from the preset, and on selection writes back through =to_option=:
-
-#+BEGIN_SRC rust
-// open:
-self.video_max_concurrent_tracks_list = Some(EnumListInput::new(
-    "Max concurrent webcam tracks",
-    VideoMaxConcurrentTracksPreset::iter(),
-    VideoMaxConcurrentTracksPreset::from_option(self.config.video_max_concurrent_tracks),
-));
-// on finish:
-self.config.video_max_concurrent_tracks = value.to_option();
-#+END_SRC
-
-Update the =Esc=-to-close and =draw= blocks to cover all three lists.
-
-- [ ] Step 3: Participants table — one combined column.
-
-Replace the single =Resolution= header/cell with ONE combined column (table stays at 12 columns). Header "Video constraints"; cell:
-
-#+BEGIN_SRC rust
-let publish = state.video_constraint_publish_webcam.to_string();
-let subscribe = state.video_constraint_subscribe.to_string();
-let tracks = state
-    .video_max_concurrent_tracks
-    .map(|value| value.to_string())
-    .unwrap_or_else(|| "∞".to_string());
-let video_constraints = format!("out:{publish} in:{subscribe} t:{tracks}");
-#+END_SRC
-
-Give the combined column more width than the old 8% (it holds ~22 chars at the extreme, e.g. =out:1080p in:1080p t:∞=) and rebalance the other percentage widths so they still sum to 100. Exact split at implementer discretion (e.g. bump this column to ~16–18% and shave a couple of points each from Name / Created / Noise Suppression / Blur). Truncation on an 80-col terminal is acceptable per the design decision.
-
-- [ ] Step 4: Participants table — per-participant edit via a chooser sub-menu.
-
-Keep the single =r= key. Pressing =r= opens a small chooser listing the three settings; selecting one opens that setting's value list; selecting a value sends the command. Add a chooser enum and the modal state:
-
-#+BEGIN_SRC rust
-#[derive(Copy, Clone, Debug, PartialEq, Eq, strum::Display, strum::EnumIter, strum::EnumString)]
-enum VideoSetting {
-    #[strum(to_string = "Outgoing constraint")]
-    PublishWebcam,
-    #[strum(to_string = "Incoming constraint")]
-    Subscribe,
-    #[strum(to_string = "Track limit")]
-    MaxTracks,
-}
-
-// component state:
-video_setting_menu: Option<EnumListInput<VideoSetting>>,
-video_constraint_publish_webcam_list: Option<EnumListInput<VideoConstraint>>,
-video_constraint_subscribe_list: Option<EnumListInput<VideoConstraint>>,
-video_max_concurrent_tracks_list: Option<EnumListInput<VideoMaxConcurrentTracksPreset>>,
-#+END_SRC
-
-Flow:
-
-1. =r= → open =video_setting_menu= (preselect =PublishWebcam=).
-2. Menu =Enter= → match the chosen =VideoSetting= and open the matching value list, seeded from =selected.state.borrow()= (=from_option= for the track preset).
-3. Value-list =Enter= → send the command:
-
-#+BEGIN_SRC rust
-participant.set_video_constraint_publish_webcam(value);
-participant.set_video_constraint_subscribe(value);
-participant.set_video_max_concurrent_tracks(value.to_option());
-#+END_SRC
-
-4. =Esc= closes whichever modal is open; =draw= renders whichever modal is =Some=.
-
-Update the footer help text, replacing =<r>esolutions= with a single entry such as =<r> video constraints=.
-
-- [ ] Step 5: Run TUI tests.
-
-#+BEGIN_SRC bash
-cargo test -p client-simulator-tui
-#+END_SRC
-
-Expected: TUI tests pass; compile errors flag any remaining old field names.
-
-* Task 6: Update the Cloudflare Worker and Re-Vendor the Contract
-
-Order matters: change the worker first, regenerate the OpenAPI from its Zod schemas, then re-vendor into the simulator. Do NOT hand-edit the simulator's vendored JSON — it is generated output. Wire casing is =1080p= throughout.
-
-** Part A — Worker repo (=../cloudflare-browser-simulator=)
-
-*** Files
-
-- Modify: =worker/src/api/schemas.ts=
-- Modify: =worker/src/frontend/core.ts=
-- Modify: =worker/src/frontend/lite.ts=
-- Modify: worker unit tests =worker/src/*.test.ts=
-- Modify: =cli/src/commands/smoke_test.rs=
-- Regenerate: =cli/openapi/cloudflare-browser-simulator.json=, =worker/worker-configuration.d.ts=
-
-*** Steps
-
-- [ ] Step 1: Update Zod schemas (=worker/src/api/schemas.ts=).
-
-Replace =WebcamResolutionSchema= with:
-
-#+BEGIN_SRC typescript
-export const VideoConstraintSchema = z.enum([
-  "none", "90p", "144p", "240p", "360p", "480p", "720p", "1080p", "1440p", "2160p",
-]);
-#+END_SRC
-
-In =ParticipantSettingsSchema=, replace =resolution: WebcamResolutionSchema= with:
-
-#+BEGIN_SRC typescript
-videoConstraintPublishWebcam: VideoConstraintSchema,
-videoConstraintSubscribe: VideoConstraintSchema,
-videoMaxConcurrentTracks: z.number().int().min(0).nullable(),
-#+END_SRC
-
-In =ParticipantStateSchema=, replace =webcamResolution: WebcamResolutionSchema= with the same three fields.
-
-Replace =SetWebcamResolutionCommandSchema= with three command schemas, and add them to the command discriminated union (and remove the old one):
-
-#+BEGIN_SRC typescript
-const SetVideoConstraintPublishWebcamCommandSchema = z.object({
-  type: z.literal("set-video-constraint-publish-webcam"),
-  videoConstraintPublishWebcam: VideoConstraintSchema,
-});
-const SetVideoConstraintSubscribeCommandSchema = z.object({
-  type: z.literal("set-video-constraint-subscribe"),
-  videoConstraintSubscribe: VideoConstraintSchema,
-});
-const SetVideoMaxConcurrentTracksCommandSchema = z.object({
-  type: z.literal("set-video-max-concurrent-tracks"),
-  videoMaxConcurrentTracks: z.number().int().min(0).nullable(),
-});
-#+END_SRC
-
-- [ ] Step 2: Update Core controls and state (=worker/src/frontend/core.ts=).
-
-In =CoreControls=, replace =setWebcamResolution= with three methods. Implement them against =hyper.settings.media= (NOT the removed =videoCodec= API):
-
-#+BEGIN_SRC typescript
-async setVideoConstraintPublishWebcam(value) {
-  await page.evaluate((next) => {
-    const hyper = (globalThis as typeof globalThis & { hyper?: any }).hyper;
-    hyper?.settings?.media?.actions?.setVideoConstraintPublishWebcam?.(next);
-  }, value);
-},
-async setVideoConstraintSubscribe(value) {
-  await page.evaluate((next) => {
-    const hyper = (globalThis as typeof globalThis & { hyper?: any }).hyper;
-    hyper?.settings?.media?.actions?.setVideoConstraintSubscribe?.(next);
-  }, value);
-},
-async setVideoMaxConcurrentTracks(value) {
-  await page.evaluate((next) => {
-    const hyper = (globalThis as typeof globalThis & { hyper?: any }).hyper;
-    hyper?.settings?.media?.actions?.setVideoMaxConcurrentTracks?.(next);
-  }, value);
-},
-#+END_SRC
-
-Update the command switch (three cases), the pre-join settings apply (three calls from =request.settings=), the state readback (read =hyper.settings.media.videoConstraintPublishWebcam= / =videoConstraintSubscribe= as bare strings and =videoMaxConcurrentTracks= as a number|null), and =buildParticipantState= defaults (=none= / =none= / =null=).
-
-- [ ] Step 3: Update Lite (=worker/src/frontend/lite.ts=).
-
-Replace the =setWebcamResolution= stub with three no-op stubs; update the unsupported log message, the command cases, and =buildLiteParticipantState= defaults (=videoConstraintPublishWebcam: "none"=, =videoConstraintSubscribe: "none"=, =videoMaxConcurrentTracks: null=).
-
-- [ ] Step 4: Update worker unit tests.
-
-Update =worker/src/*.test.ts= fixtures/expectations that reference =resolution=, =webcamResolution=, =set-webcam-resolution=, or the =p1080= casing.
-
-- [ ] Step 5: Regenerate the OpenAPI and worker types, fix the worker CLI.
-
-From the worker repo:
-
-#+BEGIN_SRC bash
-just export-openapi
-just generate-worker-types
-#+END_SRC
-
-Update =cli/src/commands/smoke_test.rs= fixtures so the generated client compiles, then:
-
-#+BEGIN_SRC bash
-just check-generated
-#+END_SRC
-
-Expected: =check-generated= passes (OpenAPI + worker types regenerated, =cargo check= clean, no stray git diff).
-
-- [ ] Step 6: Deploy is a MANUAL, maintainer-approved step (see Task 7). Do not run =just deploy-worker= as part of automated execution.
-
-** Part B — Simulator repo
-
-*** Files
-
-- Modify: [[file:cloudflare-worker-client/openapi/cloudflare-browser-simulator.json][cloudflare-worker-client/openapi/cloudflare-browser-simulator.json]] (re-vendor)
-- Modify: [[file:cloudflare-worker-client/src/client.rs][cloudflare-worker-client/src/client.rs]]
-- Modify: [[file:browser/src/participant/cloudflare/mod.rs][browser/src/participant/cloudflare/mod.rs]]
-- Modify: [[file:browser/tests/cloudflare_driver.rs][browser/tests/cloudflare_driver.rs]]
-
-*** Steps
-
-- [ ] Step 1: Re-vendor the regenerated OpenAPI and regenerate the progenitor client.
-
-#+BEGIN_SRC bash
-cp ../cloudflare-browser-simulator/cli/openapi/cloudflare-browser-simulator.json \
-   cloudflare-worker-client/openapi/cloudflare-browser-simulator.json
-cargo check -p cloudflare-worker-client
-#+END_SRC
-
-This moves the vendored copy from =0.3.0= to the current worker version. Expect the full re-vendor to surface unrelated =0.3.0→0.4.x= schema drift — be prepared for additional progenitor type renames that ripple into =client.rs= and =cloudflare/mod.rs=. Note the generated type names (progenitor): expect =ParticipantSettingsVideoConstraintPublishWebcam=, =ParticipantSettingsVideoConstraintSubscribe=, and =SessionCommandRequest::SetVideoConstraintPublishWebcam {{ .. }}= variants (confirm exact names from the compile output).
-
-- [ ] Step 2: Update =cloudflare-worker-client/src/client.rs=.
-
-Replace the =ParticipantSettingsResolution= import/usage. Update =create_session_request=:
-
-#+BEGIN_SRC rust
-settings: ParticipantSettings {
-    audio_enabled: true,
-    auto_gain_control: true,
-    blur: false,
-    noise_suppression: ParticipantSettingsNoiseSuppression::None,
-    screenshare_enabled: false,
-    transport: ParticipantSettingsTransport::Webrtc,
-    video_constraint_publish_webcam: ParticipantSettingsVideoConstraintPublishWebcam::None,
-    video_constraint_subscribe: ParticipantSettingsVideoConstraintSubscribe::None,
-    video_max_concurrent_tracks: None,
-    video_enabled: true,
-},
-#+END_SRC
-
-Update any schema-mismatch fixture JSON to carry the three new =ParticipantState= fields.
-
-- [ ] Step 3: Update =browser/src/participant/cloudflare/mod.rs=.
-
-Replace =map_command_webcam_resolution= / the settings match with mapping function(s) over =VideoConstraint=. If progenitor emits distinct publish/subscribe enum types, use two functions with identical arms (=map_video_constraint_publish_webcam=, =map_video_constraint_subscribe=). Each arm maps =VideoConstraint::P1080 => ...::P1080=, etc.
-
-Update =map_settings=:
-
-#+BEGIN_SRC rust
-video_constraint_publish_webcam: map_video_constraint_publish_webcam(settings.video_constraint_publish_webcam),
-video_constraint_subscribe: map_video_constraint_subscribe(settings.video_constraint_subscribe),
-video_max_concurrent_tracks: settings.video_max_concurrent_tracks.map(|value| value as f64),
-#+END_SRC
-
-(=video_max_concurrent_tracks= maps to whatever numeric type progenitor generates — likely =Option<f64>=; cast accordingly.)
-
-Update the state mapping (worker → =ParticipantState=) for the three new fields, and =command_request= for the three new message variants:
-
-#+BEGIN_SRC rust
-ParticipantMessage::SetVideoConstraintPublishWebcam(value) => {
-    types::SessionCommandRequest::SetVideoConstraintPublishWebcam {
-        video_constraint_publish_webcam: map_command_video_constraint_publish_webcam(value),
-    }
-}
-ParticipantMessage::SetVideoConstraintSubscribe(value) => {
-    types::SessionCommandRequest::SetVideoConstraintSubscribe {
-        video_constraint_subscribe: map_command_video_constraint_subscribe(value),
-    }
-}
-ParticipantMessage::SetVideoMaxConcurrentTracks(value) => {
-    types::SessionCommandRequest::SetVideoMaxConcurrentTracks {
-        video_max_concurrent_tracks: value.map(|value| value as f64),
-    }
-}
-#+END_SRC
-
-- [ ] Step 4: Update Cloudflare tests and fixtures (=browser/tests/cloudflare_driver.rs= and the in-module tests in =cloudflare/mod.rs=).
-
-Replace the old expected command JSON with three:
-
-#+BEGIN_SRC rust
-json!({ "type": "set-video-constraint-publish-webcam", "videoConstraintPublishWebcam": "1080p" })
-json!({ "type": "set-video-constraint-subscribe", "videoConstraintSubscribe": "720p" })
-json!({ "type": "set-video-max-concurrent-tracks", "videoMaxConcurrentTracks": 2 })
-#+END_SRC
-
-Update worker state fixtures that used =webcamResolution= so they use:
-
-#+BEGIN_SRC json
-"videoConstraintPublishWebcam": "720p",
-"videoConstraintSubscribe": "none",
-"videoMaxConcurrentTracks": null
-#+END_SRC
-
-- [ ] Step 5: Run Cloudflare tests.
-
-#+BEGIN_SRC bash
-cargo test -p cloudflare-worker-client
-cargo test -p client-simulator-browser cloudflare
-#+END_SRC
-
-Expected: both pass.
-
-* Task 7: Remove Legacy References and Run Full Verification
-
-** Files
-
-- Modify any file reported by the search commands in this task.
-
-** Steps
-
-- [ ] Step 1: Search for legacy runtime API references (both repos).
-
-#+BEGIN_SRC bash
-rg -n "videoResolutionForWebcamEncoder|setVideoResolutionForWebcamEncoder" . ../cloudflare-browser-simulator
-#+END_SRC
-
-Expected: no matches in active source (simulator or worker). Doc references are acceptable only if they explicitly describe removed legacy behavior.
-
-- [ ] Step 2: Search for old simulator setting names.
-
-#+BEGIN_SRC bash
-rg -n "\bresolution\b|WebcamResolution|webcam_resolution|SetWebcamResolutions|set_webcam_resolution|webcamResolution|set-webcam-resolution" config/src browser/src tui/src src cloudflare-worker-client browser/tests
-#+END_SRC
-
-Expected: no active simulator code uses old webcam resolution names.
-
-- [ ] Step 3: Format and lint (simulator).
-
-#+BEGIN_SRC bash
-just fmt
-just clippy
-#+END_SRC
-
-Expected: both exit 0.
-
-- [ ] Step 4: Run the full simulator test suite.
-
-#+BEGIN_SRC bash
-just test
-#+END_SRC
-
-Expected: all tests pass.
-
-- [ ] Step 5: MANUAL — deploy the worker and confirm the deployed SDK.
-
-This is the outward-facing, maintainer-approved step. From the worker repo:
-
-#+BEGIN_SRC bash
-just deploy-worker
-#+END_SRC
-
-Confirm =latest.dev.hyper.video= runs a Hyper build exposing =hyper.settings.media.actions.setVideoConstraintPublishWebcam= (and subscribe / max-tracks). If the deployed SDK is behind, the live runs below will fail regardless of code correctness.
-
-- [ ] Step 6: Live local-backend smoke test against latest.dev.
-
-#+BEGIN_SRC bash
-cargo run -- headless \
-  --url https://latest.dev.hyper.video/0Y6-6FZ-20J \
-  --participant '{"backend":"local","video_constraint_publish_webcam":"480p","video_constraint_subscribe":"720p","video_max_concurrent_tracks":1}'
-#+END_SRC
-
-Expected:
-
-- Logs do not contain =Failed to apply settings before joining=.
-- Logs do not contain =videoResolutionForWebcamEncoder=.
-- Participant reaches =Joined the space=.
-- The process stays running until Ctrl-C.
-
-- [ ] Step 7: Nullable track-limit smoke test.
-
-#+BEGIN_SRC bash
-cargo run -- headless \
-  --url https://latest.dev.hyper.video/0Y6-6FZ-20J \
-  --participant '{"backend":"local","video_constraint_publish_webcam":"360p","video_constraint_subscribe":"none","video_max_concurrent_tracks":null}'
-#+END_SRC
-
-Expected:
-
-- Logs do not contain =Failed to apply settings before joining=.
-- Live page has =window.hyper.settings.media.videoMaxConcurrentTracks === null=.
-- Ctrl-C performs graceful shutdown.
-
-- [ ] Step 8: OPTIONAL — live cloudflare-backend smoke test.
-
-After the worker is deployed, optionally run one participant with =--participant '{"backend":"cloudflare", ...}'= against the deployed worker to confirm the three new commands round-trip end-to-end.
-
-* Self-Review Checklist
-
-- [ ] Every active simulator path that used =resolution= now has publish constraint, subscribe constraint, and max-track setting coverage (config, spec, state, messages, runtime, mod, core, lite, remote_stub, headless, TUI, cloudflare).
-- [ ] Local Hyper Core browser automation uses =hyper.settings.media=, not =hyper.settings.videoCodec=, for these settings.
-- [ ] =WebcamResolution= is fully deleted from the simulator (config enum, exports, all usages).
-- [ ] Headless CLI and participant JSON treat =null= / absent as "no override" (plain =Option<usize>=); a numeric value overrides.
-- [ ] TUI start screen exposes three fields; the participants table shows one combined column and edits the three settings via the =r= chooser sub-menu. =Custom= is gone; presets are Unlimited/1/2/3/4.
-- [ ] Worker Zod schemas, controls (=hyper.settings.media=), and lite stub updated; OpenAPI regenerated via =just export-openapi=; =just check-generated= clean.
-- [ ] Simulator re-vendored the regenerated OpenAPI (=0.3.0= → current); progenitor client + mappings updated; wire casing is =1080p=.
-- [ ] Worker deploy + live latest.dev validation performed manually by the maintainer.
-- [ ] Full verification ran with =just fmt=, =just clippy=, =just test=, and at least one live latest.dev smoke test.

From 5acc17c967738bfcb26efd191f3ce128c0a8b0a7 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Wed, 3 Jun 2026 15:57:44 +0200
Subject: [PATCH 29/42] device farm secrets

---
 .env.tpl   | 4 ++++
 .gitignore | 1 +
 justfile   | 3 +++
 3 files changed, 8 insertions(+)
 create mode 100644 .env.tpl

diff --git a/.env.tpl b/.env.tpl
new file mode 100644
index 0000000..b5dc28e
--- /dev/null
+++ b/.env.tpl
@@ -0,0 +1,4 @@
+# AWS device farm
+DEVICE_FARM_AWS_ACCESS_KEY_ID={{ op://infra/aws-device-farm-simulator-credentials/access_key_id }}
+DEVICE_FARM_AWS_SECRET_ACCESS_KEY={{ op://infra/aws-device-farm-simulator-credentials/secret_access_key }}
+DEVICE_FARM_AWS_REGION=us-west-2
diff --git a/.gitignore b/.gitignore
index 99f6144..d2b1c40 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@ target/
 tmp/
 hyper_session_cookies.json
 /.direnv/
+/.env
diff --git a/justfile b/justfile
index 8aa59b4..7e34538 100644
--- a/justfile
+++ b/justfile
@@ -1,6 +1,9 @@
 default:
     just --list
 
+setup:
+    cat .env.tpl | op inject > .env
+
 # -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
 run *flags="":

From cbaeafaa5c342d48e6c6a63d0ac8196b7b85b92c Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 11:47:33 +0200
Subject: [PATCH 30/42] aws device farm: fix joining

---
 Cargo.lock                                 |   3 +
 Cargo.toml                                 |   3 +
 browser/Cargo.toml                         |   3 +
 browser/src/participant/device_farm/mod.rs | 156 ++++++++++++++++++++-
 browser/tests/device_farm_driver.rs        | 105 +++++++++++---
 config/src/participant_config.rs           |  56 +++++++-
 6 files changed, 304 insertions(+), 22 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 902988d..0dc2fbe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -799,8 +799,10 @@ checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 name = "client-simulator-browser"
 version = "0.3.4"
 dependencies = [
+ "async-trait",
  "aws-config",
  "aws-sdk-devicefarm",
+ "bytes",
  "chromiumoxide",
  "chrono",
  "client-simulator-config",
@@ -808,6 +810,7 @@ dependencies = [
  "derive_more",
  "eyre",
  "futures",
+ "http 1.4.0",
  "reqwest",
  "serde",
  "serde_json",
diff --git a/Cargo.toml b/Cargo.toml
index 3854a33..8b492af 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,7 +18,9 @@ repository = "https://github.com/hypervideo/browser-simulator"
 [workspace.dependencies]
 aws-config = { version = "1", default-features = false, features = ["behavior-version-latest", "rt-tokio", "rustls"] }
 aws-sdk-devicefarm = { version = "1", default-features = false, features = ["behavior-version-latest", "rt-tokio", "rustls"] }
+async-trait = "0.1.89"
 better-panic = "0.3.0"
+bytes = "1.11.1"
 chromiumoxide = { version = "0.9.1", features = ["bytes"], default-features = false }
 chrono = { version = "0.4.44", features = ["serde"] }
 clap = { version = "4.6.1", features = ["derive", "env", "cargo", "string"] }
@@ -30,6 +32,7 @@ directories = "6.0.0"
 eyre = "0.6.12"
 futures = "0.3.32"
 human-panic = "2.0.8"
+http = "1.4.0"
 lazy_static = "1.5.0"
 libc = "0.2.186"
 pretty_assertions = "1.4.1"
diff --git a/browser/Cargo.toml b/browser/Cargo.toml
index 453fff4..ef74f9f 100644
--- a/browser/Cargo.toml
+++ b/browser/Cargo.toml
@@ -8,11 +8,14 @@ repository.workspace = true
 [dependencies]
 aws-config.workspace = true
 aws-sdk-devicefarm.workspace = true
+async-trait.workspace = true
+bytes.workspace = true
 chromiumoxide.workspace = true
 chrono.workspace = true
 derive_more.workspace = true
 eyre.workspace = true
 futures.workspace = true
+http.workspace = true
 reqwest.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/browser/src/participant/device_farm/mod.rs b/browser/src/participant/device_farm/mod.rs
index b339da1..c6120b0 100644
--- a/browser/src/participant/device_farm/mod.rs
+++ b/browser/src/participant/device_farm/mod.rs
@@ -47,6 +47,15 @@ pub(crate) use test_grid::AwsTestGrid;
 #[allow(unused_imports)]
 pub use test_grid::TestGridApi;
 use thirtyfour::{
+    common::config::WebDriverConfig,
+    prelude::{
+        WebDriverError,
+        WebDriverResult,
+    },
+    session::http::{
+        Body,
+        HttpClient,
+    },
     CapabilitiesHelper,
     ChromeCapabilities,
     ChromiumLikeCapabilities,
@@ -65,6 +74,11 @@ use tokio::{
 #[allow(unused_imports)]
 pub(crate) use webdriver_driver::WebDriverDriver;
 
+const DEVICE_FARM_MAX_DURATION_MIN_SECS: u64 = 180;
+const DEVICE_FARM_MAX_DURATION_MAX_SECS: u64 = 2400;
+const DEVICE_FARM_IDLE_TIMEOUT_MIN_SECS: u64 = 30;
+const DEVICE_FARM_IDLE_TIMEOUT_MAX_SECS: u64 = 900;
+
 #[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq)]
 pub(super) struct DeviceFarmLaunchOptions {
@@ -156,11 +170,19 @@ impl DeviceFarmSession {
         caps.add_arg("--use-fake-device-for-media-stream")?;
         caps.insert_base_capability(
             "aws:maxDurationSecs".to_string(),
-            serde_json::json!((config.session_max_duration_ms / 1000).max(1)),
+            serde_json::json!(aws_duration_secs(
+                config.session_max_duration_ms,
+                DEVICE_FARM_MAX_DURATION_MIN_SECS,
+                DEVICE_FARM_MAX_DURATION_MAX_SECS,
+            )),
         );
         caps.insert_base_capability(
             "aws:idleTimeoutSecs".to_string(),
-            serde_json::json!((config.idle_timeout_ms / 1000).max(1)),
+            serde_json::json!(aws_duration_secs(
+                config.idle_timeout_ms,
+                DEVICE_FARM_IDLE_TIMEOUT_MIN_SECS,
+                DEVICE_FARM_IDLE_TIMEOUT_MAX_SECS,
+            )),
         );
         Ok(caps)
     }
@@ -170,8 +192,17 @@ impl DeviceFarmSession {
             .create_test_grid_url(&config.project_arn, config.url_expires_seconds)
             .await?;
         let caps = Self::build_capabilities(&config)?;
+        let endpoint_url: url::Url = url
+            .parse()
+            .context("Device Farm returned an invalid Selenium endpoint URL")?;
+        debug!(
+            endpoint_host = endpoint_url.host_str().unwrap_or("<unknown>"),
+            endpoint_uses_wd_hub = endpoint_url.path().ends_with("/wd/hub"),
+            "Received Device Farm Selenium endpoint",
+        );
+        let client = DeviceFarmHttpClient::new(endpoint_url);
         // Device Farm can take 60-120s before a requested session becomes usable.
-        WebDriver::new(&url, caps)
+        WebDriver::new_with_config_and_client(&url, caps, WebDriverConfig::default(), client)
             .await
             .context("failed to connect to Device Farm Selenium endpoint")
     }
@@ -309,6 +340,99 @@ impl DeviceFarmSession {
     }
 }
 
+#[derive(Clone)]
+struct DeviceFarmHttpClient {
+    signed_url: url::Url,
+    inner: reqwest::Client,
+}
+
+impl DeviceFarmHttpClient {
+    fn new(signed_url: url::Url) -> Self {
+        Self {
+            signed_url,
+            inner: reqwest::Client::new(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl HttpClient for DeviceFarmHttpClient {
+    async fn send(&self, request: http::Request<Body<'_>>) -> WebDriverResult<http::Response<bytes::Bytes>> {
+        let request = rewrite_device_farm_request_uri(&self.signed_url, request)?;
+        HttpClient::send(&self.inner, request).await
+    }
+
+    async fn new(&self) -> Arc<dyn HttpClient> {
+        Arc::new(Self::new(self.signed_url.clone()))
+    }
+}
+
+fn rewrite_device_farm_request_uri<'a>(
+    signed_url: &url::Url,
+    request: http::Request<Body<'a>>,
+) -> WebDriverResult<http::Request<Body<'a>>> {
+    let (mut parts, body) = request.into_parts();
+    let rewritten = signed_test_grid_command_url(signed_url, &parts.uri)?;
+    parts.uri = rewritten
+        .as_str()
+        .parse()
+        .map_err(|err| WebDriverError::ParseError(format!("invalid Device Farm WebDriver request URI: {err}")))?;
+    Ok(http::Request::from_parts(parts, body))
+}
+
+fn signed_test_grid_command_url(signed_url: &url::Url, command_uri: &http::Uri) -> WebDriverResult<url::Url> {
+    let mut url = signed_url.clone();
+    let command_path = webdriver_command_path(signed_url, command_uri);
+    let base_path = signed_url.path().trim_end_matches('/');
+    let path = if base_path.is_empty() {
+        format!("/{command_path}")
+    } else if command_path.is_empty() {
+        base_path.to_string()
+    } else {
+        format!("{base_path}/{command_path}")
+    };
+    url.set_path(&path);
+
+    let query = match (signed_url.query(), command_uri.query()) {
+        (Some(signed), Some(command)) if !command.is_empty() => Some(format!("{signed}&{command}")),
+        (Some(signed), _) => Some(signed.to_string()),
+        (None, Some(command)) if !command.is_empty() => Some(command.to_string()),
+        _ => None,
+    };
+    url.set_query(query.as_deref());
+
+    Ok(url)
+}
+
+fn webdriver_command_path(signed_url: &url::Url, command_uri: &http::Uri) -> String {
+    let joined_path = command_uri.path();
+    let base_path = signed_url.path().trim_end_matches('/');
+
+    if !base_path.is_empty() {
+        let base_prefix = format!("{base_path}/");
+        if let Some(command) = joined_path.strip_prefix(&base_prefix) {
+            return command.trim_start_matches('/').to_string();
+        }
+
+        if let Some((parent, _)) = base_path.rsplit_once('/') {
+            let parent_prefix = if parent.is_empty() {
+                "/".to_string()
+            } else {
+                format!("{parent}/")
+            };
+            if let Some(command) = joined_path.strip_prefix(&parent_prefix) {
+                return command.trim_start_matches('/').to_string();
+            }
+        }
+    }
+
+    joined_path.trim_start_matches('/').to_string()
+}
+
+fn aws_duration_secs(duration_ms: u64, min_secs: u64, max_secs: u64) -> u64 {
+    duration_ms.div_ceil(1000).clamp(min_secs, max_secs)
+}
+
 impl ParticipantDriverSession for DeviceFarmSession {
     fn participant_name(&self) -> &str {
         &self.launch_spec.username
@@ -344,3 +468,29 @@ impl ParticipantDriverSession for DeviceFarmSession {
         self.wait_for_termination_inner().boxed()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn capabilities_clamp_aws_duration_ranges() {
+        let high_max_low_idle = capabilities_for_duration(3_600_000, 5_000);
+        assert_eq!(high_max_low_idle._get("aws:maxDurationSecs"), Some(&json!(2400)));
+        assert_eq!(high_max_low_idle._get("aws:idleTimeoutSecs"), Some(&json!(30)));
+
+        let low_max_high_idle = capabilities_for_duration(60_000, 2_000_000);
+        assert_eq!(low_max_high_idle._get("aws:maxDurationSecs"), Some(&json!(180)));
+        assert_eq!(low_max_high_idle._get("aws:idleTimeoutSecs"), Some(&json!(900)));
+    }
+
+    fn capabilities_for_duration(session_max_duration_ms: u64, idle_timeout_ms: u64) -> ChromeCapabilities {
+        let config = DeviceFarmConfig {
+            session_max_duration_ms,
+            idle_timeout_ms,
+            ..DeviceFarmConfig::default()
+        };
+        DeviceFarmSession::build_capabilities(&config).unwrap()
+    }
+}
diff --git a/browser/tests/device_farm_driver.rs b/browser/tests/device_farm_driver.rs
index 323247e..a355493 100644
--- a/browser/tests/device_farm_driver.rs
+++ b/browser/tests/device_farm_driver.rs
@@ -82,6 +82,38 @@ async fn device_farm_session_creates_url_connects_joins_and_closes() {
     assert!(paths.contains(&("DELETE", "/session/df-1")));
 }
 
+#[tokio::test]
+async fn device_farm_session_preserves_signed_test_grid_url_path_and_query() {
+    let signature = "X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Signature=test-signature";
+    let (base_url, requests, server) = spawn_webdriver_mock_with_options(WebDriverMockOptions {
+        path_prefix: "/signed-grid/wd/hub".to_string(),
+        required_query: Some(signature.to_string()),
+    })
+    .await;
+    let cookie_manager = HyperSessionCookieManger::new(unique_temp_dir().join("cookies.json"));
+    let participant = Participant::spawn_device_farm_with_api(
+        &device_farm_config(),
+        cookie_manager,
+        Arc::new(TestGridStub {
+            url: format!("{base_url}/signed-grid/wd/hub?{signature}"),
+        }),
+    )
+    .expect("device farm participant should spawn");
+    let state = participant.state.clone();
+
+    let joined = wait_for_state(&state, |current| current.running && current.joined).await;
+    assert!(joined.running);
+    assert!(joined.joined);
+
+    participant.close().await;
+    server.abort();
+
+    let requests = requests.lock().unwrap().clone();
+    assert!(requests
+        .iter()
+        .all(|request| { request.path.starts_with("/signed-grid/wd/hub/") && request.path.contains(signature) }));
+}
+
 #[derive(Debug)]
 struct TestGridStub {
     url: String,
@@ -136,18 +168,31 @@ struct WebDriverState {
     joined: bool,
 }
 
+#[derive(Debug, Default)]
+struct WebDriverMockOptions {
+    path_prefix: String,
+    required_query: Option<String>,
+}
+
 async fn spawn_webdriver_mock() -> (String, Arc<Mutex<Vec<CapturedRequest>>>, tokio::task::JoinHandle<()>) {
+    spawn_webdriver_mock_with_options(WebDriverMockOptions::default()).await
+}
+
+async fn spawn_webdriver_mock_with_options(
+    options: WebDriverMockOptions,
+) -> (String, Arc<Mutex<Vec<CapturedRequest>>>, tokio::task::JoinHandle<()>) {
     let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
     let base_url = format!("http://{}", listener.local_addr().unwrap());
     let requests = Arc::new(Mutex::new(Vec::new()));
     let requests_for_task = Arc::clone(&requests);
     let state = Arc::new(Mutex::new(WebDriverState::default()));
+    let options = Arc::new(options);
 
     let task = tokio::spawn(async move {
         loop {
             let (mut stream, _) = listener.accept().await.unwrap();
             let request = read_request(&mut stream).await;
-            let response = webdriver_response(&request, &state);
+            let response = webdriver_response(&request, &state, &options);
             requests_for_task.lock().unwrap().push(request);
             write_response(&mut stream, response).await;
         }
@@ -156,8 +201,16 @@ async fn spawn_webdriver_mock() -> (String, Arc<Mutex<Vec<CapturedRequest>>>, to
     (base_url, requests, task)
 }
 
-fn webdriver_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriverState>>) -> MockResponse {
-    match (request.method.as_str(), request.path.as_str()) {
+fn webdriver_response(
+    request: &CapturedRequest,
+    state: &Arc<Mutex<WebDriverState>>,
+    options: &WebDriverMockOptions,
+) -> MockResponse {
+    let Some(path) = normalize_signed_path(request, options) else {
+        return no_such_element();
+    };
+
+    match (request.method.as_str(), path.as_str()) {
         ("POST", "/session") => MockResponse::json(
             200,
             json!({
@@ -173,12 +226,33 @@ fn webdriver_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriverStat
         ("GET", "/session/df-1/url") => MockResponse::json(200, json!({ "value": "https://example.com/m/demo" })),
         ("DELETE", "/session/df-1") => MockResponse::json(200, json!({ "value": null })),
         ("POST", "/session/df-1/element") => element_response(request, state),
-        _ if request.path.starts_with("/session/df-1/element/") => element_command_response(request, state),
-        _ if request.path == "/session/df-1/execute/sync" => MockResponse::json(200, json!({ "value": null })),
+        _ if path.starts_with("/session/df-1/element/") => element_command_response(&path, state),
+        _ if path == "/session/df-1/execute/sync" => MockResponse::json(200, json!({ "value": null })),
         _ => MockResponse::json(200, json!({ "value": null })),
     }
 }
 
+fn normalize_signed_path(request: &CapturedRequest, options: &WebDriverMockOptions) -> Option<String> {
+    let (path, query) = request
+        .path
+        .split_once('?')
+        .map_or((request.path.as_str(), ""), |(path, query)| (path, query));
+
+    if let Some(required_query) = &options.required_query {
+        if query != required_query {
+            return None;
+        }
+    }
+
+    if options.path_prefix.is_empty() {
+        return Some(path.to_string());
+    }
+
+    path.strip_prefix(&options.path_prefix)
+        .filter(|path| path.starts_with('/'))
+        .map(ToOwned::to_owned)
+}
+
 fn element_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriverState>>) -> MockResponse {
     let selector = request_json(request)["value"].as_str().unwrap_or_default().to_string();
     let joined = state.lock().unwrap().joined;
@@ -212,26 +286,21 @@ fn element_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriverState>
     element("generic")
 }
 
-fn element_command_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriverState>>) -> MockResponse {
-    if request.path.ends_with("/click") {
-        if request.path.contains("/element/join/") {
+fn element_command_response(path: &str, state: &Arc<Mutex<WebDriverState>>) -> MockResponse {
+    if path.ends_with("/click") {
+        if path.contains("/element/join/") {
             state.lock().unwrap().joined = true;
-        } else if request.path.contains("/element/leave/") || request.path.contains("/element/confirm/") {
+        } else if path.contains("/element/leave/") || path.contains("/element/confirm/") {
             state.lock().unwrap().joined = false;
         }
         return MockResponse::json(200, json!({ "value": null }));
     }
 
-    if let Some(attribute) = request
-        .path
-        .rsplit('/')
-        .next()
-        .filter(|_| request.path.contains("/attribute/"))
-    {
+    if let Some(attribute) = path.rsplit('/').next().filter(|_| path.contains("/attribute/")) {
         let value = match attribute {
-            "data-test-state" if request.path.contains("/element/audio/") => json!("true"),
-            "data-test-state" if request.path.contains("/element/video/") => json!("true"),
-            "data-test-state" if request.path.contains("/element/screen/") => json!("false"),
+            "data-test-state" if path.contains("/element/audio/") => json!("true"),
+            "data-test-state" if path.contains("/element/video/") => json!("true"),
+            "data-test-state" if path.contains("/element/screen/") => json!("false"),
             "aria-pressed" => Value::Null,
             "aria-label" => Value::Null,
             _ => Value::Null,
diff --git a/config/src/participant_config.rs b/config/src/participant_config.rs
index 7985559..99fa682 100644
--- a/config/src/participant_config.rs
+++ b/config/src/participant_config.rs
@@ -20,7 +20,7 @@ impl ParticipantConfig {
         let name = if let Some(name) = name {
             name.to_string()
         } else {
-            generate_random_name()
+            format!("{}{}", backend_name_prefix(config.backend), generate_random_name())
         };
         let url = config.url.clone().ok_or_eyre("No session URL provided")?;
         Ok(Self {
@@ -41,3 +41,57 @@ pub fn generate_random_name() -> String {
     let mut generator = Generator::with_naming(Name::Numbered);
     generator.next().unwrap()
 }
+
+const fn backend_name_prefix(backend: super::ParticipantBackendKind) -> &'static str {
+    match backend {
+        super::ParticipantBackendKind::Local => "local-",
+        super::ParticipantBackendKind::RemoteStub => "stub-",
+        super::ParticipantBackendKind::Cloudflare => "cf-",
+        super::ParticipantBackendKind::AwsDeviceFarm => "aws-",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ParticipantBackendKind;
+
+    fn config_with_backend(backend: ParticipantBackendKind) -> super::super::Config {
+        super::super::Config {
+            url: Some(Url::parse("https://example.com/space/test").expect("valid URL")),
+            backend,
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn generated_names_are_prefixed_by_backend() {
+        let cases = [
+            (ParticipantBackendKind::Local, "local-"),
+            (ParticipantBackendKind::RemoteStub, "stub-"),
+            (ParticipantBackendKind::Cloudflare, "cf-"),
+            (ParticipantBackendKind::AwsDeviceFarm, "aws-"),
+        ];
+
+        for (backend, prefix) in cases {
+            let config = config_with_backend(backend);
+            let participant = ParticipantConfig::new(&config, None::<String>).expect("participant config");
+
+            assert!(
+                participant.username.starts_with(prefix),
+                "expected {:?} generated name {:?} to start with {:?}",
+                backend,
+                participant.username,
+                prefix
+            );
+        }
+    }
+
+    #[test]
+    fn provided_names_are_not_prefixed() {
+        let config = config_with_backend(ParticipantBackendKind::Cloudflare);
+        let participant = ParticipantConfig::new(&config, Some("Ada")).expect("participant config");
+
+        assert_eq!(participant.username, "Ada");
+    }
+}

From 66d07454d4d7c7dd255b38c892ce9936cf18cd52 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 11:48:03 +0200
Subject: [PATCH 31/42] secrets

---
 .env.tpl | 1 +
 .envrc   | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/.env.tpl b/.env.tpl
index b5dc28e..c9fcb45 100644
--- a/.env.tpl
+++ b/.env.tpl
@@ -2,3 +2,4 @@
 DEVICE_FARM_AWS_ACCESS_KEY_ID={{ op://infra/aws-device-farm-simulator-credentials/access_key_id }}
 DEVICE_FARM_AWS_SECRET_ACCESS_KEY={{ op://infra/aws-device-farm-simulator-credentials/secret_access_key }}
 DEVICE_FARM_AWS_REGION=us-west-2
+DEVICE_FARM_PROJECT_ARN={{ op://infra/aws-device-farm-simulator-credentials/mgpse2ej3msjproinokciv773m }}
diff --git a/.envrc b/.envrc
index 78deaa5..becbf1c 100644
--- a/.envrc
+++ b/.envrc
@@ -1,2 +1,4 @@
 export NIXPKGS_ALLOW_UNFREE=1 # for google-chrome
 use flake . --impure
+
+dotenv_if_exists .env

From f34897f664ac1ab86d3c6f6afeeb74dd26173130 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 13:07:56 +0200
Subject: [PATCH 32/42] Fix Device Farm state polling

---
 browser/src/participant/device_farm/mod.rs |  74 ++++++--
 browser/src/participant/shared/runtime.rs  | 111 ++++++++++--
 browser/tests/device_farm_driver.rs        | 196 ++++++++++++++++++++-
 3 files changed, 343 insertions(+), 38 deletions(-)

diff --git a/browser/src/participant/device_farm/mod.rs b/browser/src/participant/device_farm/mod.rs
index c6120b0..16ddf46 100644
--- a/browser/src/participant/device_farm/mod.rs
+++ b/browser/src/participant/device_farm/mod.rs
@@ -33,6 +33,7 @@ use eyre::{
     bail,
     Context as _,
     ContextCompat as _,
+    Report,
     Result,
 };
 use futures::{
@@ -232,9 +233,10 @@ impl DeviceFarmSession {
         };
         let mut automation = FrontendKindBuilder::build(context, auth).await?;
 
-        self.start_keep_alive_poller();
+        self.termination_tx.send_replace(None);
+        self.start_max_duration_poller();
         if let Err(err) = automation.join().await {
-            self.stop_keep_alive_poller().await;
+            self.stop_max_duration_poller().await;
             return Err(err);
         }
 
@@ -252,16 +254,29 @@ impl DeviceFarmSession {
 
     fn effective_poll_interval(&self) -> Duration {
         let configured = self.config.health_poll_interval_ms.max(1);
-        let budget = self.config.idle_timeout_ms.saturating_div(2).max(1);
+        let budget = aws_duration_secs(
+            self.config.idle_timeout_ms,
+            DEVICE_FARM_IDLE_TIMEOUT_MIN_SECS,
+            DEVICE_FARM_IDLE_TIMEOUT_MAX_SECS,
+        )
+        .saturating_mul(500)
+        .max(1);
         Duration::from_millis(configured.min(budget))
     }
 
-    fn start_keep_alive_poller(&mut self) {
-        // The WebDriver is owned by frontend automation, so Phase 4 keeps
-        // reclamation implicit: Device Farm reclaims an abandoned session after
-        // aws:idleTimeoutSecs, and hard-stops it at aws:maxDurationSecs.
+    fn effective_max_duration(&self) -> Duration {
+        Duration::from_secs(aws_duration_secs(
+            self.config.session_max_duration_ms,
+            DEVICE_FARM_MAX_DURATION_MIN_SECS,
+            DEVICE_FARM_MAX_DURATION_MAX_SECS,
+        ))
+    }
+
+    fn start_max_duration_poller(&mut self) {
+        // Periodic runtime state refreshes send WebDriver commands and keep the
+        // AWS idle timeout alive. This task only mirrors the AWS hard session cap.
         let interval = self.effective_poll_interval();
-        let max_duration = Duration::from_millis(self.config.session_max_duration_ms);
+        let max_duration = self.effective_max_duration();
         let termination_tx = self.termination_tx.clone();
         let (shutdown_tx, mut shutdown_rx) = oneshot::channel();
 
@@ -290,7 +305,7 @@ impl DeviceFarmSession {
         self.poller_task = Some(task);
     }
 
-    async fn stop_keep_alive_poller(&mut self) {
+    async fn stop_max_duration_poller(&mut self) {
         if let Some(tx) = self.poller_shutdown_tx.take() {
             let _ = tx.send(());
         }
@@ -300,7 +315,7 @@ impl DeviceFarmSession {
     }
 
     async fn close_inner(&mut self) -> Result<()> {
-        self.stop_keep_alive_poller().await;
+        self.stop_max_duration_poller().await;
 
         if let Some(mut automation) = self.automation.take() {
             let joined = automation
@@ -328,6 +343,14 @@ impl DeviceFarmSession {
         Ok(())
     }
 
+    async fn ping_webdriver(driver: WebDriver) -> Result<()> {
+        driver
+            .current_url()
+            .await
+            .context("Device Farm WebDriver session is not responsive")?;
+        Ok(())
+    }
+
     async fn wait_for_termination_inner(&mut self) -> DriverTermination {
         loop {
             if let Some(termination) = self.termination_rx.borrow().clone() {
@@ -448,14 +471,20 @@ impl ParticipantDriverSession for DeviceFarmSession {
 
     fn refresh_state(&mut self) -> BoxFuture<'_, Result<ParticipantState>> {
         async move {
-            match self.automation.as_mut() {
-                Some(automation) => {
-                    let state = automation.refresh_state().await?;
-                    self.cached_state = state.clone();
-                    Ok(state)
-                }
-                None => Ok(self.cached_state.clone()),
+            if self.automation.is_none() {
+                return Ok(self.cached_state.clone());
             }
+
+            let driver = self
+                .webdriver
+                .as_ref()
+                .context("Device Farm WebDriver session not started")?
+                .clone();
+            Self::ping_webdriver(driver).await?;
+            let automation = self.automation.as_mut().context("Device Farm automation not started")?;
+            let state = automation.refresh_state().await?;
+            self.cached_state = state.clone();
+            Ok(state)
         }
         .boxed()
     }
@@ -467,6 +496,17 @@ impl ParticipantDriverSession for DeviceFarmSession {
     fn wait_for_termination(&mut self) -> BoxFuture<'_, DriverTermination> {
         self.wait_for_termination_inner().boxed()
     }
+
+    fn state_refresh_interval(&self) -> Option<Duration> {
+        Some(self.effective_poll_interval())
+    }
+
+    fn state_refresh_error_termination(&self, err: &Report) -> Option<DriverTermination> {
+        Some(DriverTermination::new(
+            "warn",
+            format!("Device Farm browser session stopped responding while refreshing state: {err}"),
+        ))
+    }
 }
 
 #[cfg(test)]
diff --git a/browser/src/participant/shared/runtime.rs b/browser/src/participant/shared/runtime.rs
index 58f418e..f805a7f 100644
--- a/browser/src/participant/shared/runtime.rs
+++ b/browser/src/participant/shared/runtime.rs
@@ -5,14 +5,27 @@ use super::{
     },
     ParticipantState,
 };
-use eyre::Result;
+use eyre::{
+    Report,
+    Result,
+};
 use futures::future::BoxFuture;
-use tokio::sync::{
-    mpsc::{
-        UnboundedReceiver,
-        UnboundedSender,
+use std::{
+    future::pending,
+    time::Duration,
+};
+use tokio::{
+    sync::{
+        mpsc::{
+            UnboundedReceiver,
+            UnboundedSender,
+        },
+        watch,
+    },
+    time::{
+        Instant,
+        MissedTickBehavior,
     },
-    watch,
 };
 use tokio_util::sync::CancellationToken;
 
@@ -40,6 +53,14 @@ pub(in crate::participant) trait ParticipantDriverSession: Send {
     fn refresh_state(&mut self) -> BoxFuture<'_, Result<ParticipantState>>;
     fn close(&mut self) -> BoxFuture<'_, Result<()>>;
     fn wait_for_termination(&mut self) -> BoxFuture<'_, DriverTermination>;
+
+    fn state_refresh_interval(&self) -> Option<Duration> {
+        None
+    }
+
+    fn state_refresh_error_termination(&self, _err: &Report) -> Option<DriverTermination> {
+        None
+    }
 }
 
 /// Drive one participant session by translating runtime messages into backend operations.
@@ -95,13 +116,33 @@ where
         return Ok(());
     }
 
-    sync_state(&mut driver, &state, &sender).await;
+    if let Some(termination) = sync_state(&mut driver, &state, &sender).await {
+        let participant_name = driver.participant_name().to_string();
+        log_runtime_message(&sender, termination.level, &participant_name, termination.message);
+        if let Err(err) = driver.close().await {
+            log_runtime_message(
+                &sender,
+                "error",
+                &participant_name,
+                format!("Failed closing participant after state refresh failure: {err}"),
+            );
+        }
+        mark_stopped(&state);
+        return Ok(());
+    }
+
+    let mut state_refresh_ticker = driver.state_refresh_interval().map(|interval| {
+        let mut ticker = tokio::time::interval_at(Instant::now() + interval, interval);
+        ticker.set_missed_tick_behavior(MissedTickBehavior::Delay);
+        ticker
+    });
 
     loop {
         enum RuntimeEvent {
             Command(ParticipantMessage),
             ChannelClosed,
             Terminated(DriverTermination),
+            RefreshState,
             Cancelled,
         }
 
@@ -114,6 +155,13 @@ where
                 Some(message) => RuntimeEvent::Command(message),
                 None => RuntimeEvent::ChannelClosed,
             },
+            _ = async {
+                if let Some(ticker) = state_refresh_ticker.as_mut() {
+                    ticker.tick().await;
+                } else {
+                    pending::<()>().await;
+                }
+            } => RuntimeEvent::RefreshState,
         };
 
         match event {
@@ -152,6 +200,21 @@ where
                 }
                 break;
             }
+            RuntimeEvent::RefreshState => {
+                if let Some(termination) = sync_state(&mut driver, &state, &sender).await {
+                    let participant_name = driver.participant_name().to_string();
+                    log_runtime_message(&sender, termination.level, &participant_name, termination.message);
+                    if let Err(err) = driver.close().await {
+                        log_runtime_message(
+                            &sender,
+                            "error",
+                            &participant_name,
+                            format!("Failed closing participant after state refresh failure: {err}"),
+                        );
+                    }
+                    break;
+                }
+            }
             RuntimeEvent::Command(ParticipantMessage::Close) => {
                 if let Err(err) = driver.close().await {
                     log_runtime_message(
@@ -173,7 +236,19 @@ where
                     );
                 }
 
-                sync_state(&mut driver, &state, &sender).await;
+                if let Some(termination) = sync_state(&mut driver, &state, &sender).await {
+                    let participant_name = driver.participant_name().to_string();
+                    log_runtime_message(&sender, termination.level, &participant_name, termination.message);
+                    if let Err(err) = driver.close().await {
+                        log_runtime_message(
+                            &sender,
+                            "error",
+                            &participant_name,
+                            format!("Failed closing participant after state refresh failure: {err}"),
+                        );
+                    }
+                    break;
+                }
             }
         }
     }
@@ -188,7 +263,8 @@ async fn sync_state<D>(
     driver: &mut D,
     state: &watch::Sender<ParticipantState>,
     sender: &UnboundedSender<ParticipantLogMessage>,
-) where
+) -> Option<DriverTermination>
+where
     D: ParticipantDriverSession,
 {
     match driver.refresh_state().await {
@@ -198,14 +274,19 @@ async fn sync_state<D>(
             state.send_modify(|current| {
                 *current = next_state;
             });
+            None
         }
         Err(err) => {
-            log_runtime_message(
-                sender,
-                "error",
-                driver.participant_name(),
-                format!("Failed refreshing participant state: {err}"),
-            );
+            let termination = driver.state_refresh_error_termination(&err);
+            if termination.is_none() {
+                log_runtime_message(
+                    sender,
+                    "error",
+                    driver.participant_name(),
+                    format!("Failed refreshing participant state: {err}"),
+                );
+            }
+            termination
         }
     }
 }
diff --git a/browser/tests/device_farm_driver.rs b/browser/tests/device_farm_driver.rs
index a355493..3c731b2 100644
--- a/browser/tests/device_farm_driver.rs
+++ b/browser/tests/device_farm_driver.rs
@@ -64,6 +64,9 @@ async fn device_farm_session_creates_url_connects_joins_and_closes() {
     let joined = wait_for_state(&state, |current| current.running && current.joined).await;
     assert!(joined.running);
     assert!(joined.joined);
+    assert!(!joined.muted);
+    assert!(joined.video_activated);
+    assert!(!joined.screenshare_activated);
 
     participant.close().await;
     assert!(!state.borrow().running);
@@ -88,6 +91,7 @@ async fn device_farm_session_preserves_signed_test_grid_url_path_and_query() {
     let (base_url, requests, server) = spawn_webdriver_mock_with_options(WebDriverMockOptions {
         path_prefix: "/signed-grid/wd/hub".to_string(),
         required_query: Some(signature.to_string()),
+        ..Default::default()
     })
     .await;
     let cookie_manager = HyperSessionCookieManger::new(unique_temp_dir().join("cookies.json"));
@@ -114,6 +118,130 @@ async fn device_farm_session_preserves_signed_test_grid_url_path_and_query() {
         .all(|request| { request.path.starts_with("/signed-grid/wd/hub/") && request.path.contains(signature) }));
 }
 
+#[tokio::test]
+async fn device_farm_session_polls_and_publishes_frontend_state_changes() {
+    let (base_url, requests, server) = spawn_webdriver_mock_with_options(WebDriverMockOptions {
+        media_change_after_attribute_reads: Some(5),
+        ..Default::default()
+    })
+    .await;
+    let cookie_manager = HyperSessionCookieManger::new(unique_temp_dir().join("cookies.json"));
+    let mut config = device_farm_config();
+    config.device_farm.health_poll_interval_ms = 100;
+    let participant =
+        Participant::spawn_device_farm_with_api(&config, cookie_manager, Arc::new(TestGridStub { url: base_url }))
+            .expect("device farm participant should spawn");
+    let state = participant.state.clone();
+
+    let initial = {
+        let mut state = state.clone();
+        timeout(Duration::from_secs(2), async move {
+            state
+                .wait_for(|current| {
+                    current.running
+                        && current.joined
+                        && !current.muted
+                        && current.video_activated
+                        && !current.screenshare_activated
+                })
+                .await
+                .unwrap()
+                .clone()
+        })
+        .await
+    };
+
+    if initial.is_err() {
+        participant.clone().close().await;
+        server.abort();
+    }
+
+    let initial = initial.unwrap_or_else(|_| {
+        panic!(
+            "timed out waiting for initial Device Farm state; current: {:?}; requests: {:?}",
+            state.borrow(),
+            request_summary(&requests.lock().unwrap())
+        )
+    });
+    assert!(!initial.muted);
+    assert!(initial.video_activated);
+    assert!(!initial.screenshare_activated);
+
+    let updated = {
+        let mut state = state.clone();
+        timeout(Duration::from_secs(2), async move {
+            state
+                .wait_for(|current| {
+                    current.running
+                        && current.joined
+                        && current.muted
+                        && !current.video_activated
+                        && current.screenshare_activated
+                })
+                .await
+                .unwrap()
+                .clone()
+        })
+        .await
+    };
+
+    if updated.is_err() {
+        participant.clone().close().await;
+        server.abort();
+    }
+
+    let updated = updated.unwrap_or_else(|_| {
+        panic!(
+            "timed out waiting for Device Farm state refresh; requests: {:?}",
+            request_summary(&requests.lock().unwrap())
+        )
+    });
+    assert!(updated.muted);
+    assert!(!updated.video_activated);
+    assert!(updated.screenshare_activated);
+
+    participant.close().await;
+    server.abort();
+}
+
+#[tokio::test]
+async fn device_farm_session_stops_when_webdriver_health_check_fails() {
+    let (base_url, _requests, server) = spawn_webdriver_mock_with_options(WebDriverMockOptions {
+        fail_current_url_after: Some(1),
+        ..Default::default()
+    })
+    .await;
+    let cookie_manager = HyperSessionCookieManger::new(unique_temp_dir().join("cookies.json"));
+    let mut config = device_farm_config();
+    config.device_farm.health_poll_interval_ms = 20;
+    let participant =
+        Participant::spawn_device_farm_with_api(&config, cookie_manager, Arc::new(TestGridStub { url: base_url }))
+            .expect("device farm participant should spawn");
+    let state = participant.state.clone();
+
+    wait_for_state(&state, |current| current.running && current.joined).await;
+
+    let stopped = {
+        let mut state = state.clone();
+        timeout(Duration::from_secs(2), async move {
+            state
+                .wait_for(|current| !current.running && !current.joined)
+                .await
+                .unwrap()
+                .clone()
+        })
+        .await
+    };
+
+    participant.close().await;
+    server.abort();
+
+    assert!(
+        stopped.is_ok(),
+        "Device Farm participant should stop when WebDriver stops responding"
+    );
+}
+
 #[derive(Debug)]
 struct TestGridStub {
     url: String,
@@ -166,12 +294,16 @@ struct CapturedRequest {
 #[derive(Debug, Default)]
 struct WebDriverState {
     joined: bool,
+    current_url_requests: usize,
+    media_attribute_reads: usize,
 }
 
 #[derive(Debug, Default)]
 struct WebDriverMockOptions {
     path_prefix: String,
     required_query: Option<String>,
+    media_change_after_attribute_reads: Option<usize>,
+    fail_current_url_after: Option<usize>,
 }
 
 async fn spawn_webdriver_mock() -> (String, Arc<Mutex<Vec<CapturedRequest>>>, tokio::task::JoinHandle<()>) {
@@ -223,15 +355,37 @@ fn webdriver_response(
             }),
         ),
         ("POST", "/session/df-1/url") => MockResponse::json(200, json!({ "value": null })),
-        ("GET", "/session/df-1/url") => MockResponse::json(200, json!({ "value": "https://example.com/m/demo" })),
+        ("GET", "/session/df-1/url") => current_url_response(state, options),
         ("DELETE", "/session/df-1") => MockResponse::json(200, json!({ "value": null })),
         ("POST", "/session/df-1/element") => element_response(request, state),
-        _ if path.starts_with("/session/df-1/element/") => element_command_response(&path, state),
+        _ if path.starts_with("/session/df-1/element/") => element_command_response(&path, state, options),
         _ if path == "/session/df-1/execute/sync" => MockResponse::json(200, json!({ "value": null })),
         _ => MockResponse::json(200, json!({ "value": null })),
     }
 }
 
+fn current_url_response(state: &Arc<Mutex<WebDriverState>>, options: &WebDriverMockOptions) -> MockResponse {
+    let mut state = state.lock().unwrap();
+    state.current_url_requests += 1;
+    if options
+        .fail_current_url_after
+        .is_some_and(|limit| state.current_url_requests > limit)
+    {
+        return MockResponse::json(
+            500,
+            json!({
+                "value": {
+                    "error": "invalid session id",
+                    "message": "session is no longer available",
+                    "stacktrace": ""
+                }
+            }),
+        );
+    }
+
+    MockResponse::json(200, json!({ "value": "https://example.com/m/demo" }))
+}
+
 fn normalize_signed_path(request: &CapturedRequest, options: &WebDriverMockOptions) -> Option<String> {
     let (path, query) = request
         .path
@@ -286,7 +440,11 @@ fn element_response(request: &CapturedRequest, state: &Arc<Mutex<WebDriverState>
     element("generic")
 }
 
-fn element_command_response(path: &str, state: &Arc<Mutex<WebDriverState>>) -> MockResponse {
+fn element_command_response(
+    path: &str,
+    state: &Arc<Mutex<WebDriverState>>,
+    options: &WebDriverMockOptions,
+) -> MockResponse {
     if path.ends_with("/click") {
         if path.contains("/element/join/") {
             state.lock().unwrap().joined = true;
@@ -297,10 +455,29 @@ fn element_command_response(path: &str, state: &Arc<Mutex<WebDriverState>>) -> M
     }
 
     if let Some(attribute) = path.rsplit('/').next().filter(|_| path.contains("/attribute/")) {
+        let media_attribute = attribute == "data-test-state"
+            && (path.contains("/element/audio/")
+                || path.contains("/element/video/")
+                || path.contains("/element/screen/"));
+        let media_changed = {
+            let mut state = state.lock().unwrap();
+            if media_attribute {
+                state.media_attribute_reads += 1;
+            }
+            options
+                .media_change_after_attribute_reads
+                .is_some_and(|limit| state.media_attribute_reads > limit)
+        };
         let value = match attribute {
-            "data-test-state" if path.contains("/element/audio/") => json!("true"),
-            "data-test-state" if path.contains("/element/video/") => json!("true"),
-            "data-test-state" if path.contains("/element/screen/") => json!("false"),
+            "data-test-state" if path.contains("/element/audio/") => {
+                json!(if media_changed { "false" } else { "true" })
+            }
+            "data-test-state" if path.contains("/element/video/") => {
+                json!(if media_changed { "false" } else { "true" })
+            }
+            "data-test-state" if path.contains("/element/screen/") => {
+                json!(if media_changed { "true" } else { "false" })
+            }
             "aria-pressed" => Value::Null,
             "aria-label" => Value::Null,
             _ => Value::Null,
@@ -417,6 +594,13 @@ fn request_json(request: &CapturedRequest) -> Value {
     serde_json::from_str(&request.body).unwrap_or(Value::Null)
 }
 
+fn request_summary(requests: &[CapturedRequest]) -> Vec<String> {
+    requests
+        .iter()
+        .map(|request| format!("{} {}", request.method, request.path))
+        .collect()
+}
+
 fn unique_temp_dir() -> PathBuf {
     let nonce = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
     let dir = std::env::temp_dir().join(format!("hyper-browser-simulator-device-farm-it-{nonce}"));

From 50b7923c0d78e90bf7bd9bd17b548cb0c2f0657b Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 15:45:32 +0200
Subject: [PATCH 33/42] embed device farm secrets

---
 browser/src/participant/device_farm/test_grid.rs | 12 ++++++++++++
 config/src/device_farm_config.rs                 | 15 +++++++++------
 config/src/lib.rs                                | 13 +++++++++++--
 3 files changed, 32 insertions(+), 8 deletions(-)

diff --git a/browser/src/participant/device_farm/test_grid.rs b/browser/src/participant/device_farm/test_grid.rs
index c488116..afc037a 100644
--- a/browser/src/participant/device_farm/test_grid.rs
+++ b/browser/src/participant/device_farm/test_grid.rs
@@ -1,3 +1,7 @@
+use client_simulator_config::{
+    DEVICE_FARM_AWS_ACCESS_KEY_ID,
+    DEVICE_FARM_AWS_SECRET_ACCESS_KEY,
+};
 use eyre::{
     Context as _,
     Result,
@@ -33,8 +37,16 @@ impl AwsTestGrid {
         self.client
             .get_or_init(|| async move {
                 let region = aws_sdk_devicefarm::config::Region::new(region);
+                let credentials = aws_sdk_devicefarm::config::Credentials::new(
+                    DEVICE_FARM_AWS_ACCESS_KEY_ID,
+                    DEVICE_FARM_AWS_SECRET_ACCESS_KEY,
+                    None,
+                    None,
+                    "embedded-device-farm-env",
+                );
                 let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
                     .region(region)
+                    .credentials_provider(credentials)
                     .load()
                     .await;
                 aws_sdk_devicefarm::Client::new(&config)
diff --git a/config/src/device_farm_config.rs b/config/src/device_farm_config.rs
index d276150..d47c92a 100644
--- a/config/src/device_farm_config.rs
+++ b/config/src/device_farm_config.rs
@@ -3,12 +3,14 @@ use serde::{
     Serialize,
 };
 
-const DEFAULT_REGION: &str = "us-west-2";
+pub const DEVICE_FARM_AWS_ACCESS_KEY_ID: &str = env!("DEVICE_FARM_AWS_ACCESS_KEY_ID");
+pub const DEVICE_FARM_AWS_SECRET_ACCESS_KEY: &str = env!("DEVICE_FARM_AWS_SECRET_ACCESS_KEY");
+pub const DEVICE_FARM_AWS_REGION: &str = env!("DEVICE_FARM_AWS_REGION");
+pub const DEVICE_FARM_PROJECT_ARN: &str = env!("DEVICE_FARM_PROJECT_ARN");
 
 /// Configuration for the AWS Device Farm desktop-browser ("Test Grid") backend.
 ///
-/// Credentials are NOT stored here; they are resolved from the standard AWS
-/// credential chain (env vars / shared profile) by `aws-config` at runtime.
+/// Credentials are embedded at compile time.
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub struct DeviceFarmConfig {
     /// ARN of the Device Farm Test Grid project (from Terraform output).
@@ -37,8 +39,8 @@ impl DeviceFarmConfig {
 impl Default for DeviceFarmConfig {
     fn default() -> Self {
         Self {
-            project_arn: String::new(),
-            region: DEFAULT_REGION.to_owned(),
+            project_arn: DEVICE_FARM_PROJECT_ARN.to_owned(),
+            region: DEVICE_FARM_AWS_REGION.to_owned(),
             url_expires_seconds: 300,
             session_max_duration_ms: 1_800_000,
             idle_timeout_ms: 180_000,
@@ -57,7 +59,8 @@ mod tests {
     #[test]
     fn default_targets_us_west_2_and_is_default() {
         let config = DeviceFarmConfig::default();
-        assert_eq!(config.region, "us-west-2");
+        assert_eq!(config.region, DEVICE_FARM_AWS_REGION);
+        assert_eq!(config.project_arn, DEVICE_FARM_PROJECT_ARN);
         assert!(config.is_default());
         // Poll interval must stay safely inside the idle timeout window.
         assert!(config.health_poll_interval_ms < config.idle_timeout_ms);
diff --git a/config/src/lib.rs b/config/src/lib.rs
index 15a6a04..c5cc100 100644
--- a/config/src/lib.rs
+++ b/config/src/lib.rs
@@ -34,7 +34,13 @@ pub use client_config::{
 };
 pub use cloudflare_config::CloudflareConfig;
 use color_eyre::Result;
-pub use device_farm_config::DeviceFarmConfig;
+pub use device_farm_config::{
+    DeviceFarmConfig,
+    DEVICE_FARM_AWS_ACCESS_KEY_ID,
+    DEVICE_FARM_AWS_REGION,
+    DEVICE_FARM_AWS_SECRET_ACCESS_KEY,
+    DEVICE_FARM_PROJECT_ARN,
+};
 use eyre::Context as _;
 pub use participant_config::{
     generate_random_name,
@@ -97,7 +103,10 @@ const fn default_auto_gain_control() -> bool {
 
 impl Default for Config {
     fn default() -> Self {
-        yaml_serde::from_str(DEFAULT_CONFIG).expect("Failed to parse default config")
+        let mut config: Self = yaml_serde::from_str(DEFAULT_CONFIG).expect("Failed to parse default config");
+        config.device_farm.project_arn = DEVICE_FARM_PROJECT_ARN.to_owned();
+        config.device_farm.region = DEVICE_FARM_AWS_REGION.to_owned();
+        config
     }
 }
 

From 289bbfba0aea74051db13a490f81983c64436759 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 16:22:17 +0200
Subject: [PATCH 34/42] cloudflare-browser-simulator is now a git submodule

---
 .../release-hyper-browser-simulator/SKILL.md  |   26 +-
 .github/workflows/ci.yml                      |   20 +
 .github/workflows/release.yml                 |    5 +
 .gitmodules                                   |    3 +
 README.md                                     |   22 +
 cloudflare-browser-simulator                  |    1 +
 cloudflare-worker-client/build.rs             |   12 +-
 .../openapi/cloudflare-browser-simulator.json | 1420 -----------------
 justfile                                      |    1 +
 9 files changed, 85 insertions(+), 1425 deletions(-)
 create mode 100644 .gitmodules
 create mode 160000 cloudflare-browser-simulator
 delete mode 100644 cloudflare-worker-client/openapi/cloudflare-browser-simulator.json

diff --git a/.codex/skills/release-hyper-browser-simulator/SKILL.md b/.codex/skills/release-hyper-browser-simulator/SKILL.md
index 573838e..9d662a3 100644
--- a/.codex/skills/release-hyper-browser-simulator/SKILL.md
+++ b/.codex/skills/release-hyper-browser-simulator/SKILL.md
@@ -18,6 +18,7 @@ Use this skill to prepare, publish, or verify releases of the Rust workspace in
 - Generated release workflow: `.github/workflows/release.yml`.
 - Local release helpers: `justfile`.
 - User install docs: `README.md`.
+- Cloudflare worker API schema: `cloudflare-browser-simulator` git submodule, using `cli/openapi/cloudflare-browser-simulator.json`.
 
 Before making changes, check `git status --short --branch` and work with any existing dirty files without reverting unrelated user edits.
 
@@ -30,8 +31,16 @@ Homebrew:
 - Release artifacts are hosted on GitHub.
 - Formulae are pushed to `hypervideo/homebrew-tap`.
 - CI needs the `HOMEBREW_TAP_TOKEN` secret on `hypervideo/browser-simulator`.
+- CI and release checkouts need the `CLOUDFLARE_BROWSER_SIMULATOR_READ_TOKEN` secret on `hypervideo/browser-simulator`; it must be a read-only token that can fetch this public repo and the private `hypervideo/cloudflare-browser-simulator` submodule.
 - Prerelease tags do not publish to Homebrew unless `publish-prereleases` is enabled.
 
+Cloudflare worker submodule:
+
+- The worker deploys from its own repository. Do not deploy the worker from this repo's release flow.
+- The simulator release source must pin a worker submodule commit that is reachable from GitHub, not only from a local sibling checkout.
+- If the submodule pointer references a worker commit that is not pushed yet, push that worker commit first. Use a non-`main` branch if deployment should not happen; the worker repo deploy workflow deploys from `main`.
+- To consume a newer worker API, update and commit the worker repo's generated `cli/openapi/cloudflare-browser-simulator.json`, then update the submodule pointer here and make any Rust client compatibility fixes.
+
 Nix:
 
 - `flake.nix` exposes `.#hyper-client-simulator`, `.#client-simulator`, and `.#default`.
@@ -48,6 +57,8 @@ Nix:
 git fetch --tags origin
 git tag --sort=-v:refname | head
 gh release list --repo hypervideo/browser-simulator --limit 10
+git submodule update --init --recursive
+git submodule status --recursive
 ```
 
 2. Choose the next SemVer version, using a `v` prefix only for the git tag.
@@ -58,7 +69,18 @@ gh release list --repo hypervideo/browser-simulator --limit 10
 - `nix/packages.nix`: `version = "X.Y.Z";`.
 - `Cargo.lock`: refresh local package versions after the `Cargo.toml` bump.
 
-4. Validate before tagging:
+4. Confirm submodule release readiness:
+
+```sh
+git -C cloudflare-browser-simulator status --short --branch
+git -C cloudflare-browser-simulator rev-parse HEAD
+git -C cloudflare-browser-simulator fetch origin --tags
+git -C cloudflare-browser-simulator branch -r --contains HEAD
+```
+
+The submodule should be clean and its commit must be contained by an `origin/*` ref before tagging. If no remote branch or tag is printed, push the worker commit first.
+
+5. Validate before tagging:
 
 ```sh
 just fmt
@@ -96,6 +118,8 @@ gh run list --repo hypervideo/browser-simulator --workflow Release --limit 10
 gh release view vX.Y.Z --repo hypervideo/browser-simulator
 ```
 
+If release checkout fails while fetching `cloudflare-browser-simulator`, confirm `CLOUDFLARE_BROWSER_SIMULATOR_READ_TOKEN` exists and can read the private worker repo, and confirm the pinned submodule commit has been pushed.
+
 Check the Homebrew tap formula:
 
 ```sh
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 582cc52..c806491 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -6,6 +6,9 @@ on:
   pull_request:
     branches: ['**']
 
+permissions:
+  contents: read
+
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
@@ -41,14 +44,31 @@ jobs:
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
 
+  private-submodule-notice:
+    name: Private Submodule Notice
+    runs-on: ubuntu-latest
+    timeout-minutes: 1
+    if: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository }}
+
+    steps:
+      - name: Explain limited fork CI
+        run: |
+          echo "Full lint/test CI is skipped for fork pull requests because this public repository depends on the private hypervideo/cloudflare-browser-simulator submodule."
+          echo "Run the full workflow from a trusted branch after review."
+
   lint-and-test:
     name: Lint and Test
     runs-on: ubuntu-latest
     timeout-minutes: 10
+    if: ${{ github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository }}
 
     steps:
       - name: Checkout repository
         uses: actions/checkout@v6.0.2
+        with:
+          persist-credentials: false
+          submodules: recursive
+          token: ${{ secrets.CLOUDFLARE_BROWSER_SIMULATOR_READ_TOKEN }}
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 32e7d76..67b2858 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -60,6 +60,7 @@ jobs:
         with:
           persist-credentials: false
           submodules: recursive
+          token: ${{ secrets.CLOUDFLARE_BROWSER_SIMULATOR_READ_TOKEN }}
       - name: Install dist
         # we specify bash to get pipefail; it guards against the `curl` command
         # failing. otherwise `sh` won't catch that `curl` returned non-0
@@ -120,6 +121,7 @@ jobs:
         with:
           persist-credentials: false
           submodules: recursive
+          token: ${{ secrets.CLOUDFLARE_BROWSER_SIMULATOR_READ_TOKEN }}
       - name: Install Rust non-interactively if not already installed
         if: ${{ matrix.container }}
         run: |
@@ -179,6 +181,7 @@ jobs:
         with:
           persist-credentials: false
           submodules: recursive
+          token: ${{ secrets.CLOUDFLARE_BROWSER_SIMULATOR_READ_TOKEN }}
       - name: Install cached dist
         uses: actions/download-artifact@v7
         with:
@@ -229,6 +232,7 @@ jobs:
         with:
           persist-credentials: false
           submodules: recursive
+          token: ${{ secrets.CLOUDFLARE_BROWSER_SIMULATOR_READ_TOKEN }}
       - name: Install cached dist
         uses: actions/download-artifact@v7
         with:
@@ -341,3 +345,4 @@ jobs:
         with:
           persist-credentials: false
           submodules: recursive
+          token: ${{ secrets.CLOUDFLARE_BROWSER_SIMULATOR_READ_TOKEN }}
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..d7a723c
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "cloudflare-browser-simulator"]
+	path = cloudflare-browser-simulator
+	url = https://github.com/hypervideo/cloudflare-browser-simulator.git
diff --git a/README.md b/README.md
index 36b50ee..a434884 100644
--- a/README.md
+++ b/README.md
@@ -23,3 +23,25 @@ brew upgrade hyper-client-simulator
 
 The Homebrew package installs the simulator binary only. Chrome or Chromium must
 still be installed locally on the Mac where you run it.
+
+## Development
+
+This repository uses `hypervideo/cloudflare-browser-simulator` as a Git submodule
+for the Cloudflare worker OpenAPI schema used by `cloudflare-worker-client`.
+Clone with submodules, or initialize them after cloning:
+
+```sh
+git clone --recurse-submodules git@github.com:hypervideo/browser-simulator.git
+git submodule update --init --recursive
+```
+
+To consume a newer worker API, first update and commit the generated OpenAPI
+artifact in `hypervideo/cloudflare-browser-simulator`, then update this
+repository's submodule pointer and make any matching Rust client changes. Worker
+deployment remains owned by the Cloudflare worker repository.
+
+GitHub Actions needs the repository secret
+`CLOUDFLARE_BROWSER_SIMULATOR_READ_TOKEN` set to a read-only token that can
+fetch both this repository and the private worker submodule. Full lint/test CI is
+skipped for untrusted fork pull requests because that secret is not exposed
+there.
diff --git a/cloudflare-browser-simulator b/cloudflare-browser-simulator
new file mode 160000
index 0000000..888c36a
--- /dev/null
+++ b/cloudflare-browser-simulator
@@ -0,0 +1 @@
+Subproject commit 888c36acb64277f78b116ede29e7ce005dea9573
diff --git a/cloudflare-worker-client/build.rs b/cloudflare-worker-client/build.rs
index 186ca9f..905b138 100644
--- a/cloudflare-worker-client/build.rs
+++ b/cloudflare-worker-client/build.rs
@@ -6,13 +6,17 @@ use std::{
 
 fn main() {
     let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("missing CARGO_MANIFEST_DIR"));
-    let spec_path = manifest_dir.join("openapi/cloudflare-browser-simulator.json");
+    let spec_path = manifest_dir.join("../cloudflare-browser-simulator/cli/openapi/cloudflare-browser-simulator.json");
 
     println!("cargo:rerun-if-changed={}", spec_path.display());
 
-    let spec =
-        serde_json::from_slice::<openapiv3::OpenAPI>(&fs::read(&spec_path).expect("failed to read OpenAPI spec"))
-            .expect("failed to parse OpenAPI spec");
+    let spec_bytes = fs::read(&spec_path).unwrap_or_else(|error| {
+        panic!(
+            "failed to read OpenAPI spec at {}: {error}. Initialize the cloudflare-browser-simulator submodule with `git submodule update --init --recursive`.",
+            spec_path.display()
+        )
+    });
+    let spec = serde_json::from_slice::<openapiv3::OpenAPI>(&spec_bytes).expect("failed to parse OpenAPI spec");
 
     let mut generator = progenitor::Generator::default();
     let tokens = generator
diff --git a/cloudflare-worker-client/openapi/cloudflare-browser-simulator.json b/cloudflare-worker-client/openapi/cloudflare-browser-simulator.json
deleted file mode 100644
index f1875a1..0000000
--- a/cloudflare-worker-client/openapi/cloudflare-browser-simulator.json
+++ /dev/null
@@ -1,1420 +0,0 @@
-{
-  "openapi": "3.0.3",
-  "info": {
-    "title": "cloudflare-browser-simulator",
-    "version": "0.4.1",
-    "description": "Cloudflare Worker that launches Browser Rendering sessions, joins Hyper rooms, and exposes its API contract from code."
-  },
-  "components": {
-    "schemas": {
-      "HealthzResponse": {
-        "type": "object",
-        "properties": {
-          "ok": {
-            "type": "boolean",
-            "enum": [
-              true
-            ]
-          }
-        },
-        "required": [
-          "ok"
-        ]
-      },
-      "SessionsResponse": {
-        "type": "object",
-        "properties": {
-          "ok": {
-            "type": "boolean",
-            "enum": [
-              true
-            ]
-          },
-          "summary": {
-            "$ref": "#/components/schemas/SessionSummary"
-          },
-          "sessions": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/Session"
-            }
-          }
-        },
-        "required": [
-          "ok",
-          "summary",
-          "sessions"
-        ]
-      },
-      "SessionSummary": {
-        "type": "object",
-        "properties": {
-          "openSessions": {
-            "type": "number"
-          },
-          "connectedSessions": {
-            "type": "number"
-          },
-          "idleSessions": {
-            "type": "number"
-          },
-          "activeSessions": {
-            "type": "number"
-          },
-          "maxConcurrentSessions": {
-            "type": "number"
-          },
-          "allowedBrowserAcquisitions": {
-            "type": "number"
-          },
-          "timeUntilNextAllowedBrowserAcquisition": {
-            "type": "number"
-          }
-        },
-        "required": [
-          "openSessions",
-          "connectedSessions",
-          "idleSessions",
-          "activeSessions",
-          "maxConcurrentSessions",
-          "allowedBrowserAcquisitions",
-          "timeUntilNextAllowedBrowserAcquisition"
-        ]
-      },
-      "Session": {
-        "type": "object",
-        "properties": {
-          "sessionId": {
-            "type": "string"
-          },
-          "startTime": {
-            "type": "number"
-          },
-          "connectionId": {
-            "type": "string"
-          },
-          "connectionStartTime": {
-            "type": "number"
-          },
-          "isActive": {
-            "type": "boolean"
-          }
-        },
-        "required": [
-          "sessionId",
-          "startTime",
-          "isActive"
-        ]
-      },
-      "LimitsResponse": {
-        "type": "object",
-        "properties": {
-          "ok": {
-            "type": "boolean",
-            "enum": [
-              true
-            ]
-          },
-          "limits": {
-            "$ref": "#/components/schemas/Limits"
-          },
-          "docs": {
-            "$ref": "#/components/schemas/LimitsDocs"
-          }
-        },
-        "required": [
-          "ok",
-          "limits",
-          "docs"
-        ]
-      },
-      "Limits": {
-        "type": "object",
-        "properties": {
-          "activeSessions": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/ActiveSessionRef"
-            }
-          },
-          "maxConcurrentSessions": {
-            "type": "number"
-          },
-          "allowedBrowserAcquisitions": {
-            "type": "number"
-          },
-          "timeUntilNextAllowedBrowserAcquisition": {
-            "type": "number"
-          }
-        },
-        "required": [
-          "activeSessions",
-          "maxConcurrentSessions",
-          "allowedBrowserAcquisitions",
-          "timeUntilNextAllowedBrowserAcquisition"
-        ]
-      },
-      "ActiveSessionRef": {
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "id"
-        ]
-      },
-      "LimitsDocs": {
-        "type": "object",
-        "properties": {
-          "activeSessions": {
-            "type": "string"
-          },
-          "maxConcurrentSessions": {
-            "type": "string"
-          },
-          "allowedBrowserAcquisitions": {
-            "type": "string"
-          },
-          "timeUntilNextAllowedBrowserAcquisition": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "activeSessions",
-          "maxConcurrentSessions",
-          "allowedBrowserAcquisitions",
-          "timeUntilNextAllowedBrowserAcquisition"
-        ]
-      },
-      "SessionCreateResponse": {
-        "type": "object",
-        "properties": {
-          "ok": {
-            "type": "boolean",
-            "enum": [
-              true
-            ]
-          },
-          "sessionId": {
-            "type": "string"
-          },
-          "state": {
-            "$ref": "#/components/schemas/ParticipantState"
-          },
-          "log": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/AutomationLogEntry"
-            }
-          }
-        },
-        "required": [
-          "ok",
-          "sessionId",
-          "state",
-          "log"
-        ]
-      },
-      "ParticipantState": {
-        "type": "object",
-        "properties": {
-          "running": {
-            "type": "boolean"
-          },
-          "joined": {
-            "type": "boolean"
-          },
-          "muted": {
-            "type": "boolean"
-          },
-          "videoActivated": {
-            "type": "boolean"
-          },
-          "screenshareActivated": {
-            "type": "boolean"
-          },
-          "autoGainControl": {
-            "type": "boolean"
-          },
-          "noiseSuppression": {
-            "type": "string",
-            "enum": [
-              "none",
-              "deepfilternet",
-              "rnnoise",
-              "iris-carthy",
-              "krisp-high",
-              "krisp-medium",
-              "krisp-low",
-              "krisp-high-with-bvc",
-              "krisp-medium-with-bvc",
-              "ai-coustics-sparrow-xxs",
-              "ai-coustics-sparrow-xs",
-              "ai-coustics-sparrow-s",
-              "ai-coustics-sparrow-l",
-              "ai-coustics-sparrow-xxs-48khz",
-              "ai-coustics-sparrow-xs-48khz",
-              "ai-coustics-rook-s-48khz",
-              "ai-coustics-rook-l-48khz"
-            ]
-          },
-          "transportMode": {
-            "type": "string",
-            "enum": [
-              "webrtc",
-              "webtransport"
-            ]
-          },
-          "videoConstraintPublishWebcam": {
-            "type": "string",
-            "enum": [
-              "none",
-              "90p",
-              "144p",
-              "240p",
-              "360p",
-              "480p",
-              "720p",
-              "1080p",
-              "1440p",
-              "2160p"
-            ]
-          },
-          "videoConstraintSubscribe": {
-            "type": "string",
-            "enum": [
-              "none",
-              "90p",
-              "144p",
-              "240p",
-              "360p",
-              "480p",
-              "720p",
-              "1080p",
-              "1440p",
-              "2160p"
-            ]
-          },
-          "videoMaxConcurrentTracks": {
-            "type": "integer",
-            "nullable": true,
-            "minimum": 0
-          },
-          "backgroundBlur": {
-            "type": "boolean"
-          }
-        },
-        "required": [
-          "running",
-          "joined",
-          "muted",
-          "videoActivated",
-          "screenshareActivated",
-          "autoGainControl",
-          "noiseSuppression",
-          "transportMode",
-          "videoConstraintPublishWebcam",
-          "videoConstraintSubscribe",
-          "videoMaxConcurrentTracks",
-          "backgroundBlur"
-        ]
-      },
-      "AutomationLogEntry": {
-        "type": "object",
-        "properties": {
-          "at": {
-            "type": "string",
-            "format": "date-time"
-          },
-          "step": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "at",
-          "step"
-        ]
-      },
-      "ApiErrorResponse": {
-        "type": "object",
-        "properties": {
-          "success": {
-            "type": "boolean",
-            "enum": [
-              false
-            ]
-          },
-          "errors": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/ValidationErrorItem"
-            }
-          },
-          "ok": {
-            "type": "boolean",
-            "enum": [
-              false
-            ]
-          },
-          "sessionId": {
-            "type": "string"
-          },
-          "error": {
-            "type": "string"
-          },
-          "log": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/AutomationLogEntry"
-            }
-          },
-          "screenshot": {
-            "$ref": "#/components/schemas/Screenshot"
-          }
-        }
-      },
-      "ValidationErrorItem": {
-        "type": "object",
-        "properties": {
-          "code": {
-            "type": "number"
-          },
-          "message": {
-            "type": "string"
-          },
-          "path": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          }
-        },
-        "required": [
-          "code",
-          "message",
-          "path"
-        ]
-      },
-      "Screenshot": {
-        "type": "object",
-        "properties": {
-          "mimeType": {
-            "type": "string"
-          },
-          "base64": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "mimeType",
-          "base64"
-        ]
-      },
-      "SessionCreateRequest": {
-        "type": "object",
-        "properties": {
-          "roomUrl": {
-            "type": "string",
-            "format": "uri",
-            "description": "Hyper room URL to join."
-          },
-          "displayName": {
-            "type": "string",
-            "minLength": 1,
-            "description": "Display name shown in the room."
-          },
-          "frontendKind": {
-            "type": "string",
-            "enum": [
-              "hyper-core",
-              "hyper-lite"
-            ]
-          },
-          "hyperSessionCookie": {
-            "type": "string",
-            "minLength": 1,
-            "description": "Optional Hyper Core `hyper_session` cookie value to inject before navigation."
-          },
-          "settings": {
-            "$ref": "#/components/schemas/ParticipantSettings"
-          },
-          "sessionTimeoutMs": {
-            "type": "number",
-            "description": "Desired Browser Rendering inactivity timeout (`keep_alive`) in milliseconds."
-          },
-          "navigationTimeoutMs": {
-            "type": "number",
-            "description": "Navigation timeout in milliseconds."
-          },
-          "selectorTimeoutMs": {
-            "type": "number",
-            "description": "Selector timeout in milliseconds."
-          },
-          "debug": {
-            "type": "boolean",
-            "description": "Include a debug screenshot in 500 responses."
-          }
-        },
-        "required": [
-          "roomUrl",
-          "displayName",
-          "frontendKind",
-          "settings"
-        ]
-      },
-      "ParticipantSettings": {
-        "type": "object",
-        "properties": {
-          "audioEnabled": {
-            "type": "boolean",
-            "description": "Whether the participant should join with audio enabled."
-          },
-          "videoEnabled": {
-            "type": "boolean",
-            "description": "Whether the participant should join with video enabled."
-          },
-          "screenshareEnabled": {
-            "type": "boolean",
-            "description": "Whether the participant should start screensharing after join."
-          },
-          "autoGainControl": {
-            "type": "boolean",
-            "description": "Whether Hyper should automatically adjust microphone volume."
-          },
-          "noiseSuppression": {
-            "type": "string",
-            "enum": [
-              "none",
-              "deepfilternet",
-              "rnnoise",
-              "iris-carthy",
-              "krisp-high",
-              "krisp-medium",
-              "krisp-low",
-              "krisp-high-with-bvc",
-              "krisp-medium-with-bvc",
-              "ai-coustics-sparrow-xxs",
-              "ai-coustics-sparrow-xs",
-              "ai-coustics-sparrow-s",
-              "ai-coustics-sparrow-l",
-              "ai-coustics-sparrow-xxs-48khz",
-              "ai-coustics-sparrow-xs-48khz",
-              "ai-coustics-rook-s-48khz",
-              "ai-coustics-rook-l-48khz"
-            ]
-          },
-          "transport": {
-            "type": "string",
-            "enum": [
-              "webrtc",
-              "webtransport"
-            ]
-          },
-          "videoConstraintPublishWebcam": {
-            "type": "string",
-            "enum": [
-              "none",
-              "90p",
-              "144p",
-              "240p",
-              "360p",
-              "480p",
-              "720p",
-              "1080p",
-              "1440p",
-              "2160p"
-            ]
-          },
-          "videoConstraintSubscribe": {
-            "type": "string",
-            "enum": [
-              "none",
-              "90p",
-              "144p",
-              "240p",
-              "360p",
-              "480p",
-              "720p",
-              "1080p",
-              "1440p",
-              "2160p"
-            ]
-          },
-          "videoMaxConcurrentTracks": {
-            "type": "integer",
-            "nullable": true,
-            "minimum": 0
-          },
-          "blur": {
-            "type": "boolean",
-            "description": "Whether background blur should be enabled."
-          }
-        },
-        "required": [
-          "audioEnabled",
-          "videoEnabled",
-          "screenshareEnabled",
-          "autoGainControl",
-          "noiseSuppression",
-          "transport",
-          "videoConstraintPublishWebcam",
-          "videoConstraintSubscribe",
-          "videoMaxConcurrentTracks",
-          "blur"
-        ]
-      },
-      "SessionBatchCloseResponse": {
-        "type": "object",
-        "properties": {
-          "ok": {
-            "type": "boolean",
-            "enum": [
-              true
-            ]
-          },
-          "results": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/SessionBatchCloseResult"
-            }
-          },
-          "summary": {
-            "$ref": "#/components/schemas/SessionBatchCloseSummary"
-          }
-        },
-        "required": [
-          "ok",
-          "results",
-          "summary"
-        ]
-      },
-      "SessionBatchCloseResult": {
-        "type": "object",
-        "properties": {
-          "ok": {
-            "type": "boolean"
-          },
-          "sessionId": {
-            "type": "string"
-          },
-          "error": {
-            "type": "string"
-          },
-          "log": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/AutomationLogEntry"
-            }
-          }
-        },
-        "required": [
-          "ok",
-          "sessionId",
-          "log"
-        ]
-      },
-      "SessionBatchCloseSummary": {
-        "type": "object",
-        "properties": {
-          "requestedSessions": {
-            "type": "number"
-          },
-          "closedSessions": {
-            "type": "number"
-          },
-          "failedSessions": {
-            "type": "number"
-          }
-        },
-        "required": [
-          "requestedSessions",
-          "closedSessions",
-          "failedSessions"
-        ]
-      },
-      "SessionBatchCloseRequest": {
-        "type": "object",
-        "properties": {
-          "sessionIds": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "minLength": 1,
-              "description": "Cloudflare Browser Rendering session ID."
-            },
-            "minItems": 1,
-            "description": "Browser Rendering session IDs to close in a single request."
-          }
-        },
-        "required": [
-          "sessionIds"
-        ]
-      },
-      "SessionCommandResponse": {
-        "type": "object",
-        "properties": {
-          "ok": {
-            "type": "boolean",
-            "enum": [
-              true
-            ]
-          },
-          "sessionId": {
-            "type": "string"
-          },
-          "state": {
-            "$ref": "#/components/schemas/ParticipantState"
-          },
-          "log": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/AutomationLogEntry"
-            }
-          }
-        },
-        "required": [
-          "ok",
-          "sessionId",
-          "state",
-          "log"
-        ]
-      },
-      "SessionCommandRequest": {
-        "oneOf": [
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "join"
-                ]
-              }
-            },
-            "required": [
-              "type"
-            ]
-          },
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "leave"
-                ]
-              }
-            },
-            "required": [
-              "type"
-            ]
-          },
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "toggle-audio"
-                ]
-              }
-            },
-            "required": [
-              "type"
-            ]
-          },
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "toggle-video"
-                ]
-              }
-            },
-            "required": [
-              "type"
-            ]
-          },
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "toggle-screenshare"
-                ]
-              }
-            },
-            "required": [
-              "type"
-            ]
-          },
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "toggle-auto-gain-control"
-                ]
-              }
-            },
-            "required": [
-              "type"
-            ]
-          },
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "set-noise-suppression"
-                ]
-              },
-              "noiseSuppression": {
-                "type": "string",
-                "enum": [
-                  "none",
-                  "deepfilternet",
-                  "rnnoise",
-                  "iris-carthy",
-                  "krisp-high",
-                  "krisp-medium",
-                  "krisp-low",
-                  "krisp-high-with-bvc",
-                  "krisp-medium-with-bvc",
-                  "ai-coustics-sparrow-xxs",
-                  "ai-coustics-sparrow-xs",
-                  "ai-coustics-sparrow-s",
-                  "ai-coustics-sparrow-l",
-                  "ai-coustics-sparrow-xxs-48khz",
-                  "ai-coustics-sparrow-xs-48khz",
-                  "ai-coustics-rook-s-48khz",
-                  "ai-coustics-rook-l-48khz"
-                ]
-              }
-            },
-            "required": [
-              "type",
-              "noiseSuppression"
-            ]
-          },
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "set-video-constraint-publish-webcam"
-                ]
-              },
-              "videoConstraintPublishWebcam": {
-                "type": "string",
-                "enum": [
-                  "none",
-                  "90p",
-                  "144p",
-                  "240p",
-                  "360p",
-                  "480p",
-                  "720p",
-                  "1080p",
-                  "1440p",
-                  "2160p"
-                ]
-              }
-            },
-            "required": [
-              "type",
-              "videoConstraintPublishWebcam"
-            ]
-          },
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "set-video-constraint-subscribe"
-                ]
-              },
-              "videoConstraintSubscribe": {
-                "type": "string",
-                "enum": [
-                  "none",
-                  "90p",
-                  "144p",
-                  "240p",
-                  "360p",
-                  "480p",
-                  "720p",
-                  "1080p",
-                  "1440p",
-                  "2160p"
-                ]
-              }
-            },
-            "required": [
-              "type",
-              "videoConstraintSubscribe"
-            ]
-          },
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "set-video-max-concurrent-tracks"
-                ]
-              },
-              "videoMaxConcurrentTracks": {
-                "type": "integer",
-                "nullable": true,
-                "minimum": 0
-              }
-            },
-            "required": [
-              "type",
-              "videoMaxConcurrentTracks"
-            ]
-          },
-          {
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": [
-                  "toggle-background-blur"
-                ]
-              }
-            },
-            "required": [
-              "type"
-            ]
-          }
-        ]
-      },
-      "SessionStateResponse": {
-        "type": "object",
-        "properties": {
-          "ok": {
-            "type": "boolean",
-            "enum": [
-              true
-            ]
-          },
-          "sessionId": {
-            "type": "string"
-          },
-          "state": {
-            "$ref": "#/components/schemas/ParticipantState"
-          },
-          "log": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/AutomationLogEntry"
-            }
-          }
-        },
-        "required": [
-          "ok",
-          "sessionId",
-          "state"
-        ]
-      },
-      "SessionKeepAliveResponse": {
-        "type": "object",
-        "properties": {
-          "ok": {
-            "type": "boolean",
-            "enum": [
-              true
-            ]
-          },
-          "sessionId": {
-            "type": "string"
-          },
-          "state": {
-            "$ref": "#/components/schemas/ParticipantState"
-          },
-          "log": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/AutomationLogEntry"
-            }
-          }
-        },
-        "required": [
-          "ok",
-          "sessionId",
-          "state",
-          "log"
-        ]
-      },
-      "SessionCloseResponse": {
-        "type": "object",
-        "properties": {
-          "ok": {
-            "type": "boolean",
-            "enum": [
-              true
-            ]
-          },
-          "sessionId": {
-            "type": "string"
-          },
-          "log": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/AutomationLogEntry"
-            }
-          }
-        },
-        "required": [
-          "ok",
-          "sessionId",
-          "log"
-        ]
-      }
-    },
-    "parameters": {}
-  },
-  "paths": {
-    "": {
-      "get": {
-        "operationId": "redirectToDocs",
-        "tags": [
-          "meta"
-        ],
-        "summary": "Redirect to the interactive API docs",
-        "responses": {
-          "302": {
-            "description": "Redirects to /docs."
-          }
-        }
-      }
-    },
-    "/healthz": {
-      "get": {
-        "operationId": "getHealthz",
-        "tags": [
-          "meta"
-        ],
-        "summary": "Check worker health",
-        "responses": {
-          "200": {
-            "description": "Simple worker health response.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/HealthzResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/sessions": {
-      "get": {
-        "operationId": "listSessions",
-        "tags": [
-          "sessions"
-        ],
-        "summary": "List active browser rendering sessions",
-        "responses": {
-          "200": {
-            "description": "Active Cloudflare Browser Rendering sessions and a summarized count.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionsResponse"
-                }
-              }
-            }
-          }
-        }
-      },
-      "post": {
-        "operationId": "createSession",
-        "tags": [
-          "sessions"
-        ],
-        "summary": "Create a participant browser session",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/SessionCreateRequest"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Participant session created.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionCreateResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "Input validation failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          },
-          "500": {
-            "description": "Session creation failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          },
-          "501": {
-            "description": "Requested create-session behavior is not implemented yet.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/limits": {
-      "get": {
-        "operationId": "getLimits",
-        "tags": [
-          "sessions"
-        ],
-        "summary": "Show browser rendering capacity and rate limits",
-        "responses": {
-          "200": {
-            "description": "Current browser rendering limits and field-level notes.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/LimitsResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/sessions/close": {
-      "post": {
-        "operationId": "closeSessions",
-        "tags": [
-          "sessions"
-        ],
-        "summary": "Close multiple participant browser sessions",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/SessionBatchCloseRequest"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Participant sessions closed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionBatchCloseResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "Input validation failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          },
-          "500": {
-            "description": "Participant session close handler failed before processing results.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/sessions/{sessionId}/commands": {
-      "post": {
-        "operationId": "commandSession",
-        "tags": [
-          "sessions"
-        ],
-        "summary": "Apply a runtime participant command",
-        "parameters": [
-          {
-            "schema": {
-              "type": "string",
-              "minLength": 1,
-              "description": "Cloudflare Browser Rendering session ID."
-            },
-            "required": true,
-            "description": "Cloudflare Browser Rendering session ID.",
-            "name": "sessionId",
-            "in": "path"
-          }
-        ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/SessionCommandRequest"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Participant command applied.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionCommandResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "Input validation failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          },
-          "500": {
-            "description": "Participant command failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          },
-          "501": {
-            "description": "Participant commands are not implemented yet.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/sessions/{sessionId}/state": {
-      "get": {
-        "operationId": "getSessionState",
-        "tags": [
-          "sessions"
-        ],
-        "summary": "Fetch the latest participant state",
-        "parameters": [
-          {
-            "schema": {
-              "type": "string",
-              "minLength": 1,
-              "description": "Cloudflare Browser Rendering session ID."
-            },
-            "required": true,
-            "description": "Cloudflare Browser Rendering session ID.",
-            "name": "sessionId",
-            "in": "path"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Participant state fetched.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionStateResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "Input validation failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          },
-          "500": {
-            "description": "Participant state lookup failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          },
-          "501": {
-            "description": "Participant state scraping is not implemented yet.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/sessions/{sessionId}/keep-alive": {
-      "post": {
-        "operationId": "keepAliveSession",
-        "tags": [
-          "sessions"
-        ],
-        "summary": "Send a keep-alive command to a participant browser session",
-        "parameters": [
-          {
-            "schema": {
-              "type": "string",
-              "minLength": 1,
-              "description": "Cloudflare Browser Rendering session ID."
-            },
-            "required": true,
-            "description": "Cloudflare Browser Rendering session ID.",
-            "name": "sessionId",
-            "in": "path"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Keep-alive command sent and participant state refreshed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionKeepAliveResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "Input validation failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          },
-          "500": {
-            "description": "Keep-alive failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/sessions/{sessionId}/close": {
-      "post": {
-        "operationId": "closeSession",
-        "tags": [
-          "sessions"
-        ],
-        "summary": "Close a participant browser session",
-        "parameters": [
-          {
-            "schema": {
-              "type": "string",
-              "minLength": 1,
-              "description": "Cloudflare Browser Rendering session ID."
-            },
-            "required": true,
-            "description": "Cloudflare Browser Rendering session ID.",
-            "name": "sessionId",
-            "in": "path"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Participant session closed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionCloseResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "Input validation failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          },
-          "500": {
-            "description": "Participant session close failed.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ApiErrorResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/justfile b/justfile
index 7e34538..7e636c1 100644
--- a/justfile
+++ b/justfile
@@ -2,6 +2,7 @@ default:
     just --list
 
 setup:
+    git submodule update --init --recursive
     cat .env.tpl | op inject > .env
 
 # -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

From a6ea830f544b2f493e02390a9cc857b977f34584 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 16:27:16 +0200
Subject: [PATCH 35/42] aws subcommand

---
 Cargo.lock                                    |   1 +
 Cargo.toml                                    |   1 +
 .../src/participant/device_farm/control.rs    | 210 +++++++
 browser/src/participant/device_farm/mod.rs    |  64 +-
 .../src/participant/device_farm/test_grid.rs  |  70 ++-
 browser/tests/device_farm_driver.rs           |  39 ++
 src/aws.rs                                    | 554 ++++++++++++++++++
 src/main.rs                                   | 108 ++++
 8 files changed, 996 insertions(+), 51 deletions(-)
 create mode 100644 browser/src/participant/device_farm/control.rs
 create mode 100644 src/aws.rs

diff --git a/Cargo.lock b/Cargo.lock
index 0dc2fbe..3787b25 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1933,6 +1933,7 @@ name = "hyper-client-simulator"
 version = "0.3.4"
 dependencies = [
  "better-panic",
+ "chrono",
  "clap",
  "client-simulator-browser",
  "client-simulator-config",
diff --git a/Cargo.toml b/Cargo.toml
index 8b492af..6f01401 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -87,6 +87,7 @@ repository.workspace = true
 
 [dependencies]
 better-panic.workspace = true
+chrono.workspace = true
 clap.workspace = true
 client-simulator-browser.workspace = true
 client-simulator-config.workspace = true
diff --git a/browser/src/participant/device_farm/control.rs b/browser/src/participant/device_farm/control.rs
new file mode 100644
index 0000000..52fb20f
--- /dev/null
+++ b/browser/src/participant/device_farm/control.rs
@@ -0,0 +1,210 @@
+use super::test_grid::TestGridApi;
+use aws_sdk_devicefarm::{
+    primitives::DateTime,
+    types::{
+        TestGridSession,
+        TestGridSessionStatus,
+    },
+};
+use eyre::{
+    bail,
+    Context as _,
+    Result,
+};
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
+pub struct DeviceFarmSessionInfo {
+    pub arn: String,
+    pub session_id: String,
+    pub status: String,
+    pub created: Option<String>,
+    pub ended: Option<String>,
+    pub age_seconds: Option<i64>,
+    pub billing_minutes: Option<f64>,
+    pub selenium_properties: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DeviceFarmCloseResult {
+    Closed,
+    AlreadyClosed,
+}
+
+pub fn session_id_from_arn(arn: &str) -> Option<String> {
+    arn.rsplit_once('/').map(|(_, session_id)| session_id.to_string())
+}
+
+pub fn selenium_properties_json(value: Option<&str>) -> Option<serde_json::Value> {
+    value.map(|value| serde_json::from_str(value).unwrap_or_else(|_| serde_json::Value::String(value.to_string())))
+}
+
+pub async fn list_project_sessions(
+    api: &dyn TestGridApi,
+    project_arn: &str,
+    status: Option<TestGridSessionStatus>,
+) -> Result<Vec<DeviceFarmSessionInfo>> {
+    let now_epoch_seconds = chrono::Utc::now().timestamp();
+    let sessions = api.list_test_grid_sessions(project_arn, status).await?;
+    Ok(sessions
+        .into_iter()
+        .map(|session| map_test_grid_session(session, now_epoch_seconds))
+        .collect())
+}
+
+pub async fn list_active_project_sessions(
+    api: &dyn TestGridApi,
+    project_arn: &str,
+) -> Result<Vec<DeviceFarmSessionInfo>> {
+    list_project_sessions(api, project_arn, Some(TestGridSessionStatus::Active)).await
+}
+
+pub async fn close_test_grid_session(
+    api: &dyn TestGridApi,
+    project_arn: &str,
+    url_expires_seconds: u64,
+    session_id: &str,
+) -> Result<DeviceFarmCloseResult> {
+    let signed_url = api
+        .create_test_grid_url(project_arn, url_expires_seconds)
+        .await
+        .context("failed to create Device Farm Test Grid URL")?;
+    let signed_url = signed_url
+        .parse::<url::Url>()
+        .context("Device Farm returned an invalid Selenium endpoint URL")?;
+    let command_uri = format!("/session/{session_id}")
+        .parse::<http::Uri>()
+        .context("invalid WebDriver session deletion URI")?;
+    let url = signed_test_grid_command_url(&signed_url, &command_uri)?;
+
+    let response = reqwest::Client::new()
+        .delete(url)
+        .send()
+        .await
+        .context("failed to send WebDriver delete session request")?;
+    let status = response.status();
+    let body = response.text().await.unwrap_or_default();
+
+    if status == reqwest::StatusCode::OK || status == reqwest::StatusCode::NO_CONTENT {
+        return Ok(DeviceFarmCloseResult::Closed);
+    }
+
+    if webdriver_error_is_invalid_session_id(&body) {
+        return Ok(DeviceFarmCloseResult::AlreadyClosed);
+    }
+
+    if status == reqwest::StatusCode::FORBIDDEN || status == reqwest::StatusCode::METHOD_NOT_ALLOWED {
+        bail!(
+            "AWS Device Farm did not accept WebDriver session deletion for {session_id} (HTTP {status}); \
+             Test Grid has no supported per-session force-close API response: {body}"
+        );
+    }
+
+    bail!("failed to close Device Farm session {session_id} (HTTP {status}): {body}");
+}
+
+pub(crate) fn signed_test_grid_command_url(signed_url: &url::Url, command_uri: &http::Uri) -> Result<url::Url> {
+    let mut url = signed_url.clone();
+    let command_path = webdriver_command_path(signed_url, command_uri);
+    let base_path = signed_url.path().trim_end_matches('/');
+    let path = if base_path.is_empty() {
+        format!("/{command_path}")
+    } else if command_path.is_empty() {
+        base_path.to_string()
+    } else {
+        format!("{base_path}/{command_path}")
+    };
+    url.set_path(&path);
+
+    let query = match (signed_url.query(), command_uri.query()) {
+        (Some(signed), Some(command)) if !command.is_empty() => Some(format!("{signed}&{command}")),
+        (Some(signed), _) => Some(signed.to_string()),
+        (None, Some(command)) if !command.is_empty() => Some(command.to_string()),
+        _ => None,
+    };
+    url.set_query(query.as_deref());
+
+    Ok(url)
+}
+
+fn map_test_grid_session(session: TestGridSession, now_epoch_seconds: i64) -> DeviceFarmSessionInfo {
+    let arn = session.arn().unwrap_or_default().to_string();
+    let created = session.created();
+    let ended = session.ended();
+    DeviceFarmSessionInfo {
+        session_id: session_id_from_arn(&arn).unwrap_or_default(),
+        arn,
+        status: session
+            .status()
+            .map(ToString::to_string)
+            .unwrap_or_else(|| "UNKNOWN".to_string()),
+        created: created.map(ToString::to_string),
+        ended: ended.map(ToString::to_string),
+        age_seconds: age_seconds(created, ended, now_epoch_seconds),
+        billing_minutes: session.billing_minutes(),
+        selenium_properties: selenium_properties_json(session.selenium_properties()),
+    }
+}
+
+fn age_seconds(created: Option<&DateTime>, ended: Option<&DateTime>, now_epoch_seconds: i64) -> Option<i64> {
+    let created = created?;
+    let end_epoch_seconds = ended.map_or(now_epoch_seconds, DateTime::secs);
+    Some(end_epoch_seconds - created.secs())
+}
+
+fn webdriver_command_path(signed_url: &url::Url, command_uri: &http::Uri) -> String {
+    let joined_path = command_uri.path();
+    let base_path = signed_url.path().trim_end_matches('/');
+
+    if !base_path.is_empty() {
+        let base_prefix = format!("{base_path}/");
+        if let Some(command) = joined_path.strip_prefix(&base_prefix) {
+            return command.trim_start_matches('/').to_string();
+        }
+
+        if let Some((parent, _)) = base_path.rsplit_once('/') {
+            let parent_prefix = if parent.is_empty() {
+                "/".to_string()
+            } else {
+                format!("{parent}/")
+            };
+            if let Some(command) = joined_path.strip_prefix(&parent_prefix) {
+                return command.trim_start_matches('/').to_string();
+            }
+        }
+    }
+
+    joined_path.trim_start_matches('/').to_string()
+}
+
+fn webdriver_error_is_invalid_session_id(body: &str) -> bool {
+    serde_json::from_str::<serde_json::Value>(body).is_ok_and(|value| {
+        value
+            .get("value")
+            .and_then(|value| value.get("error"))
+            .and_then(serde_json::Value::as_str)
+            == Some("invalid session id")
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn extracts_session_id_from_test_grid_session_arn() {
+        let arn = "arn:aws:devicefarm:us-west-2:111122223333:testgrid-session:project-guid/session-guid";
+        assert_eq!(session_id_from_arn(arn), Some("session-guid".to_string()));
+    }
+
+    #[test]
+    fn maps_selenium_properties_to_json_when_possible() {
+        let value = selenium_properties_json(Some(r#"{"browserName":"chrome"}"#));
+        assert_eq!(value, Some(serde_json::json!({"browserName": "chrome"})));
+    }
+
+    #[test]
+    fn keeps_non_json_selenium_properties_as_string() {
+        let value = selenium_properties_json(Some("browserName=chrome"));
+        assert_eq!(value, Some(serde_json::json!("browserName=chrome")));
+    }
+}
diff --git a/browser/src/participant/device_farm/mod.rs b/browser/src/participant/device_farm/mod.rs
index 16ddf46..23f4665 100644
--- a/browser/src/participant/device_farm/mod.rs
+++ b/browser/src/participant/device_farm/mod.rs
@@ -1,3 +1,4 @@
+mod control;
 mod test_grid;
 mod webdriver_driver;
 
@@ -25,10 +26,18 @@ use crate::{
         },
     },
 };
+pub use aws_sdk_devicefarm::types::TestGridSessionStatus;
 use client_simulator_config::{
     media::FakeMedia,
     DeviceFarmConfig,
 };
+pub use control::{
+    close_test_grid_session,
+    list_active_project_sessions,
+    list_project_sessions,
+    DeviceFarmCloseResult,
+    DeviceFarmSessionInfo,
+};
 use eyre::{
     bail,
     Context as _,
@@ -44,9 +53,10 @@ use std::{
     sync::Arc,
     time::Duration,
 };
-pub(crate) use test_grid::AwsTestGrid;
-#[allow(unused_imports)]
-pub use test_grid::TestGridApi;
+pub use test_grid::{
+    AwsTestGrid,
+    TestGridApi,
+};
 use thirtyfour::{
     common::config::WebDriverConfig,
     prelude::{
@@ -404,52 +414,8 @@ fn rewrite_device_farm_request_uri<'a>(
 }
 
 fn signed_test_grid_command_url(signed_url: &url::Url, command_uri: &http::Uri) -> WebDriverResult<url::Url> {
-    let mut url = signed_url.clone();
-    let command_path = webdriver_command_path(signed_url, command_uri);
-    let base_path = signed_url.path().trim_end_matches('/');
-    let path = if base_path.is_empty() {
-        format!("/{command_path}")
-    } else if command_path.is_empty() {
-        base_path.to_string()
-    } else {
-        format!("{base_path}/{command_path}")
-    };
-    url.set_path(&path);
-
-    let query = match (signed_url.query(), command_uri.query()) {
-        (Some(signed), Some(command)) if !command.is_empty() => Some(format!("{signed}&{command}")),
-        (Some(signed), _) => Some(signed.to_string()),
-        (None, Some(command)) if !command.is_empty() => Some(command.to_string()),
-        _ => None,
-    };
-    url.set_query(query.as_deref());
-
-    Ok(url)
-}
-
-fn webdriver_command_path(signed_url: &url::Url, command_uri: &http::Uri) -> String {
-    let joined_path = command_uri.path();
-    let base_path = signed_url.path().trim_end_matches('/');
-
-    if !base_path.is_empty() {
-        let base_prefix = format!("{base_path}/");
-        if let Some(command) = joined_path.strip_prefix(&base_prefix) {
-            return command.trim_start_matches('/').to_string();
-        }
-
-        if let Some((parent, _)) = base_path.rsplit_once('/') {
-            let parent_prefix = if parent.is_empty() {
-                "/".to_string()
-            } else {
-                format!("{parent}/")
-            };
-            if let Some(command) = joined_path.strip_prefix(&parent_prefix) {
-                return command.trim_start_matches('/').to_string();
-            }
-        }
-    }
-
-    joined_path.trim_start_matches('/').to_string()
+    control::signed_test_grid_command_url(signed_url, command_uri)
+        .map_err(|err| WebDriverError::ParseError(format!("invalid Device Farm WebDriver request URI: {err}")))
 }
 
 fn aws_duration_secs(duration_ms: u64, min_secs: u64, max_secs: u64) -> u64 {
diff --git a/browser/src/participant/device_farm/test_grid.rs b/browser/src/participant/device_farm/test_grid.rs
index afc037a..7f8bab7 100644
--- a/browser/src/participant/device_farm/test_grid.rs
+++ b/browser/src/participant/device_farm/test_grid.rs
@@ -1,8 +1,13 @@
+use aws_sdk_devicefarm::types::{
+    TestGridSession,
+    TestGridSessionStatus,
+};
 use client_simulator_config::{
     DEVICE_FARM_AWS_ACCESS_KEY_ID,
     DEVICE_FARM_AWS_SECRET_ACCESS_KEY,
 };
 use eyre::{
+    bail,
     Context as _,
     Result,
 };
@@ -16,16 +21,32 @@ use futures::{
 pub trait TestGridApi: Send + Sync {
     /// Create a short-lived Selenium Remote WebDriver URL for `project_arn`.
     fn create_test_grid_url(&self, project_arn: &str, expires_seconds: u64) -> BoxFuture<'_, Result<String>>;
+
+    fn list_test_grid_sessions(
+        &self,
+        _project_arn: &str,
+        _status: Option<TestGridSessionStatus>,
+    ) -> BoxFuture<'_, Result<Vec<TestGridSession>>> {
+        async move { bail!("ListTestGridSessions is not implemented by this TestGridApi") }.boxed()
+    }
+
+    fn get_test_grid_session(
+        &self,
+        _project_arn: &str,
+        _session_id: &str,
+    ) -> BoxFuture<'_, Result<Option<TestGridSession>>> {
+        async move { bail!("GetTestGridSession is not implemented by this TestGridApi") }.boxed()
+    }
 }
 
 /// Real implementation backed by `aws-sdk-devicefarm`.
-pub(crate) struct AwsTestGrid {
+pub struct AwsTestGrid {
     region: String,
     client: tokio::sync::OnceCell<aws_sdk_devicefarm::Client>,
 }
 
 impl AwsTestGrid {
-    pub(crate) fn new(region: &str) -> Self {
+    pub fn new(region: &str) -> Self {
         Self {
             region: region.to_owned(),
             client: tokio::sync::OnceCell::new(),
@@ -75,4 +96,49 @@ impl TestGridApi for AwsTestGrid {
         }
         .boxed()
     }
+
+    fn list_test_grid_sessions(
+        &self,
+        project_arn: &str,
+        status: Option<TestGridSessionStatus>,
+    ) -> BoxFuture<'_, Result<Vec<TestGridSession>>> {
+        let project_arn = project_arn.to_owned();
+        async move {
+            let mut builder = self.client().await.list_test_grid_sessions().project_arn(project_arn);
+            if let Some(status) = status {
+                builder = builder.status(status);
+            }
+
+            let mut pages = builder.into_paginator().send();
+            let mut sessions = Vec::new();
+            while let Some(page) = pages.next().await {
+                let page = page.context("ListTestGridSessions failed")?;
+                sessions.extend(page.test_grid_sessions().iter().cloned());
+            }
+            Ok(sessions)
+        }
+        .boxed()
+    }
+
+    fn get_test_grid_session(
+        &self,
+        project_arn: &str,
+        session_id: &str,
+    ) -> BoxFuture<'_, Result<Option<TestGridSession>>> {
+        let project_arn = project_arn.to_owned();
+        let session_id = session_id.to_owned();
+        async move {
+            let output = self
+                .client()
+                .await
+                .get_test_grid_session()
+                .project_arn(project_arn)
+                .session_id(session_id)
+                .send()
+                .await
+                .context("GetTestGridSession failed")?;
+            Ok(output.test_grid_session().cloned())
+        }
+        .boxed()
+    }
 }
diff --git a/browser/tests/device_farm_driver.rs b/browser/tests/device_farm_driver.rs
index 3c731b2..5503e4a 100644
--- a/browser/tests/device_farm_driver.rs
+++ b/browser/tests/device_farm_driver.rs
@@ -7,6 +7,10 @@
 use client_simulator_browser::{
     auth::HyperSessionCookieManger,
     participant::{
+        device_farm::{
+            close_test_grid_session,
+            DeviceFarmCloseResult,
+        },
         Participant,
         ParticipantState,
     },
@@ -118,6 +122,41 @@ async fn device_farm_session_preserves_signed_test_grid_url_path_and_query() {
         .all(|request| { request.path.starts_with("/signed-grid/wd/hub/") && request.path.contains(signature) }));
 }
 
+#[tokio::test]
+async fn close_test_grid_session_preserves_signed_test_grid_url_path_and_query() {
+    let signature = "X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Signature=test-signature";
+    let (base_url, requests, server) = spawn_webdriver_mock_with_options(WebDriverMockOptions {
+        path_prefix: "/signed-grid/wd/hub".to_string(),
+        required_query: Some(signature.to_string()),
+        ..Default::default()
+    })
+    .await;
+    let api = TestGridStub {
+        url: format!("{base_url}/signed-grid/wd/hub?{signature}"),
+    };
+
+    let result = close_test_grid_session(
+        &api,
+        "arn:aws:devicefarm:us-west-2:123456789012:testgrid-project:abc",
+        300,
+        "df-1",
+    )
+    .await
+    .expect("close helper should send signed WebDriver delete");
+
+    assert_eq!(result, DeviceFarmCloseResult::Closed);
+
+    server.abort();
+
+    let requests = requests.lock().unwrap().clone();
+    assert_eq!(requests.len(), 1);
+    assert_eq!(
+        requests[0].path,
+        format!("/signed-grid/wd/hub/session/df-1?{signature}")
+    );
+    assert_eq!(requests[0].method, "DELETE");
+}
+
 #[tokio::test]
 async fn device_farm_session_polls_and_publishes_frontend_state_changes() {
     let (base_url, requests, server) = spawn_webdriver_mock_with_options(WebDriverMockOptions {
diff --git a/src/aws.rs b/src/aws.rs
new file mode 100644
index 0000000..63d8418
--- /dev/null
+++ b/src/aws.rs
@@ -0,0 +1,554 @@
+use clap::{
+    Args,
+    Subcommand,
+};
+use client_simulator_browser::participant::device_farm::{
+    self,
+    AwsTestGrid,
+    DeviceFarmCloseResult,
+    DeviceFarmSessionInfo,
+};
+use client_simulator_config::{
+    Config,
+    TuiArgs,
+};
+use eyre::{
+    bail,
+    Context as _,
+    Result,
+};
+use serde::Serialize;
+use tracing_subscriber::{
+    fmt,
+    prelude::*,
+    registry,
+    EnvFilter,
+};
+
+const DEVICE_FARM_DESKTOP_INSTANCE_MINUTE_USD: f64 = 0.005;
+
+#[derive(Args, Debug, Clone)]
+pub struct AwsArgs {
+    #[command(subcommand)]
+    pub command: AwsCommand,
+}
+
+#[derive(Subcommand, Debug, Clone)]
+pub enum AwsCommand {
+    /// List AWS Device Farm Test Grid sessions for the configured project.
+    ListSessions(ListSessionsArgs),
+    /// Force-close AWS Device Farm Test Grid sessions for the configured project.
+    CloseSessions(CloseSessionsArgs),
+}
+
+#[derive(Args, Debug, Clone)]
+pub struct ListSessionsArgs {
+    /// Print machine-readable JSON instead of a human table.
+    #[clap(long)]
+    pub json: bool,
+    /// Filter sessions by Device Farm status.
+    #[clap(long, value_enum, default_value_t = ListSessionsStatus::Active)]
+    pub status: ListSessionsStatus,
+    /// Only show sessions created at or after this local date/time or RFC3339 timestamp.
+    #[clap(long, value_name = "DATE", value_parser = parse_since_arg)]
+    pub since: Option<SinceDate>,
+}
+
+#[derive(clap::ValueEnum, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ListSessionsStatus {
+    Active,
+    Closed,
+    All,
+}
+
+impl ListSessionsStatus {
+    fn test_grid_status(self) -> Option<device_farm::TestGridSessionStatus> {
+        match self {
+            Self::Active => Some(device_farm::TestGridSessionStatus::Active),
+            Self::Closed => Some(device_farm::TestGridSessionStatus::Closed),
+            Self::All => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SinceDate {
+    epoch_seconds: i64,
+}
+
+#[derive(Args, Debug, Clone)]
+pub struct CloseSessionsArgs {
+    /// Comma-separated Device Farm session IDs. If absent, all active sessions are closed.
+    #[clap(value_name = "SESSION_IDS", value_delimiter = ',')]
+    pub session_ids: Vec<String>,
+}
+
+pub async fn run(args: AwsArgs, filter: EnvFilter) -> Result<()> {
+    init_logging(filter)?;
+
+    let config = Config::new(TuiArgs::default()).context("Failed to create config")?;
+    if config.device_farm.project_arn.trim().is_empty() {
+        bail!("device_farm.project_arn is not configured; set it in config.yaml before using `aws`");
+    }
+
+    let api = AwsTestGrid::new(&config.device_farm.region);
+    match args.command {
+        AwsCommand::ListSessions(args) => list_sessions(&api, &config.device_farm.project_arn, args).await,
+        AwsCommand::CloseSessions(args) => close_sessions(&api, &config, args).await,
+    }
+}
+
+async fn list_sessions(api: &AwsTestGrid, project_arn: &str, args: ListSessionsArgs) -> Result<()> {
+    let sessions = device_farm::list_project_sessions(api, project_arn, args.status.test_grid_status()).await?;
+    let sessions = filter_sessions_since(sessions, args.since.as_ref());
+    if args.json {
+        print!("{}", format_sessions_json(&sessions)?);
+    } else {
+        print!("{}", format_sessions_human(&sessions));
+    }
+    Ok(())
+}
+
+async fn close_sessions(api: &AwsTestGrid, config: &Config, args: CloseSessionsArgs) -> Result<()> {
+    let listed_sessions = if args.session_ids.is_empty() {
+        device_farm::list_active_project_sessions(api, &config.device_farm.project_arn).await?
+    } else {
+        Vec::new()
+    };
+    let targets = close_targets(&args.session_ids, &listed_sessions);
+
+    if targets.is_empty() {
+        println!("No active Device Farm sessions to close.");
+        return Ok(());
+    }
+
+    let mut failures = Vec::new();
+    for session_id in targets {
+        match device_farm::close_test_grid_session(
+            api,
+            &config.device_farm.project_arn,
+            config.device_farm.url_expires_seconds,
+            &session_id,
+        )
+        .await
+        {
+            Ok(DeviceFarmCloseResult::Closed) => println!("closed {session_id}"),
+            Ok(DeviceFarmCloseResult::AlreadyClosed) => println!("already closed {session_id}"),
+            Err(err) => {
+                println!("failed {session_id}: {err}");
+                failures.push(format!("{session_id}: {err}"));
+            }
+        }
+    }
+
+    if failures.is_empty() {
+        Ok(())
+    } else {
+        bail!("failed to close Device Farm sessions: {}", failures.join("; "))
+    }
+}
+
+fn init_logging(filter: EnvFilter) -> Result<()> {
+    registry()
+        .with(
+            fmt::layer()
+                .with_writer(std::io::stderr)
+                .with_span_events(fmt::format::FmtSpan::CLOSE)
+                .with_filter(filter),
+        )
+        .with(tracing_error::ErrorLayer::default())
+        .try_init()?;
+
+    Ok(())
+}
+
+fn format_sessions_json(sessions: &[DeviceFarmSessionInfo]) -> Result<String> {
+    let summary = SessionListOutput::new(sessions);
+    let mut output = serde_json::to_string_pretty(&summary)?;
+    output.push('\n');
+    Ok(output)
+}
+
+fn format_sessions_human(sessions: &[DeviceFarmSessionInfo]) -> String {
+    if sessions.is_empty() {
+        return format!(
+            "No Device Farm sessions found.\n{}\n",
+            cost_summary_text(total_billing_minutes(sessions))
+        );
+    }
+
+    let headers = ["ID", "STATUS", "CREATED", "AGE", "ENDED", "BILLING"];
+    let rows = sessions
+        .iter()
+        .map(|session| {
+            [
+                session.session_id.clone(),
+                session.status.clone(),
+                session.created.clone().unwrap_or_else(|| "-".to_string()),
+                age_text(session.age_seconds),
+                session.ended.clone().unwrap_or_else(|| "-".to_string()),
+                billing_text(session.billing_minutes),
+            ]
+        })
+        .collect::<Vec<_>>();
+    let widths = (0..headers.len())
+        .map(|index| {
+            rows.iter()
+                .map(|row| row[index].len())
+                .max()
+                .unwrap_or_default()
+                .max(headers[index].len())
+        })
+        .collect::<Vec<_>>();
+
+    let mut output = String::new();
+    write_table_row(&mut output, &headers, &widths);
+    for row in &rows {
+        write_table_row(&mut output, row, &widths);
+    }
+    output.push_str(&cost_summary_text(total_billing_minutes(sessions)));
+    output.push('\n');
+    output
+}
+
+fn write_table_row<const N: usize>(output: &mut String, columns: &[impl AsRef<str>; N], widths: &[usize]) {
+    for (index, column) in columns.iter().enumerate() {
+        if index > 0 {
+            output.push_str("  ");
+        }
+        let value = column.as_ref();
+        output.push_str(value);
+        for _ in value.len()..widths[index] {
+            output.push(' ');
+        }
+    }
+    output.push('\n');
+}
+
+fn age_text(seconds: Option<i64>) -> String {
+    let Some(seconds) = seconds.filter(|seconds| *seconds >= 0) else {
+        return "-".to_string();
+    };
+    let hours = seconds / 3600;
+    let minutes = (seconds % 3600) / 60;
+    let seconds = seconds % 60;
+
+    if hours > 0 {
+        format!("{hours}h {minutes:02}m")
+    } else if minutes > 0 {
+        format!("{minutes}m {seconds:02}s")
+    } else {
+        format!("{seconds}s")
+    }
+}
+
+fn billing_text(minutes: Option<f64>) -> String {
+    minutes.map_or_else(|| "-".to_string(), |minutes| format!("{minutes:.2}"))
+}
+
+fn parse_since_arg(value: &str) -> std::result::Result<SinceDate, String> {
+    parse_since_epoch_seconds(value)
+        .map(|epoch_seconds| SinceDate { epoch_seconds })
+        .ok_or_else(|| {
+            "expected YYYY-MM-DD, YYYY-MM-DD HH:MM[:SS], YYYY-MM-DDTHH:MM[:SS], or RFC3339 timestamp".to_string()
+        })
+}
+
+fn parse_since_epoch_seconds(value: &str) -> Option<i64> {
+    use chrono::{
+        Local,
+        NaiveDate,
+        NaiveDateTime,
+        TimeZone as _,
+    };
+
+    if let Ok(parsed) = chrono::DateTime::parse_from_rfc3339(value) {
+        return Some(parsed.timestamp());
+    }
+
+    for format in [
+        "%Y-%m-%d %H:%M:%S",
+        "%Y-%m-%d %H:%M",
+        "%Y-%m-%dT%H:%M:%S",
+        "%Y-%m-%dT%H:%M",
+    ] {
+        if let Ok(parsed) = NaiveDateTime::parse_from_str(value, format) {
+            return Local.from_local_datetime(&parsed).single().map(|date| date.timestamp());
+        }
+    }
+
+    NaiveDate::parse_from_str(value, "%Y-%m-%d")
+        .ok()
+        .and_then(|date| date.and_hms_opt(0, 0, 0))
+        .and_then(|date| Local.from_local_datetime(&date).single())
+        .map(|date| date.timestamp())
+}
+
+fn filter_sessions_since(
+    sessions: Vec<DeviceFarmSessionInfo>,
+    since: Option<&SinceDate>,
+) -> Vec<DeviceFarmSessionInfo> {
+    let Some(since) = since else {
+        return sessions;
+    };
+
+    sessions
+        .into_iter()
+        .filter(|session| {
+            session
+                .created
+                .as_deref()
+                .and_then(parse_created_epoch_seconds)
+                .is_some_and(|created| created >= since.epoch_seconds)
+        })
+        .collect()
+}
+
+fn parse_created_epoch_seconds(value: &str) -> Option<i64> {
+    chrono::DateTime::parse_from_rfc3339(value)
+        .ok()
+        .map(|date| date.timestamp())
+}
+
+fn total_billing_minutes(sessions: &[DeviceFarmSessionInfo]) -> f64 {
+    normalize_zero(sessions.iter().filter_map(|session| session.billing_minutes).sum())
+}
+
+fn total_cost_usd(total_billing_minutes: f64) -> f64 {
+    normalize_zero(total_billing_minutes * DEVICE_FARM_DESKTOP_INSTANCE_MINUTE_USD)
+}
+
+fn normalize_zero(value: f64) -> f64 {
+    if value.abs() < f64::EPSILON {
+        0.0
+    } else {
+        value
+    }
+}
+
+fn cost_summary_text(total_billing_minutes: f64) -> String {
+    format!(
+        "Total cost: ${:.4} ({:.2} billing minutes at ${:.4}/min)",
+        total_cost_usd(total_billing_minutes),
+        total_billing_minutes,
+        DEVICE_FARM_DESKTOP_INSTANCE_MINUTE_USD
+    )
+}
+
+#[derive(Serialize)]
+struct SessionListOutput<'a> {
+    sessions: &'a [DeviceFarmSessionInfo],
+    total_billing_minutes: f64,
+    total_cost_usd: f64,
+    instance_minute_usd: f64,
+}
+
+impl<'a> SessionListOutput<'a> {
+    fn new(sessions: &'a [DeviceFarmSessionInfo]) -> Self {
+        let total_billing_minutes = total_billing_minutes(sessions);
+        Self {
+            sessions,
+            total_billing_minutes,
+            total_cost_usd: total_cost_usd(total_billing_minutes),
+            instance_minute_usd: DEVICE_FARM_DESKTOP_INSTANCE_MINUTE_USD,
+        }
+    }
+}
+
+fn close_targets(requested_session_ids: &[String], sessions: &[DeviceFarmSessionInfo]) -> Vec<String> {
+    let candidates = if requested_session_ids.is_empty() {
+        sessions
+            .iter()
+            .filter(|session| session.status == "ACTIVE")
+            .map(|session| session.session_id.clone())
+            .collect::<Vec<_>>()
+    } else {
+        requested_session_ids.to_vec()
+    };
+
+    let mut targets = Vec::new();
+    for session_id in candidates {
+        if !session_id.is_empty() && !targets.contains(&session_id) {
+            targets.push(session_id);
+        }
+    }
+    targets
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use client_simulator_browser::participant::device_farm::DeviceFarmSessionInfo;
+    use serde_json::json;
+
+    #[test]
+    fn human_output_includes_session_table_columns() {
+        let output = format_sessions_human(&[session_fixture("session-1", "ACTIVE")]);
+
+        assert!(output.contains("ID"));
+        assert!(output.contains("STATUS"));
+        assert!(output.contains("CREATED"));
+        assert!(output.contains("AGE"));
+        assert!(output.contains("BILLING"));
+        assert!(output.contains("session-1"));
+        assert!(output.contains("ACTIVE"));
+        assert!(output.contains("12m 34s"));
+    }
+
+    #[test]
+    fn json_output_includes_sessions_and_total_cost() {
+        let output = format_sessions_json(&[session_fixture_with_billing("session-1", "ACTIVE", 12.5)]).unwrap();
+        let value: serde_json::Value = serde_json::from_str(&output).unwrap();
+
+        assert_eq!(
+            value["sessions"],
+            json!([session_fixture_with_billing("session-1", "ACTIVE", 12.5)])
+        );
+        assert_eq!(value["total_billing_minutes"], json!(12.5));
+        assert_eq!(value["total_cost_usd"], json!(0.0625));
+        assert_eq!(value["instance_minute_usd"], json!(0.005));
+    }
+
+    #[test]
+    fn empty_list_output_is_explicit() {
+        assert_eq!(
+            format_sessions_human(&[]),
+            "No Device Farm sessions found.\nTotal cost: $0.0000 (0.00 billing minutes at $0.0050/min)\n"
+        );
+        let value: serde_json::Value = serde_json::from_str(&format_sessions_json(&[]).unwrap()).unwrap();
+        assert_eq!(value["sessions"], json!([]));
+        assert_eq!(value["total_cost_usd"], json!(0.0));
+    }
+
+    #[test]
+    fn human_output_includes_total_cost_for_shown_sessions() {
+        let output = format_sessions_human(&[
+            session_fixture_with_billing("session-1", "CLOSED", 10.0),
+            session_fixture_with_billing("session-2", "CLOSED", 20.5),
+        ]);
+
+        assert!(output.contains("Total cost: $0.1525 (30.50 billing minutes at $0.0050/min)"));
+    }
+
+    #[test]
+    fn list_status_maps_to_aws_status_filter() {
+        assert_eq!(
+            ListSessionsStatus::Active.test_grid_status(),
+            Some(device_farm::TestGridSessionStatus::Active)
+        );
+        assert_eq!(
+            ListSessionsStatus::Closed.test_grid_status(),
+            Some(device_farm::TestGridSessionStatus::Closed)
+        );
+        assert_eq!(ListSessionsStatus::All.test_grid_status(), None);
+    }
+
+    #[test]
+    fn parse_since_accepts_date_and_optional_time() {
+        assert!(parse_since_arg("2026-06-04").is_ok());
+        assert!(parse_since_arg("2026-06-04 10:11").is_ok());
+        assert!(parse_since_arg("2026-06-04T10:11:12").is_ok());
+        assert!(parse_since_arg("2026-06-04T10:11:12Z").is_ok());
+    }
+
+    #[test]
+    fn parse_since_rejects_unknown_text() {
+        assert!(parse_since_arg("last tuesday").is_err());
+    }
+
+    #[test]
+    fn since_filter_keeps_sessions_created_at_or_after_threshold() {
+        let since = parse_since_arg("2026-06-04T10:11:12Z").unwrap();
+        let sessions = vec![
+            session_fixture_with_created("before", "CLOSED", "2026-06-04T10:11:11Z"),
+            session_fixture_with_created("at", "CLOSED", "2026-06-04T10:11:12Z"),
+            session_fixture_with_created("after", "CLOSED", "2026-06-04T10:11:13Z"),
+            DeviceFarmSessionInfo {
+                created: None,
+                ..session_fixture("missing-created", "CLOSED")
+            },
+        ];
+
+        let filtered = filter_sessions_since(sessions, Some(&since));
+        let ids = filtered
+            .iter()
+            .map(|session| session.session_id.as_str())
+            .collect::<Vec<_>>();
+
+        assert_eq!(ids, vec!["at", "after"]);
+    }
+
+    #[test]
+    fn provided_close_ids_target_exactly_those_ids() {
+        let targets = close_targets(
+            &["a".to_string(), "b".to_string()],
+            &[session_fixture("active-session", "ACTIVE")],
+        );
+
+        assert_eq!(targets, vec!["a", "b"]);
+    }
+
+    #[test]
+    fn empty_close_ids_selects_all_active_sessions() {
+        let targets = close_targets(
+            &[],
+            &[
+                session_fixture("active-1", "ACTIVE"),
+                session_fixture("closed-1", "CLOSED"),
+                session_fixture("active-2", "ACTIVE"),
+            ],
+        );
+
+        assert_eq!(targets, vec!["active-1", "active-2"]);
+    }
+
+    #[test]
+    fn empty_close_ids_do_not_select_closed_or_errored_sessions() {
+        let targets = close_targets(
+            &[],
+            &[
+                session_fixture("closed-1", "CLOSED"),
+                session_fixture("errored-1", "ERRORED"),
+            ],
+        );
+
+        assert!(targets.is_empty());
+    }
+
+    #[test]
+    fn close_targets_deduplicates_preserving_first_seen_order() {
+        let targets = close_targets(
+            &["b".to_string(), "a".to_string(), "b".to_string(), "c".to_string()],
+            &[],
+        );
+
+        assert_eq!(targets, vec!["b", "a", "c"]);
+    }
+
+    fn session_fixture(session_id: &str, status: &str) -> DeviceFarmSessionInfo {
+        DeviceFarmSessionInfo {
+            arn: format!("arn:aws:devicefarm:us-west-2:123456789012:testgrid-session:project/{session_id}"),
+            session_id: session_id.to_string(),
+            status: status.to_string(),
+            created: Some("2026-06-04T10:11:12Z".to_string()),
+            ended: None,
+            age_seconds: Some(754),
+            billing_minutes: None,
+            selenium_properties: Some(json!({"browserName": "chrome"})),
+        }
+    }
+
+    fn session_fixture_with_billing(session_id: &str, status: &str, billing_minutes: f64) -> DeviceFarmSessionInfo {
+        DeviceFarmSessionInfo {
+            billing_minutes: Some(billing_minutes),
+            ..session_fixture(session_id, status)
+        }
+    }
+
+    fn session_fixture_with_created(session_id: &str, status: &str, created: &str) -> DeviceFarmSessionInfo {
+        DeviceFarmSessionInfo {
+            created: Some(created.to_string()),
+            ..session_fixture(session_id, status)
+        }
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 3da495a..ef044c4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,3 +1,4 @@
+mod aws;
 mod errors;
 mod headless;
 
@@ -78,6 +79,8 @@ enum Command {
     Headless(headless::HeadlessArgs),
     /// Connect to the hyper server to get a hyper session cookie
     Cookie(CookieArgs),
+    /// Manage AWS Device Farm Test Grid sessions
+    Aws(aws::AwsArgs),
 }
 
 #[cfg(test)]
@@ -157,6 +160,110 @@ mod tests {
         assert!(filter.contains("warn"));
         assert!(filter.contains("client_simulator_browser=debug"));
     }
+
+    #[test]
+    fn parses_aws_list_sessions_json() {
+        let args = CliArgs::parse_from(["hyper-client-simulator", "aws", "list-sessions", "--json"]);
+        match args.command {
+            Some(Command::Aws(aws::AwsArgs {
+                command: aws::AwsCommand::ListSessions(args),
+            })) => {
+                assert!(args.json);
+                assert_eq!(args.status, aws::ListSessionsStatus::Active);
+            }
+            other => panic!("expected aws list-sessions, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn parses_aws_list_sessions_closed_status() {
+        let args = CliArgs::parse_from(["hyper-client-simulator", "aws", "list-sessions", "--status", "closed"]);
+        match args.command {
+            Some(Command::Aws(aws::AwsArgs {
+                command: aws::AwsCommand::ListSessions(args),
+            })) => {
+                assert_eq!(args.status, aws::ListSessionsStatus::Closed);
+            }
+            other => panic!("expected aws list-sessions, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn parses_aws_list_sessions_all_status() {
+        let args = CliArgs::parse_from(["hyper-client-simulator", "aws", "list-sessions", "--status", "all"]);
+        match args.command {
+            Some(Command::Aws(aws::AwsArgs {
+                command: aws::AwsCommand::ListSessions(args),
+            })) => {
+                assert_eq!(args.status, aws::ListSessionsStatus::All);
+            }
+            other => panic!("expected aws list-sessions, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn parses_aws_list_sessions_since_date() {
+        let args = CliArgs::parse_from([
+            "hyper-client-simulator",
+            "aws",
+            "list-sessions",
+            "--since",
+            "2026-06-04",
+        ]);
+        match args.command {
+            Some(Command::Aws(aws::AwsArgs {
+                command: aws::AwsCommand::ListSessions(args),
+            })) => {
+                assert!(args.since.is_some());
+            }
+            other => panic!("expected aws list-sessions, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn parses_aws_list_sessions_since_date_time() {
+        let args = CliArgs::parse_from([
+            "hyper-client-simulator",
+            "aws",
+            "list-sessions",
+            "--since",
+            "2026-06-04 10:11",
+        ]);
+        match args.command {
+            Some(Command::Aws(aws::AwsArgs {
+                command: aws::AwsCommand::ListSessions(args),
+            })) => {
+                assert!(args.since.is_some());
+            }
+            other => panic!("expected aws list-sessions, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn parses_aws_close_sessions_with_comma_separated_ids() {
+        let args = CliArgs::parse_from(["hyper-client-simulator", "aws", "close-sessions", "a,b,c"]);
+        match args.command {
+            Some(Command::Aws(aws::AwsArgs {
+                command: aws::AwsCommand::CloseSessions(args),
+            })) => {
+                assert_eq!(args.session_ids, vec!["a", "b", "c"]);
+            }
+            other => panic!("expected aws close-sessions, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn parses_aws_close_sessions_without_ids() {
+        let args = CliArgs::parse_from(["hyper-client-simulator", "aws", "close-sessions"]);
+        match args.command {
+            Some(Command::Aws(aws::AwsArgs {
+                command: aws::AwsCommand::CloseSessions(args),
+            })) => {
+                assert!(args.session_ids.is_empty());
+            }
+            other => panic!("expected aws close-sessions, got {other:?}"),
+        }
+    }
 }
 
 #[derive(clap::Args, Debug, Clone)]
@@ -187,6 +294,7 @@ async fn main() -> eyre::Result<()> {
             std::process::exit(code);
         }
         Some(Command::Cookie(args)) => run_cookie(args, logging_filter_from_env(logging)).await,
+        Some(Command::Aws(args)) => aws::run(args, logging_filter_from_env(logging)).await,
     }
 }
 

From f5b8e1490457a5dbaa32ac3f36239577ee41b2c1 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 16:54:22 +0200
Subject: [PATCH 36/42] update github workflows to use aws secrets

---
 .github/workflows/ci.yml      | 5 +++++
 .github/workflows/release.yml | 8 ++++++++
 2 files changed, 13 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c806491..870e090 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -61,6 +61,11 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     if: ${{ github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository }}
+    env:
+      DEVICE_FARM_AWS_ACCESS_KEY_ID: ${{ secrets.DEVICE_FARM_AWS_ACCESS_KEY_ID }}
+      DEVICE_FARM_AWS_SECRET_ACCESS_KEY: ${{ secrets.DEVICE_FARM_AWS_SECRET_ACCESS_KEY }}
+      DEVICE_FARM_AWS_REGION: ${{ secrets.DEVICE_FARM_AWS_REGION }}
+      DEVICE_FARM_PROJECT_ARN: ${{ secrets.DEVICE_FARM_PROJECT_ARN }}
 
     steps:
       - name: Checkout repository
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 67b2858..c8745b7 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -113,6 +113,10 @@ jobs:
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json
+      DEVICE_FARM_AWS_ACCESS_KEY_ID: ${{ secrets.DEVICE_FARM_AWS_ACCESS_KEY_ID }}
+      DEVICE_FARM_AWS_SECRET_ACCESS_KEY: ${{ secrets.DEVICE_FARM_AWS_SECRET_ACCESS_KEY }}
+      DEVICE_FARM_AWS_REGION: ${{ secrets.DEVICE_FARM_AWS_REGION }}
+      DEVICE_FARM_PROJECT_ARN: ${{ secrets.DEVICE_FARM_PROJECT_ARN }}
     steps:
       - name: enable windows longpaths
         run: |
@@ -176,6 +180,10 @@ jobs:
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
+      DEVICE_FARM_AWS_ACCESS_KEY_ID: ${{ secrets.DEVICE_FARM_AWS_ACCESS_KEY_ID }}
+      DEVICE_FARM_AWS_SECRET_ACCESS_KEY: ${{ secrets.DEVICE_FARM_AWS_SECRET_ACCESS_KEY }}
+      DEVICE_FARM_AWS_REGION: ${{ secrets.DEVICE_FARM_AWS_REGION }}
+      DEVICE_FARM_PROJECT_ARN: ${{ secrets.DEVICE_FARM_PROJECT_ARN }}
     steps:
       - uses: actions/checkout@v6
         with:

From a5c42ea30368d01c6e0c6b40cf834c0d340f2719 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 17:27:02 +0200
Subject: [PATCH 37/42] fix(config): drop unused device farm timeouts

---
 browser/tests/device_farm_driver.rs |  2 --
 config/src/default-config.yaml      |  2 --
 config/src/device_farm_config.rs    |  4 ----
 config/src/lib.rs                   | 23 +++++++++++++----------
 4 files changed, 13 insertions(+), 18 deletions(-)

diff --git a/browser/tests/device_farm_driver.rs b/browser/tests/device_farm_driver.rs
index 5503e4a..b5f5c95 100644
--- a/browser/tests/device_farm_driver.rs
+++ b/browser/tests/device_farm_driver.rs
@@ -303,8 +303,6 @@ fn device_farm_config() -> Config {
         url_expires_seconds: 300,
         session_max_duration_ms: 60_000,
         idle_timeout_ms: 30_000,
-        navigation_timeout_ms: 45_000,
-        selector_timeout_ms: 20_000,
         health_poll_interval_ms: 30_000,
         debug: false,
     };
diff --git a/config/src/default-config.yaml b/config/src/default-config.yaml
index 381dd79..a6bfcce 100644
--- a/config/src/default-config.yaml
+++ b/config/src/default-config.yaml
@@ -39,8 +39,6 @@ device_farm:
   url_expires_seconds: 300
   session_max_duration_ms: 1800000
   idle_timeout_ms: 180000
-  navigation_timeout_ms: 45000
-  selector_timeout_ms: 20000
   health_poll_interval_ms: 30000
   debug: false
 audio_enabled: true
diff --git a/config/src/device_farm_config.rs b/config/src/device_farm_config.rs
index d47c92a..2154995 100644
--- a/config/src/device_farm_config.rs
+++ b/config/src/device_farm_config.rs
@@ -23,8 +23,6 @@ pub struct DeviceFarmConfig {
     pub session_max_duration_ms: u64,
     /// `aws:idleTimeoutSecs` capability - max gap between WebDriver commands.
     pub idle_timeout_ms: u64,
-    pub navigation_timeout_ms: u64,
-    pub selector_timeout_ms: u64,
     /// How often the keep-alive poller pings the live session.
     pub health_poll_interval_ms: u64,
     pub debug: bool,
@@ -44,8 +42,6 @@ impl Default for DeviceFarmConfig {
             url_expires_seconds: 300,
             session_max_duration_ms: 1_800_000,
             idle_timeout_ms: 180_000,
-            navigation_timeout_ms: 45_000,
-            selector_timeout_ms: 20_000,
             health_poll_interval_ms: 30_000,
             debug: false,
         }
diff --git a/config/src/lib.rs b/config/src/lib.rs
index c5cc100..c672444 100644
--- a/config/src/lib.rs
+++ b/config/src/lib.rs
@@ -163,14 +163,6 @@ impl config::Source for Config {
                         self.device_farm.session_max_duration_ms.into(),
                     ),
                     ("idle_timeout_ms".to_string(), self.device_farm.idle_timeout_ms.into()),
-                    (
-                        "navigation_timeout_ms".to_string(),
-                        self.device_farm.navigation_timeout_ms.into(),
-                    ),
-                    (
-                        "selector_timeout_ms".to_string(),
-                        self.device_farm.selector_timeout_ms.into(),
-                    ),
                     (
                         "health_poll_interval_ms".to_string(),
                         self.device_farm.health_poll_interval_ms.into(),
@@ -420,8 +412,6 @@ device_farm:
   url_expires_seconds: 300
   session_max_duration_ms: 1800000
   idle_timeout_ms: 180000
-  navigation_timeout_ms: 45000
-  selector_timeout_ms: 20000
   health_poll_interval_ms: 30000
   debug: true
 "#,
@@ -441,6 +431,19 @@ device_farm:
         assert!(config.device_farm.debug);
     }
 
+    #[test]
+    fn default_device_farm_config_omits_unused_timeouts() {
+        let defaults = include_str!("default-config.yaml");
+        let device_farm = defaults
+            .split_once("device_farm:\n")
+            .and_then(|(_, rest)| rest.split_once("\naudio_enabled:"))
+            .map(|(device_farm, _)| device_farm)
+            .expect("default config should contain a device_farm section");
+
+        assert!(!device_farm.contains("navigation_timeout_ms"));
+        assert!(!device_farm.contains("selector_timeout_ms"));
+    }
+
     #[test]
     fn parses_new_video_constraint_settings() {
         let config: Config = config::Config::builder()

From 2cab0a7fe8fafea4431d99b864a1f5e501f014f8 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 17:52:27 +0200
Subject: [PATCH 38/42] feat(cli): support human durations for aws since

---
 Cargo.lock  |  7 +++++++
 Cargo.toml  |  2 ++
 src/aws.rs  | 25 +++++++++++++++++++++----
 src/main.rs | 13 +++++++++++++
 4 files changed, 43 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3787b25..e8a25c1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1874,6 +1874,12 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "humantime"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
+
 [[package]]
 name = "hybrid-array"
 version = "0.4.11"
@@ -1941,6 +1947,7 @@ dependencies = [
  "color-eyre",
  "eyre",
  "human-panic",
+ "humantime",
  "libc",
  "serde",
  "serde_json",
diff --git a/Cargo.toml b/Cargo.toml
index 6f01401..30d8df1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,6 +32,7 @@ directories = "6.0.0"
 eyre = "0.6.12"
 futures = "0.3.32"
 human-panic = "2.0.8"
+humantime = "2.3.0"
 http = "1.4.0"
 lazy_static = "1.5.0"
 libc = "0.2.186"
@@ -95,6 +96,7 @@ client-simulator-tui.workspace = true
 color-eyre.workspace = true
 eyre.workspace = true
 human-panic.workspace = true
+humantime.workspace = true
 libc.workspace = true
 serde_json.workspace = true
 serde.workspace = true
diff --git a/src/aws.rs b/src/aws.rs
index 63d8418..73d4bcd 100644
--- a/src/aws.rs
+++ b/src/aws.rs
@@ -49,8 +49,8 @@ pub struct ListSessionsArgs {
     /// Filter sessions by Device Farm status.
     #[clap(long, value_enum, default_value_t = ListSessionsStatus::Active)]
     pub status: ListSessionsStatus,
-    /// Only show sessions created at or after this local date/time or RFC3339 timestamp.
-    #[clap(long, value_name = "DATE", value_parser = parse_since_arg)]
+    /// Only show sessions created at or after this local date/time, RFC3339 timestamp, or relative duration.
+    #[clap(long, value_name = "DATE_OR_DURATION", value_parser = parse_since_arg)]
     pub since: Option<SinceDate>,
 }
 
@@ -250,7 +250,7 @@ fn parse_since_arg(value: &str) -> std::result::Result<SinceDate, String> {
     parse_since_epoch_seconds(value)
         .map(|epoch_seconds| SinceDate { epoch_seconds })
         .ok_or_else(|| {
-            "expected YYYY-MM-DD, YYYY-MM-DD HH:MM[:SS], YYYY-MM-DDTHH:MM[:SS], or RFC3339 timestamp".to_string()
+            "expected YYYY-MM-DD, YYYY-MM-DD HH:MM[:SS], YYYY-MM-DDTHH:MM[:SS], RFC3339 timestamp, or human duration like '1 day'".to_string()
         })
 }
 
@@ -277,11 +277,18 @@ fn parse_since_epoch_seconds(value: &str) -> Option<i64> {
         }
     }
 
-    NaiveDate::parse_from_str(value, "%Y-%m-%d")
+    if let Some(timestamp) = NaiveDate::parse_from_str(value, "%Y-%m-%d")
         .ok()
         .and_then(|date| date.and_hms_opt(0, 0, 0))
         .and_then(|date| Local.from_local_datetime(&date).single())
         .map(|date| date.timestamp())
+    {
+        return Some(timestamp);
+    }
+
+    let duration = humantime::parse_duration(value).ok()?;
+    let duration = chrono::Duration::from_std(duration).ok()?;
+    Local::now().checked_sub_signed(duration).map(|date| date.timestamp())
 }
 
 fn filter_sessions_since(
@@ -451,6 +458,16 @@ mod tests {
         assert!(parse_since_arg("2026-06-04T10:11:12Z").is_ok());
     }
 
+    #[test]
+    fn parse_since_accepts_human_duration_relative_to_now() {
+        let before = chrono::Local::now().timestamp();
+        let since = parse_since_arg("1 day").unwrap();
+        let after = chrono::Local::now().timestamp();
+
+        assert!(since.epoch_seconds >= before - 86_400);
+        assert!(since.epoch_seconds <= after - 86_400);
+    }
+
     #[test]
     fn parse_since_rejects_unknown_text() {
         assert!(parse_since_arg("last tuesday").is_err());
diff --git a/src/main.rs b/src/main.rs
index ef044c4..71d3676 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -239,6 +239,19 @@ mod tests {
         }
     }
 
+    #[test]
+    fn parses_aws_list_sessions_since_human_duration() {
+        let args = CliArgs::parse_from(["hyper-client-simulator", "aws", "list-sessions", "--since", "1 day"]);
+        match args.command {
+            Some(Command::Aws(aws::AwsArgs {
+                command: aws::AwsCommand::ListSessions(args),
+            })) => {
+                assert!(args.since.is_some());
+            }
+            other => panic!("expected aws list-sessions, got {other:?}"),
+        }
+    }
+
     #[test]
     fn parses_aws_close_sessions_with_comma_separated_ids() {
         let args = CliArgs::parse_from(["hyper-client-simulator", "aws", "close-sessions", "a,b,c"]);

From 1413742b1bc21d0984b19060a0f6a40b2054ff34 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 17:54:30 +0200
Subject: [PATCH 39/42] ci: allow custom cargo-dist workflow

---
 dist-workspace.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/dist-workspace.toml b/dist-workspace.toml
index 4364451..b221357 100644
--- a/dist-workspace.toml
+++ b/dist-workspace.toml
@@ -5,6 +5,9 @@ members = ["cargo:."]
 [dist]
 # The preferred dist version to use in CI (Cargo.toml SemVer syntax)
 cargo-dist-version = "0.30.4"
+# Keep the generated workflow hand-maintained for private submodule checkout and
+# Device Farm build-time secrets.
+allow-dirty = ["ci"]
 # CI backends to support
 ci = "github"
 # The installers to generate for each app

From 42045f4bc82d9f49993ddfb9a12705259de8a8fc Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Thu, 4 Jun 2026 18:00:50 +0200
Subject: [PATCH 40/42] fix(deps): avoid legacy AWS rustls stack

---
 Cargo.lock | 172 ++++++++---------------------------------------------
 Cargo.toml |   4 +-
 2 files changed, 27 insertions(+), 149 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e8a25c1..99ace72 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -358,23 +358,17 @@ dependencies = [
  "aws-smithy-async",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
- "h2 0.3.27",
- "h2 0.4.14",
- "http 0.2.12",
+ "h2",
  "http 1.4.0",
- "http-body 0.4.6",
- "hyper 0.14.32",
- "hyper 1.9.0",
- "hyper-rustls 0.24.2",
- "hyper-rustls 0.27.9",
+ "hyper",
+ "hyper-rustls",
  "hyper-util",
  "pin-project-lite",
- "rustls 0.21.12",
- "rustls 0.23.40",
+ "rustls",
  "rustls-native-certs",
  "rustls-pki-types",
  "tokio",
- "tokio-rustls 0.26.4",
+ "tokio-rustls",
  "tower",
  "tracing",
 ]
@@ -1697,25 +1691,6 @@ version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 
-[[package]]
-name = "h2"
-version = "0.3.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"
-dependencies = [
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http 0.2.12",
- "indexmap",
- "slab",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
 [[package]]
 name = "h2"
 version = "0.4.14"
@@ -1852,12 +1827,6 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 
-[[package]]
-name = "httpdate"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
-
 [[package]]
 name = "human-panic"
 version = "2.0.8"
@@ -1889,30 +1858,6 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "hyper"
-version = "0.14.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
-dependencies = [
- "bytes",
- "futures-channel",
- "futures-core",
- "futures-util",
- "h2 0.3.27",
- "http 0.2.12",
- "http-body 0.4.6",
- "httparse",
- "httpdate",
- "itoa",
- "pin-project-lite",
- "socket2 0.5.10",
- "tokio",
- "tower-service",
- "tracing",
- "want",
-]
-
 [[package]]
 name = "hyper"
 version = "1.9.0"
@@ -1923,7 +1868,7 @@ dependencies = [
  "bytes",
  "futures-channel",
  "futures-core",
- "h2 0.4.14",
+ "h2",
  "http 1.4.0",
  "http-body 1.0.1",
  "httparse",
@@ -1959,21 +1904,6 @@ dependencies = [
  "url",
 ]
 
-[[package]]
-name = "hyper-rustls"
-version = "0.24.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
-dependencies = [
- "futures-util",
- "http 0.2.12",
- "hyper 0.14.32",
- "log",
- "rustls 0.21.12",
- "tokio",
- "tokio-rustls 0.24.1",
-]
-
 [[package]]
 name = "hyper-rustls"
 version = "0.27.9"
@@ -1981,12 +1911,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"
 dependencies = [
  "http 1.4.0",
- "hyper 1.9.0",
+ "hyper",
  "hyper-util",
- "rustls 0.23.40",
+ "rustls",
  "rustls-native-certs",
  "tokio",
- "tokio-rustls 0.26.4",
+ "tokio-rustls",
  "tower-service",
 ]
 
@@ -2002,12 +1932,12 @@ dependencies = [
  "futures-util",
  "http 1.4.0",
  "http-body 1.0.1",
- "hyper 1.9.0",
+ "hyper",
  "ipnet",
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.3",
+ "socket2",
  "system-configuration",
  "tokio",
  "tower-service",
@@ -3039,8 +2969,8 @@ dependencies = [
  "quinn-proto",
  "quinn-udp",
  "rustc-hash",
- "rustls 0.23.40",
- "socket2 0.6.3",
+ "rustls",
+ "socket2",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
@@ -3060,7 +2990,7 @@ dependencies = [
  "rand 0.9.4",
  "ring",
  "rustc-hash",
- "rustls 0.23.40",
+ "rustls",
  "rustls-pki-types",
  "slab",
  "thiserror 2.0.18",
@@ -3078,7 +3008,7 @@ dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.6.3",
+ "socket2",
  "tracing",
  "windows-sys 0.60.2",
 ]
@@ -3343,12 +3273,12 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2 0.4.14",
+ "h2",
  "http 1.4.0",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.9.0",
- "hyper-rustls 0.27.9",
+ "hyper",
+ "hyper-rustls",
  "hyper-util",
  "js-sys",
  "log",
@@ -3356,7 +3286,7 @@ dependencies = [
  "percent-encoding",
  "pin-project-lite",
  "quinn",
- "rustls 0.23.40",
+ "rustls",
  "rustls-pki-types",
  "rustls-platform-verifier",
  "serde",
@@ -3364,7 +3294,7 @@ dependencies = [
  "serde_urlencoded",
  "sync_wrapper",
  "tokio",
- "tokio-rustls 0.26.4",
+ "tokio-rustls",
  "tokio-util",
  "tower",
  "tower-http",
@@ -3437,18 +3367,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "rustls"
-version = "0.21.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
-dependencies = [
- "log",
- "ring",
- "rustls-webpki 0.101.7",
- "sct",
-]
-
 [[package]]
 name = "rustls"
 version = "0.23.40"
@@ -3458,7 +3376,7 @@ dependencies = [
  "aws-lc-rs",
  "once_cell",
  "rustls-pki-types",
- "rustls-webpki 0.103.13",
+ "rustls-webpki",
  "subtle",
  "zeroize",
 ]
@@ -3496,10 +3414,10 @@ dependencies = [
  "jni",
  "log",
  "once_cell",
- "rustls 0.23.40",
+ "rustls",
  "rustls-native-certs",
  "rustls-platform-verifier-android",
- "rustls-webpki 0.103.13",
+ "rustls-webpki",
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
@@ -3512,16 +3430,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
-[[package]]
-name = "rustls-webpki"
-version = "0.101.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
-dependencies = [
- "ring",
- "untrusted",
-]
-
 [[package]]
 name = "rustls-webpki"
 version = "0.103.13"
@@ -3596,16 +3504,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
-[[package]]
-name = "sct"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
-dependencies = [
- "ring",
- "untrusted",
-]
-
 [[package]]
 name = "security-framework"
 version = "3.7.0"
@@ -3891,16 +3789,6 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
-[[package]]
-name = "socket2"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
-dependencies = [
- "libc",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "socket2"
 version = "0.6.3"
@@ -4326,7 +4214,7 @@ dependencies = [
  "mio",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.6.3",
+ "socket2",
  "tokio-macros",
  "windows-sys 0.61.2",
 ]
@@ -4342,23 +4230,13 @@ dependencies = [
  "syn 2.0.117",
 ]
 
-[[package]]
-name = "tokio-rustls"
-version = "0.24.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
-dependencies = [
- "rustls 0.21.12",
- "tokio",
-]
-
 [[package]]
 name = "tokio-rustls"
 version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
- "rustls 0.23.40",
+ "rustls",
  "tokio",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 30d8df1..d79823d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,8 +16,8 @@ homepage = "https://github.com/hypervideo/browser-simulator"
 repository = "https://github.com/hypervideo/browser-simulator"
 
 [workspace.dependencies]
-aws-config = { version = "1", default-features = false, features = ["behavior-version-latest", "rt-tokio", "rustls"] }
-aws-sdk-devicefarm = { version = "1", default-features = false, features = ["behavior-version-latest", "rt-tokio", "rustls"] }
+aws-config = { version = "1", default-features = false, features = ["behavior-version-latest", "rt-tokio", "default-https-client"] }
+aws-sdk-devicefarm = { version = "1", default-features = false, features = ["behavior-version-latest", "rt-tokio", "default-https-client"] }
 async-trait = "0.1.89"
 better-panic = "0.3.0"
 bytes = "1.11.1"

From 0a8052ab2a18296b955e7cc03b1a06633641211c Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 5 Jun 2026 11:38:05 +0200
Subject: [PATCH 41/42] Fix participant shutdown cleanup race

---
 browser/src/participant/device_farm/mod.rs | 156 +++++++++++++++++++--
 browser/src/participant/mod.rs             | 122 ++++++++++++++--
 tui/src/tui/app.rs                         |   5 +
 3 files changed, 264 insertions(+), 19 deletions(-)

diff --git a/browser/src/participant/device_farm/mod.rs b/browser/src/participant/device_farm/mod.rs
index 23f4665..ec00c79 100644
--- a/browser/src/participant/device_farm/mod.rs
+++ b/browser/src/participant/device_farm/mod.rs
@@ -80,7 +80,10 @@ use tokio::{
         watch,
     },
     task::JoinHandle,
-    time::MissedTickBehavior,
+    time::{
+        timeout,
+        MissedTickBehavior,
+    },
 };
 #[allow(unused_imports)]
 pub(crate) use webdriver_driver::WebDriverDriver;
@@ -89,6 +92,7 @@ const DEVICE_FARM_MAX_DURATION_MIN_SECS: u64 = 180;
 const DEVICE_FARM_MAX_DURATION_MAX_SECS: u64 = 2400;
 const DEVICE_FARM_IDLE_TIMEOUT_MIN_SECS: u64 = 30;
 const DEVICE_FARM_IDLE_TIMEOUT_MAX_SECS: u64 = 900;
+const DEVICE_FARM_FRONTEND_CLOSE_TIMEOUT: Duration = Duration::from_secs(10);
 
 #[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq)]
@@ -327,25 +331,53 @@ impl DeviceFarmSession {
     async fn close_inner(&mut self) -> Result<()> {
         self.stop_max_duration_poller().await;
 
-        if let Some(mut automation) = self.automation.take() {
-            let joined = automation
-                .refresh_state()
-                .await
-                .map(|state| state.joined)
-                .unwrap_or(false);
-            if joined {
-                if let Err(err) = automation.leave().await {
-                    self.log_message("error", format!("Failed leaving space while closing: {err}"));
+        let mut automation = self.automation.take();
+        let driver = self.webdriver.take();
+
+        // Close has two levels: leave the meeting if the frontend still looks
+        // joined, then always tear down the Selenium session. Do not refresh
+        // state here; remote missing-selector calls can block shutdown long
+        // enough to prevent the explicit WebDriver quit below.
+        if self.cached_state.joined {
+            if let Some(automation) = automation.as_mut() {
+                match timeout(DEVICE_FARM_FRONTEND_CLOSE_TIMEOUT, automation.leave()).await {
+                    Ok(Ok(())) => {}
+                    Ok(Err(err)) => {
+                        self.log_message("error", format!("Failed leaving space while closing: {err}"));
+                    }
+                    Err(_) => {
+                        self.log_message(
+                            "warn",
+                            "Timed out leaving space while closing; closing WebDriver session",
+                        );
+                    }
                 }
             }
         }
 
-        if let Some(driver) = self.webdriver.take() {
+        if let Some(driver) = driver {
+            // Keep automation alive until after quit. It owns another
+            // WebDriver clone, and a successful quit marks the shared
+            // SessionHandle so dropping that clone will not run thirtyfour's
+            // synchronous Drop cleanup.
+            let driver_for_leak = driver.clone();
             if let Err(err) = driver.quit().await {
                 self.log_message("error", format!("Failed closing WebDriver session: {err}"));
+                // Explicit DELETE /session failed. Without this, thirtyfour
+                // will try a blocking Drop cleanup later; during Tokio runtime
+                // shutdown that fallback can panic because it schedules work on
+                // a closing executor. leak() only suppresses thirtyfour's Drop
+                // cleanup; it does not leak Rust memory. The remote AWS session
+                // may remain until its idle/max-duration timeout, which is
+                // preferable to crashing after explicit cleanup already failed.
+                if let Err(leak_err) = driver_for_leak.leak() {
+                    debug!(participant = %self.participant_name(), "Could not suppress WebDriver drop cleanup after quit failure: {leak_err}");
+                }
             }
         }
 
+        drop(automation);
+
         self.cached_state.running = false;
         self.cached_state.joined = false;
         self.cached_state.screenshare_activated = false;
@@ -479,6 +511,14 @@ impl ParticipantDriverSession for DeviceFarmSession {
 mod tests {
     use super::*;
     use serde_json::json;
+    use std::sync::{
+        atomic::{
+            AtomicBool,
+            Ordering,
+        },
+        Arc,
+    };
+    use tokio::sync::mpsc::unbounded_channel;
 
     #[test]
     fn capabilities_clamp_aws_duration_ranges() {
@@ -499,4 +539,98 @@ mod tests {
         };
         DeviceFarmSession::build_capabilities(&config).unwrap()
     }
+
+    #[tokio::test]
+    async fn close_uses_cached_state_instead_of_refreshing_frontend_before_leave() {
+        let refreshed = Arc::new(AtomicBool::new(false));
+        let left = Arc::new(AtomicBool::new(false));
+        let (termination_tx, termination_rx) = watch::channel(None);
+        let (sender, _receiver) = unbounded_channel();
+
+        let mut session = DeviceFarmSession {
+            launch_spec: launch_spec(),
+            launch_options: DeviceFarmLaunchOptions {
+                headless: true,
+                fake_media: FakeMedia::default(),
+            },
+            config: DeviceFarmConfig::default(),
+            sender,
+            api: Arc::new(UnusedTestGridApi),
+            auth: None,
+            automation: Some(Box::new(RecordingAutomation {
+                refreshed: Arc::clone(&refreshed),
+                left: Arc::clone(&left),
+            })),
+            webdriver: None,
+            cached_state: ParticipantState {
+                running: true,
+                joined: true,
+                screenshare_activated: true,
+                ..Default::default()
+            },
+            termination_tx,
+            termination_rx,
+            poller_shutdown_tx: None,
+            poller_task: None,
+        };
+
+        session.close_inner().await.unwrap();
+
+        assert!(!refreshed.load(Ordering::SeqCst));
+        assert!(left.load(Ordering::SeqCst));
+        assert!(!session.cached_state.running);
+        assert!(!session.cached_state.joined);
+        assert!(!session.cached_state.screenshare_activated);
+    }
+
+    fn launch_spec() -> ParticipantLaunchSpec {
+        let config = client_simulator_config::Config {
+            url: Some("https://example.com/m/demo".parse().unwrap()),
+            ..Default::default()
+        };
+        let participant_config = client_simulator_config::ParticipantConfig::new(&config, Some("sim-user")).unwrap();
+        ParticipantLaunchSpec::from(participant_config)
+    }
+
+    struct RecordingAutomation {
+        refreshed: Arc<AtomicBool>,
+        left: Arc<AtomicBool>,
+    }
+
+    impl FrontendAutomation for RecordingAutomation {
+        fn join(&mut self) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+
+        fn leave(&mut self) -> BoxFuture<'_, Result<()>> {
+            async move {
+                self.left.store(true, Ordering::SeqCst);
+                Ok(())
+            }
+            .boxed()
+        }
+
+        fn handle_command(&mut self, _message: ParticipantMessage) -> BoxFuture<'_, Result<()>> {
+            async { Ok(()) }.boxed()
+        }
+
+        fn refresh_state(&mut self) -> BoxFuture<'_, Result<ParticipantState>> {
+            async move {
+                self.refreshed.store(true, Ordering::SeqCst);
+                Ok(ParticipantState {
+                    joined: true,
+                    ..Default::default()
+                })
+            }
+            .boxed()
+        }
+    }
+
+    struct UnusedTestGridApi;
+
+    impl TestGridApi for UnusedTestGridApi {
+        fn create_test_grid_url(&self, _project_arn: &str, _expires_seconds: u64) -> BoxFuture<'_, Result<String>> {
+            async { unreachable!("close test should not request a Device Farm URL") }.boxed()
+        }
+    }
 }
diff --git a/browser/src/participant/mod.rs b/browser/src/participant/mod.rs
index 84b232b..77659ce 100644
--- a/browser/src/participant/mod.rs
+++ b/browser/src/participant/mod.rs
@@ -58,6 +58,11 @@ pub use shared::{
     ParticipantStore,
 };
 
+#[cfg(not(test))]
+const PARTICIPANT_CLOSE_PROGRESS_INTERVAL: Duration = Duration::from_secs(10);
+#[cfg(test)]
+const PARTICIPANT_CLOSE_PROGRESS_INTERVAL: Duration = Duration::from_millis(10);
+
 /// Handle to a participant session managed by the participant runtime.
 #[derive(Debug, Clone)]
 pub struct Participant {
@@ -343,13 +348,24 @@ impl Participant {
         }
 
         if self.sender.send(ParticipantMessage::Close).is_ok() {
-            match timeout(Duration::from_secs(10), self.state.wait_for(|state| !state.running)).await {
-                Ok(Ok(_)) => {}
-                Ok(Err(err)) => {
-                    error!(participant = %self.name, "Failed to wait for participant to close: {err}");
-                }
-                Err(_) => {
-                    warn!(participant = %self.name, "Timed out waiting for participant to close");
+            // The timeout is only a progress heartbeat. Returning while the
+            // participant task is still running lets the TUI exit and drop
+            // driver state during Tokio shutdown.
+            loop {
+                match timeout(
+                    PARTICIPANT_CLOSE_PROGRESS_INTERVAL,
+                    self.state.wait_for(|state| !state.running),
+                )
+                .await
+                {
+                    Ok(Ok(_)) => break,
+                    Ok(Err(err)) => {
+                        error!(participant = %self.name, "Failed to wait for participant to close: {err}");
+                        break;
+                    }
+                    Err(_) => {
+                        warn!(participant = %self.name, "Still waiting for participant to close");
+                    }
                 }
             }
         } else {
@@ -460,7 +476,13 @@ mod tests {
             Mutex,
         },
     };
-    use tokio::sync::mpsc::unbounded_channel;
+    use tokio::{
+        sync::{
+            mpsc::unbounded_channel,
+            oneshot,
+        },
+        time::sleep,
+    };
 
     struct RecordingCloseDriver {
         commands: Arc<Mutex<Vec<ParticipantMessage>>>,
@@ -546,4 +568,88 @@ mod tests {
         assert_eq!(close_count.load(Ordering::SeqCst), 1);
         assert!(commands.lock().unwrap().is_empty());
     }
+
+    struct BlockingCloseDriver {
+        close_rx: Option<oneshot::Receiver<()>>,
+    }
+
+    impl ParticipantDriverSession for BlockingCloseDriver {
+        fn participant_name(&self) -> &str {
+            "sim-user"
+        }
+
+        fn start(&mut self) -> BoxFuture<'_, Result<()>> {
+            async move { Ok(()) }.boxed()
+        }
+
+        fn handle_command(&mut self, _message: ParticipantMessage) -> BoxFuture<'_, Result<()>> {
+            async move { Ok(()) }.boxed()
+        }
+
+        fn refresh_state(&mut self) -> BoxFuture<'_, Result<ParticipantState>> {
+            async move {
+                Ok(ParticipantState {
+                    username: "sim-user".to_string(),
+                    running: true,
+                    joined: true,
+                    ..Default::default()
+                })
+            }
+            .boxed()
+        }
+
+        fn close(&mut self) -> BoxFuture<'_, Result<()>> {
+            let close_rx = self.close_rx.take().expect("close should be called once");
+            async move {
+                let _ = close_rx.await;
+                Ok(())
+            }
+            .boxed()
+        }
+
+        fn wait_for_termination(&mut self) -> BoxFuture<'_, DriverTermination> {
+            async move { pending::<DriverTermination>().await }.boxed()
+        }
+    }
+
+    #[tokio::test]
+    async fn close_keeps_waiting_after_progress_timeout_until_driver_stops() {
+        let (command_tx, command_rx) = unbounded_channel();
+        let (log_tx, _log_rx) = unbounded_channel();
+        let (close_tx, close_rx) = oneshot::channel();
+        let (state, task_guard) = spawn_session(
+            "sim-user".to_string(),
+            command_rx,
+            log_tx,
+            BlockingCloseDriver {
+                close_rx: Some(close_rx),
+            },
+        );
+
+        let participant = Participant {
+            name: "sim-user".to_string(),
+            created: Utc::now(),
+            state,
+            _participant_task_guard: task_guard,
+            sender: command_tx,
+            close_strategy: CloseStrategy::DriverCloseOnly,
+        };
+
+        participant
+            .state
+            .clone()
+            .wait_for(|state| state.running && state.joined)
+            .await
+            .unwrap();
+
+        let state = participant.state.clone();
+        let close_task = tokio::spawn(participant.close());
+
+        sleep(PARTICIPANT_CLOSE_PROGRESS_INTERVAL * 2).await;
+        assert!(!close_task.is_finished());
+
+        close_tx.send(()).unwrap();
+        timeout(Duration::from_secs(1), close_task).await.unwrap().unwrap();
+        assert!(!state.borrow().running);
+    }
 }
diff --git a/tui/src/tui/app.rs b/tui/src/tui/app.rs
index 700bb0f..9deea89 100644
--- a/tui/src/tui/app.rs
+++ b/tui/src/tui/app.rs
@@ -188,6 +188,11 @@ impl App {
                 Action::ForceQuit => {
                     if self.shutdown_in_progress {
                         warn!("Force quitting while participant shutdown is still in progress");
+                        // Follow-up hardening: force quit currently lets Tokio
+                        // tear down tasks that may still own browser driver
+                        // handles. A safer force path would track participant
+                        // task handles and run a bounded driver cleanup, or
+                        // explicitly suppress driver Drop cleanup, before exit.
                         self.should_quit = true;
                     } else {
                         self.begin_shutdown(action_tx.clone());

From 5875501acb63b452eb2931482c9d53ac67359ef7 Mon Sep 17 00:00:00 2001
From: Robert Krahn <robert.krahn@gmail.com>
Date: Fri, 5 Jun 2026 11:58:44 +0200
Subject: [PATCH 42/42] Fix headless participant cleanup races

---
 browser/src/participant/mod.rs | 351 ++++++++++++++++++++++++++++++---
 src/headless.rs                |  44 ++++-
 2 files changed, 361 insertions(+), 34 deletions(-)

diff --git a/browser/src/participant/mod.rs b/browser/src/participant/mod.rs
index 77659ce..06a57be 100644
--- a/browser/src/participant/mod.rs
+++ b/browser/src/participant/mod.rs
@@ -26,7 +26,17 @@ use eyre::{
     OptionExt as _,
     Result,
 };
-use std::sync::Arc;
+use futures::{
+    future::{
+        BoxFuture,
+        Shared,
+    },
+    FutureExt as _,
+};
+use std::{
+    fmt,
+    sync::Arc,
+};
 use tokio::{
     sync::{
         mpsc::{
@@ -36,6 +46,7 @@ use tokio::{
         },
         watch,
     },
+    task::JoinHandle,
     time::{
         timeout,
         Duration,
@@ -69,7 +80,7 @@ pub struct Participant {
     pub name: String,
     pub created: chrono::DateTime<chrono::Utc>,
     pub state: watch::Receiver<ParticipantState>,
-    _participant_task_guard: Arc<DropGuard>,
+    participant_task: ParticipantTaskControl,
     sender: UnboundedSender<ParticipantMessage>,
     close_strategy: CloseStrategy,
 }
@@ -86,6 +97,43 @@ enum CloseStrategy {
     LeaveBeforeClose,
 }
 
+#[derive(Clone)]
+struct ParticipantTaskControl {
+    cancellation_token: CancellationToken,
+    _drop_guard: Arc<DropGuard>,
+    completion: Shared<BoxFuture<'static, Option<String>>>,
+}
+
+impl fmt::Debug for ParticipantTaskControl {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ParticipantTaskControl").finish_non_exhaustive()
+    }
+}
+
+impl ParticipantTaskControl {
+    fn new(cancellation_token: CancellationToken, drop_guard: DropGuard, handle: JoinHandle<()>) -> Self {
+        let completion = async move { handle.await.err().map(|err| err.to_string()) }
+            .boxed()
+            .shared();
+
+        Self {
+            cancellation_token,
+            _drop_guard: Arc::new(drop_guard),
+            completion,
+        }
+    }
+
+    fn cancel(&self) {
+        self.cancellation_token.cancel();
+    }
+
+    async fn wait(&self, participant_name: &str) {
+        if let Some(err) = self.completion.clone().await {
+            error!(participant = %participant_name, "Participant task failed while closing: {err}");
+        }
+    }
+}
+
 impl Participant {
     pub fn spawn_with_app_config(config: &Config, cookie_manager: HyperSessionCookieManger) -> Result<Self> {
         let (participant, _) = Self::spawn_with_app_config_and_receiver(config, cookie_manager)?;
@@ -138,7 +186,7 @@ impl Participant {
                 name,
                 created: chrono::Utc::now(),
                 state: state_receiver,
-                _participant_task_guard: task_guard,
+                participant_task: task_guard,
                 sender: sender_tx,
                 close_strategy: CloseStrategy::DriverCloseOnly,
             },
@@ -168,7 +216,7 @@ impl Participant {
             name,
             created: Utc::now(),
             state: state_receiver,
-            _participant_task_guard: task_guard,
+            participant_task: task_guard,
             sender,
             close_strategy: CloseStrategy::DriverCloseOnly,
         })
@@ -206,7 +254,7 @@ impl Participant {
             name,
             created: Utc::now(),
             state: state_receiver,
-            _participant_task_guard: task_guard,
+            participant_task: task_guard,
             sender,
             close_strategy: CloseStrategy::LeaveBeforeClose,
         })
@@ -267,7 +315,7 @@ impl Participant {
             name,
             created: Utc::now(),
             state: state_receiver,
-            _participant_task_guard: task_guard,
+            participant_task: task_guard,
             sender,
             close_strategy: CloseStrategy::DriverCloseOnly,
         })
@@ -279,24 +327,19 @@ fn spawn_session<S>(
     receiver: UnboundedReceiver<ParticipantMessage>,
     log_sender: UnboundedSender<ParticipantLogMessage>,
     session: S,
-) -> (watch::Receiver<ParticipantState>, Arc<DropGuard>)
+) -> (watch::Receiver<ParticipantState>, ParticipantTaskControl)
 where
     S: ParticipantDriverSession + 'static,
 {
     let task_cancellation_token = CancellationToken::new();
+    let task_token = task_cancellation_token.clone();
     let task_cancellation_guard = task_cancellation_token.clone().drop_guard();
     let (state_sender, state_receiver) = watch::channel(Default::default());
     let task_sender_for_task = log_sender.clone();
 
-    tokio::task::spawn(async move {
-        let result = run_participant_runtime(
-            receiver,
-            log_sender.clone(),
-            state_sender,
-            session,
-            task_cancellation_token.clone(),
-        )
-        .await;
+    let handle = tokio::task::spawn(async move {
+        let result =
+            run_participant_runtime(receiver, log_sender.clone(), state_sender, session, task_token.clone()).await;
 
         if let Err(err) = result {
             error!(participant = %name, "Failed to create participant: {err}");
@@ -315,15 +358,35 @@ where
         ));
     });
 
-    (state_receiver, Arc::new(task_cancellation_guard))
+    (
+        state_receiver,
+        ParticipantTaskControl::new(task_cancellation_token, task_cancellation_guard, handle),
+    )
+}
+
+async fn wait_for_close_observed(state: &mut watch::Receiver<ParticipantState>) {
+    let mut saw_running = state.borrow().running;
+
+    loop {
+        let running = state.borrow().running;
+        if running {
+            saw_running = true;
+        } else if saw_running {
+            return;
+        }
+
+        if state.changed().await.is_err() {
+            return;
+        }
+    }
 }
 
 impl Participant {
     pub async fn close(mut self) {
         let initial_state = self.state.borrow().clone();
         if !initial_state.running {
-            debug!(participant = %self.name, "Already closed the browser");
-            return;
+            debug!(participant = %self.name, "Closing participant before it reported running");
+            self.participant_task.cancel();
         }
 
         if self.close_strategy == CloseStrategy::LeaveBeforeClose && initial_state.joined {
@@ -354,15 +417,11 @@ impl Participant {
             loop {
                 match timeout(
                     PARTICIPANT_CLOSE_PROGRESS_INTERVAL,
-                    self.state.wait_for(|state| !state.running),
+                    wait_for_close_observed(&mut self.state),
                 )
                 .await
                 {
-                    Ok(Ok(_)) => break,
-                    Ok(Err(err)) => {
-                        error!(participant = %self.name, "Failed to wait for participant to close: {err}");
-                        break;
-                    }
+                    Ok(()) => break,
                     Err(_) => {
                         warn!(participant = %self.name, "Still waiting for participant to close");
                     }
@@ -370,7 +429,10 @@ impl Participant {
             }
         } else {
             error!(participant = %self.name, "Was not able to send ParticipantMessage::Close message");
+            self.participant_task.cancel();
         }
+
+        self.participant_task.wait(&self.name).await;
     }
 
     pub fn join(&self) {
@@ -461,10 +523,7 @@ mod tests {
         DriverTermination,
         ParticipantState,
     };
-    use futures::{
-        future::BoxFuture,
-        FutureExt as _,
-    };
+    use futures::future::BoxFuture;
     use std::{
         future::pending,
         sync::{
@@ -551,7 +610,7 @@ mod tests {
             name: "sim-user".to_string(),
             created: Utc::now(),
             state,
-            _participant_task_guard: task_guard,
+            participant_task: task_guard,
             sender: command_tx,
             close_strategy: CloseStrategy::DriverCloseOnly,
         };
@@ -630,7 +689,7 @@ mod tests {
             name: "sim-user".to_string(),
             created: Utc::now(),
             state,
-            _participant_task_guard: task_guard,
+            participant_task: task_guard,
             sender: command_tx,
             close_strategy: CloseStrategy::DriverCloseOnly,
         };
@@ -652,4 +711,234 @@ mod tests {
         timeout(Duration::from_secs(1), close_task).await.unwrap().unwrap();
         assert!(!state.borrow().running);
     }
+
+    struct CancelGuard {
+        cancel_count: Arc<AtomicUsize>,
+        disarmed: bool,
+    }
+
+    impl CancelGuard {
+        fn new(cancel_count: Arc<AtomicUsize>) -> Self {
+            Self {
+                cancel_count,
+                disarmed: false,
+            }
+        }
+
+        fn disarm(&mut self) {
+            self.disarmed = true;
+        }
+    }
+
+    impl Drop for CancelGuard {
+        fn drop(&mut self) {
+            if !self.disarmed {
+                self.cancel_count.fetch_add(1, Ordering::SeqCst);
+            }
+        }
+    }
+
+    struct BlockingStartDriver {
+        start_rx: Option<oneshot::Receiver<()>>,
+        start_cancel_count: Arc<AtomicUsize>,
+        close_count: Arc<AtomicUsize>,
+    }
+
+    impl ParticipantDriverSession for BlockingStartDriver {
+        fn participant_name(&self) -> &str {
+            "sim-user"
+        }
+
+        fn start(&mut self) -> BoxFuture<'_, Result<()>> {
+            let start_rx = self.start_rx.take().expect("start should be called once");
+            let start_cancel_count = Arc::clone(&self.start_cancel_count);
+            async move {
+                let mut cancel_guard = CancelGuard::new(start_cancel_count);
+                let _ = start_rx.await;
+                cancel_guard.disarm();
+                Ok(())
+            }
+            .boxed()
+        }
+
+        fn handle_command(&mut self, _message: ParticipantMessage) -> BoxFuture<'_, Result<()>> {
+            async move { Ok(()) }.boxed()
+        }
+
+        fn refresh_state(&mut self) -> BoxFuture<'_, Result<ParticipantState>> {
+            async move {
+                Ok(ParticipantState {
+                    username: "sim-user".to_string(),
+                    running: true,
+                    joined: true,
+                    ..Default::default()
+                })
+            }
+            .boxed()
+        }
+
+        fn close(&mut self) -> BoxFuture<'_, Result<()>> {
+            async move {
+                self.close_count.fetch_add(1, Ordering::SeqCst);
+                Ok(())
+            }
+            .boxed()
+        }
+
+        fn wait_for_termination(&mut self) -> BoxFuture<'_, DriverTermination> {
+            async move { pending::<DriverTermination>().await }.boxed()
+        }
+    }
+
+    #[tokio::test]
+    async fn close_does_not_cancel_start_after_running_state_is_published() {
+        let (command_tx, command_rx) = unbounded_channel();
+        let (log_tx, _log_rx) = unbounded_channel();
+        let (start_tx, start_rx) = oneshot::channel();
+        let start_cancel_count = Arc::new(AtomicUsize::new(0));
+        let close_count = Arc::new(AtomicUsize::new(0));
+        let (state, task_guard) = spawn_session(
+            "sim-user".to_string(),
+            command_rx,
+            log_tx,
+            BlockingStartDriver {
+                start_rx: Some(start_rx),
+                start_cancel_count: Arc::clone(&start_cancel_count),
+                close_count: Arc::clone(&close_count),
+            },
+        );
+
+        let participant = Participant {
+            name: "sim-user".to_string(),
+            created: Utc::now(),
+            state: state.clone(),
+            participant_task: task_guard,
+            sender: command_tx,
+            close_strategy: CloseStrategy::DriverCloseOnly,
+        };
+
+        state
+            .clone()
+            .wait_for(|state| state.running)
+            .await
+            .expect("participant should publish running state before start completes");
+
+        let close_task = tokio::spawn(participant.close());
+
+        sleep(PARTICIPANT_CLOSE_PROGRESS_INTERVAL * 2).await;
+        assert!(!close_task.is_finished());
+        assert_eq!(start_cancel_count.load(Ordering::SeqCst), 0);
+        assert_eq!(close_count.load(Ordering::SeqCst), 0);
+
+        start_tx.send(()).unwrap();
+        timeout(Duration::from_secs(1), close_task).await.unwrap().unwrap();
+        assert_eq!(start_cancel_count.load(Ordering::SeqCst), 0);
+        assert_eq!(close_count.load(Ordering::SeqCst), 1);
+        assert!(!state.borrow().running);
+    }
+
+    struct PendingStartDriver {
+        close_count: Arc<AtomicUsize>,
+    }
+
+    impl ParticipantDriverSession for PendingStartDriver {
+        fn participant_name(&self) -> &str {
+            "sim-user"
+        }
+
+        fn start(&mut self) -> BoxFuture<'_, Result<()>> {
+            async move { pending::<Result<()>>().await }.boxed()
+        }
+
+        fn handle_command(&mut self, _message: ParticipantMessage) -> BoxFuture<'_, Result<()>> {
+            async move { Ok(()) }.boxed()
+        }
+
+        fn refresh_state(&mut self) -> BoxFuture<'_, Result<ParticipantState>> {
+            async move {
+                Ok(ParticipantState {
+                    username: "sim-user".to_string(),
+                    running: true,
+                    joined: true,
+                    ..Default::default()
+                })
+            }
+            .boxed()
+        }
+
+        fn close(&mut self) -> BoxFuture<'_, Result<()>> {
+            async move {
+                self.close_count.fetch_add(1, Ordering::SeqCst);
+                Ok(())
+            }
+            .boxed()
+        }
+
+        fn wait_for_termination(&mut self) -> BoxFuture<'_, DriverTermination> {
+            async move { pending::<DriverTermination>().await }.boxed()
+        }
+    }
+
+    #[tokio::test]
+    async fn close_cleans_up_participant_before_running_state_is_published() {
+        let (command_tx, command_rx) = unbounded_channel();
+        let (log_tx, _log_rx) = unbounded_channel();
+        let close_count = Arc::new(AtomicUsize::new(0));
+        let (state, task_guard) = spawn_session(
+            "sim-user".to_string(),
+            command_rx,
+            log_tx,
+            PendingStartDriver {
+                close_count: Arc::clone(&close_count),
+            },
+        );
+
+        let participant = Participant {
+            name: "sim-user".to_string(),
+            created: Utc::now(),
+            state: state.clone(),
+            participant_task: task_guard,
+            sender: command_tx,
+            close_strategy: CloseStrategy::DriverCloseOnly,
+        };
+
+        participant.close().await;
+
+        assert_eq!(close_count.load(Ordering::SeqCst), 1);
+        assert!(!state.borrow().running);
+    }
+
+    #[tokio::test]
+    async fn racing_close_callers_all_wait_for_runtime_task_completion() {
+        let (command_tx, command_rx) = unbounded_channel();
+        drop(command_rx);
+        let (_state_tx, state) = watch::channel(ParticipantState::default());
+        let task_cancellation_token = CancellationToken::new();
+        let task_cancellation_guard = task_cancellation_token.clone().drop_guard();
+        let (release_task_tx, release_task_rx) = oneshot::channel();
+        let task_handle = tokio::spawn(async move {
+            let _ = release_task_rx.await;
+        });
+        let participant_task =
+            ParticipantTaskControl::new(task_cancellation_token, task_cancellation_guard, task_handle);
+        let participant = Participant {
+            name: "sim-user".to_string(),
+            created: Utc::now(),
+            state,
+            participant_task,
+            sender: command_tx,
+            close_strategy: CloseStrategy::DriverCloseOnly,
+        };
+
+        let close_task_one = tokio::spawn(participant.clone().close());
+        let close_task_two = tokio::spawn(participant.close());
+
+        sleep(PARTICIPANT_CLOSE_PROGRESS_INTERVAL * 2).await;
+        assert!(!close_task_one.is_finished());
+        assert!(!close_task_two.is_finished());
+
+        release_task_tx.send(()).unwrap();
+        timeout(Duration::from_secs(1), close_task_one).await.unwrap().unwrap();
+        timeout(Duration::from_secs(1), close_task_two).await.unwrap().unwrap();
+    }
 }
diff --git a/src/headless.rs b/src/headless.rs
index 8a0f466..88d8b79 100644
--- a/src/headless.rs
+++ b/src/headless.rs
@@ -94,13 +94,25 @@ pub async fn run(args: HeadlessArgs, filter: EnvFilter) -> Result<i32> {
     let participant_configs = build_participant_configs(global_config.clone(), &args.participants)?;
     let store = client_simulator_browser::participant::ParticipantStore::new(global_config.data_dir());
 
-    for config in &participant_configs {
-        store.spawn(config).context("Failed to spawn participant")?;
-    }
+    spawn_participants_or_shutdown(&store, &participant_configs).await?;
 
     Ok(wait_for_exit(store).await)
 }
 
+async fn spawn_participants_or_shutdown(
+    store: &client_simulator_browser::participant::ParticipantStore,
+    participant_configs: &[Config],
+) -> Result<()> {
+    for config in participant_configs {
+        if let Err(err) = store.spawn(config).context("Failed to spawn participant") {
+            store.shutdown_all().await;
+            return Err(err);
+        }
+    }
+
+    Ok(())
+}
+
 fn apply_cli_overrides(config: &mut Config, args: &HeadlessArgs) {
     if let Some(url) = &args.url {
         config.url = Some(url.clone());
@@ -524,6 +536,32 @@ mod tests {
         assert_eq!(code, 130);
     }
 
+    #[tokio::test]
+    async fn spawn_participants_shuts_down_already_spawned_on_later_spawn_error() {
+        let data_dir = unique_test_data_dir();
+        fs::create_dir_all(&data_dir).expect("create temp data dir");
+        let store = client_simulator_browser::participant::ParticipantStore::new(&data_dir);
+        let configs = vec![
+            Config {
+                url: Some(Url::parse("https://example.com/lite/first").expect("valid url")),
+                backend: ParticipantBackendKind::RemoteStub,
+                ..Default::default()
+            },
+            Config {
+                url: None,
+                backend: ParticipantBackendKind::RemoteStub,
+                ..Default::default()
+            },
+        ];
+
+        let error = spawn_participants_or_shutdown(&store, &configs)
+            .await
+            .expect_err("second participant should fail to spawn");
+
+        assert!(error.to_string().contains("Failed to spawn participant"));
+        assert!(store.is_empty());
+    }
+
     fn unique_test_data_dir() -> PathBuf {
         let timestamp = SystemTime::now()
             .duration_since(UNIX_EPOCH)