playwright-ruby-client 0.5.9 → 0.6.3

data/lib/playwright_api/page.rb

@@ -1,66 +1,15 @@
 module Playwright
   # - extends: [EventEmitter]
-  # 
+  #
   # Page provides methods to interact with a single tab in a `Browser`, or an
   # [extension background page](https://developer.chrome.com/extensions/background_pages) in Chromium. One `Browser`
   # instance might have multiple `Page` instances.
-  # 
+  #
   # This example creates a page, navigates it to a URL, and then saves a screenshot:
-  # 
   #
-  # ```js
-  # const { webkit } = require('playwright');  // Or 'chromium' or 'firefox'.
-  # 
-  # (async () => {
-  #   const browser = await webkit.launch();
-  #   const context = await browser.newContext();
-  #   const page = await context.newPage();
-  #   await page.goto('https://example.com');
-  #   await page.screenshot({path: 'screenshot.png'});
-  #   await browser.close();
-  # })();
-  # ```
-  # 
-  # ```java
-  # import com.microsoft.playwright.*;
-  # 
-  # public class Example {
-  #   public static void main(String[] args) {
-  #     try (Playwright playwright = Playwright.create()) {
-  #       BrowserType webkit = playwright.webkit();
-  #       Browser browser = webkit.launch();
-  #       BrowserContext context = browser.newContext();
-  #       Page page = context.newPage();
-  #       page.navigate("https://example.com");
-  #       page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("screenshot.png")));
-  #       browser.close();
-  #     }
-  #   }
-  # }
-  # ```
-  # 
-  # ```python async
-  # import asyncio
-  # from playwright.async_api import async_playwright
-  # 
-  # async def run(playwright):
-  #     webkit = playwright.webkit
-  #     browser = await webkit.launch()
-  #     context = await browser.new_context()
-  #     page = await context.new_page()
-  #     await page.goto("https://example.com")
-  #     await page.screenshot(path="screenshot.png")
-  #     await browser.close()
-  # 
-  # async def main():
-  #     async with async_playwright() as playwright:
-  #         await run(playwright)
-  # asyncio.run(main())
-  # ```
-  # 
   # ```python sync
   # from playwright.sync_api import sync_playwright
-  # 
+  #
   # def run(playwright):
   #     webkit = playwright.webkit
   #     browser = webkit.launch()
@@ -69,51 +18,23 @@ module Playwright
   #     page.goto("https://example.com")
   #     page.screenshot(path="screenshot.png")
   #     browser.close()
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
-  # 
+  #
   # The Page class emits various events (described below) which can be handled using any of Node's native
   # [`EventEmitter`](https://nodejs.org/api/events.html#events_class_eventemitter) methods, such as `on`, `once` or
   # `removeListener`.
-  # 
+  #
   # This example logs a message for a single page `load` event:
-  # 
   #
-  # ```js
-  # page.once('load', () => console.log('Page loaded!'));
-  # ```
-  # 
-  # ```java
-  # page.onLoad(p -> System.out.println("Page loaded!"));
-  # ```
-  # 
   # ```py
   # page.once("load", lambda: print("page loaded!"))
   # ```
-  # 
+  #
   # To unsubscribe from events use the `removeListener` method:
-  # 
   #
-  # ```js
-  # function logRequest(interceptedRequest) {
-  #   console.log('A request was made:', interceptedRequest.url());
-  # }
-  # page.on('request', logRequest);
-  # // Sometime later...
-  # page.removeListener('request', logRequest);
-  # ```
-  # 
-  # ```java
-  # Consumer<Request> logRequest = interceptedRequest -> {
-  #   System.out.println("A request was made: " + interceptedRequest.url());
-  # };
-  # page.onRequest(logRequest);
-  # // Sometime later...
-  # page.offRequest(logRequest);
-  # ```
-  # 
   # ```py
   # def log_request(intercepted_request):
   #     print("a request was made:", intercepted_request.url)
@@ -143,39 +64,17 @@ module Playwright
     # - Whenever the page is navigated.
     # - Whenever the child frame is attached or navigated. In this case, the script is evaluated in the context of the newly
     #   attached frame.
-    # 
+    #
     # The script is evaluated after the document was created but before any of its scripts were run. This is useful to amend
     # the JavaScript environment, e.g. to seed `Math.random`.
-    # 
-    # An example of overriding `Math.random` before the page loads:
-    # 
     #
-    # ```js browser
-    # // preload.js
-    # Math.random = () => 42;
-    # ```
-    # 
+    # An example of overriding `Math.random` before the page loads:
     #
-    # ```js
-    # // In your playwright script, assuming the preload.js file is in same directory
-    # await page.addInitScript({ path: './preload.js' });
-    # ```
-    # 
-    # ```java
-    # // In your playwright script, assuming the preload.js file is in same directory
-    # page.addInitScript(Paths.get("./preload.js"));
-    # ```
-    # 
-    # ```python async
-    # # in your playwright script, assuming the preload.js file is in same directory
-    # await page.add_init_script(path="./preload.js")
-    # ```
-    # 
     # ```python sync
     # # in your playwright script, assuming the preload.js file is in same directory
     # page.add_init_script(path="./preload.js")
     # ```
-    # 
+    #
     # > NOTE: The order of evaluation of multiple scripts installed via [`method: BrowserContext.addInitScript`] and
     # [`method: Page.addInitScript`] is not defined.
     def add_init_script(path: nil, script: nil)
@@ -184,7 +83,7 @@ module Playwright
 
     # Adds a `<script>` tag into the page with the desired url or content. Returns the added tag when the script's onload
     # fires or when the script content was injected into frame.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.addScriptTag`].
     def add_script_tag(content: nil, path: nil, type: nil, url: nil)
       wrap_impl(@impl.add_script_tag(content: unwrap_impl(content), path: unwrap_impl(path), type: unwrap_impl(type), url: unwrap_impl(url)))
@@ -192,7 +91,7 @@ module Playwright
 
     # Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the
     # content. Returns the added tag when the stylesheet's onload fires or when the CSS content was injected into frame.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.addStyleTag`].
     def add_style_tag(content: nil, path: nil, url: nil)
       wrap_impl(@impl.add_style_tag(content: unwrap_impl(content), path: unwrap_impl(path), url: unwrap_impl(url)))
@@ -213,18 +112,19 @@ module Playwright
     # 1. Use [`property: Page.mouse`] to click in the center of the element.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
     # 1. Ensure that the element is now checked. If not, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.check`].
     def check(
           selector,
           force: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
-      wrap_impl(@impl.check(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
+          timeout: nil,
+          trial: nil)
+      wrap_impl(@impl.check(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
     end
 
     # This method clicks an element matching `selector` by performing the following steps:
@@ -234,10 +134,10 @@ module Playwright
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.mouse`] to click in the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.click`].
     def click(
           selector,
@@ -248,15 +148,16 @@ module Playwright
           modifiers: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
-      wrap_impl(@impl.click(unwrap_impl(selector), button: unwrap_impl(button), clickCount: unwrap_impl(clickCount), delay: unwrap_impl(delay), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
+          timeout: nil,
+          trial: nil)
+      wrap_impl(@impl.click(unwrap_impl(selector), button: unwrap_impl(button), clickCount: unwrap_impl(clickCount), delay: unwrap_impl(delay), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
     end
 
     # If `runBeforeUnload` is `false`, does not run any unload handlers and waits for the page to be closed. If
     # `runBeforeUnload` is `true` the method will run unload handlers, but will **not** wait for the page to close.
-    # 
+    #
     # By default, `page.close()` **does not** run `beforeunload` handlers.
-    # 
+    #
     # > NOTE: if `runBeforeUnload` is passed as true, a `beforeunload` dialog might be summoned and should be handled manually
     # via [`event: Page.dialog`] event.
     def close(runBeforeUnload: nil)
@@ -281,12 +182,12 @@ module Playwright
     # 1. Use [`property: Page.mouse`] to double click in the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if the
     #    first click of the `dblclick()` triggers a navigation event, this method will throw.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    # 
+    #
     # > NOTE: `page.dblclick()` dispatches two `click` events and a single `dblclick` event.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.dblclick`].
     def dblclick(
           selector,
@@ -296,34 +197,22 @@ module Playwright
           modifiers: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
-      wrap_impl(@impl.dblclick(unwrap_impl(selector), button: unwrap_impl(button), delay: unwrap_impl(delay), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
+          timeout: nil,
+          trial: nil)
+      wrap_impl(@impl.dblclick(unwrap_impl(selector), button: unwrap_impl(button), delay: unwrap_impl(delay), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
     end
 
     # The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the element,
     # `click` is dispatched. This is equivalent to calling
     # [element.click()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).
-    # 
     #
-    # ```js
-    # await page.dispatchEvent('button#submit', 'click');
-    # ```
-    # 
-    # ```java
-    # page.dispatchEvent("button#submit", "click");
-    # ```
-    # 
-    # ```python async
-    # await page.dispatch_event("button#submit", "click")
-    # ```
-    # 
     # ```python sync
     # page.dispatch_event("button#submit", "click")
     # ```
-    # 
+    #
     # Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
     # and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
-    # 
+    #
     # Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:
     # - [DragEvent](https://developer.mozilla.org/en-US/docs/Web/API/DragEvent/DragEvent)
     # - [FocusEvent](https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent)
@@ -332,30 +221,9 @@ module Playwright
     # - [PointerEvent](https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/PointerEvent)
     # - [TouchEvent](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/TouchEvent)
     # - [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)
-    # 
+    #
     # You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
-    # 
     #
-    # ```js
-    # // Note you can only create DataTransfer in Chromium and Firefox
-    # const dataTransfer = await page.evaluateHandle(() => new DataTransfer());
-    # await page.dispatchEvent('#source', 'dragstart', { dataTransfer });
-    # ```
-    # 
-    # ```java
-    # // Note you can only create DataTransfer in Chromium and Firefox
-    # JSHandle dataTransfer = page.evaluateHandle("() => new DataTransfer()");
-    # Map<String, Object> arg = new HashMap<>();
-    # arg.put("dataTransfer", dataTransfer);
-    # page.dispatchEvent("#source", "dragstart", arg);
-    # ```
-    # 
-    # ```python async
-    # # note you can only create data_transfer in chromium and firefox
-    # data_transfer = await page.evaluate_handle("new DataTransfer()")
-    # await page.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
-    # ```
-    # 
     # ```python sync
     # # note you can only create data_transfer in chromium and firefox
     # data_transfer = page.evaluate_handle("new DataTransfer()")
@@ -365,114 +233,28 @@ module Playwright
       wrap_impl(@impl.dispatch_event(unwrap_impl(selector), unwrap_impl(type), eventInit: unwrap_impl(eventInit), timeout: unwrap_impl(timeout)))
     end
 
+    # This method changes the `CSS media type` through the `media` argument, and/or the `'prefers-colors-scheme'` media
+    # feature, using the `colorScheme` argument.
     #
-    # ```js
-    # await page.evaluate(() => matchMedia('screen').matches);
-    # // → true
-    # await page.evaluate(() => matchMedia('print').matches);
-    # // → false
-    # 
-    # await page.emulateMedia({ media: 'print' });
-    # await page.evaluate(() => matchMedia('screen').matches);
-    # // → false
-    # await page.evaluate(() => matchMedia('print').matches);
-    # // → true
-    # 
-    # await page.emulateMedia({});
-    # await page.evaluate(() => matchMedia('screen').matches);
-    # // → true
-    # await page.evaluate(() => matchMedia('print').matches);
-    # // → false
-    # ```
-    # 
-    # ```java
-    # page.evaluate("() => matchMedia('screen').matches");
-    # // → true
-    # page.evaluate("() => matchMedia('print').matches");
-    # // → false
-    # 
-    # page.emulateMedia(new Page.EmulateMediaOptions().setMedia(Media.PRINT));
-    # page.evaluate("() => matchMedia('screen').matches");
-    # // → false
-    # page.evaluate("() => matchMedia('print').matches");
-    # // → true
-    # 
-    # page.emulateMedia(new Page.EmulateMediaOptions());
-    # page.evaluate("() => matchMedia('screen').matches");
-    # // → true
-    # page.evaluate("() => matchMedia('print').matches");
-    # // → false
-    # ```
-    # 
-    # ```python async
-    # await page.evaluate("matchMedia('screen').matches")
-    # # → True
-    # await page.evaluate("matchMedia('print').matches")
-    # # → False
-    # 
-    # await page.emulate_media(media="print")
-    # await page.evaluate("matchMedia('screen').matches")
-    # # → False
-    # await page.evaluate("matchMedia('print').matches")
-    # # → True
-    # 
-    # await page.emulate_media()
-    # await page.evaluate("matchMedia('screen').matches")
-    # # → True
-    # await page.evaluate("matchMedia('print').matches")
-    # # → False
-    # ```
-    # 
     # ```python sync
     # page.evaluate("matchMedia('screen').matches")
     # # → True
     # page.evaluate("matchMedia('print').matches")
     # # → False
-    # 
+    #
     # page.emulate_media(media="print")
     # page.evaluate("matchMedia('screen').matches")
     # # → False
     # page.evaluate("matchMedia('print').matches")
     # # → True
-    # 
+    #
     # page.emulate_media()
     # page.evaluate("matchMedia('screen').matches")
     # # → True
     # page.evaluate("matchMedia('print').matches")
     # # → False
     # ```
-    # 
-    #
-    # ```js
-    # await page.emulateMedia({ colorScheme: 'dark' });
-    # await page.evaluate(() => matchMedia('(prefers-color-scheme: dark)').matches);
-    # // → true
-    # await page.evaluate(() => matchMedia('(prefers-color-scheme: light)').matches);
-    # // → false
-    # await page.evaluate(() => matchMedia('(prefers-color-scheme: no-preference)').matches);
-    # // → false
-    # ```
-    # 
-    # ```java
-    # page.emulateMedia(new Page.EmulateMediaOptions().setColorScheme(ColorScheme.DARK));
-    # page.evaluate("() => matchMedia('(prefers-color-scheme: dark)').matches");
-    # // → true
-    # page.evaluate("() => matchMedia('(prefers-color-scheme: light)').matches");
-    # // → false
-    # page.evaluate("() => matchMedia('(prefers-color-scheme: no-preference)').matches");
-    # // → false
-    # ```
-    # 
-    # ```python async
-    # await page.emulate_media(color_scheme="dark")
-    # await page.evaluate("matchMedia('(prefers-color-scheme: dark)').matches")
-    # # → True
-    # await page.evaluate("matchMedia('(prefers-color-scheme: light)').matches")
-    # # → False
-    # await page.evaluate("matchMedia('(prefers-color-scheme: no-preference)').matches")
-    # # → False
-    # ```
-    # 
+    #
     # ```python sync
     # page.emulate_media(color_scheme="dark")
     # page.evaluate("matchMedia('(prefers-color-scheme: dark)').matches")
@@ -481,43 +263,24 @@ module Playwright
     # # → False
     # page.evaluate("matchMedia('(prefers-color-scheme: no-preference)').matches")
     # ```
-    def emulate_media(colorScheme: nil, media: nil)
-      wrap_impl(@impl.emulate_media(colorScheme: unwrap_impl(colorScheme), media: unwrap_impl(media)))
+    def emulate_media(colorScheme: nil, media: nil, reducedMotion: nil)
+      wrap_impl(@impl.emulate_media(colorScheme: unwrap_impl(colorScheme), media: unwrap_impl(media), reducedMotion: unwrap_impl(reducedMotion)))
     end
 
     # The method finds an element matching the specified selector within the page and passes it as a first argument to
     # `expression`. If no elements match the selector, the method throws an error. Returns the value of `expression`.
-    # 
+    #
     # If `expression` returns a [Promise], then [`method: Page.evalOnSelector`] would wait for the promise to resolve and
     # return its value.
-    # 
+    #
     # Examples:
-    # 
     #
-    # ```js
-    # const searchValue = await page.$eval('#search', el => el.value);
-    # const preloadHref = await page.$eval('link[rel=preload]', el => el.href);
-    # const html = await page.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');
-    # ```
-    # 
-    # ```java
-    # String searchValue = (String) page.evalOnSelector("#search", "el => el.value");
-    # String preloadHref = (String) page.evalOnSelector("link[rel=preload]", "el => el.href");
-    # String html = (String) page.evalOnSelector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello");
-    # ```
-    # 
-    # ```python async
-    # search_value = await page.eval_on_selector("#search", "el => el.value")
-    # preload_href = await page.eval_on_selector("link[rel=preload]", "el => el.href")
-    # html = await page.eval_on_selector(".main-container", "(e, suffix) => e.outer_html + suffix", "hello")
-    # ```
-    # 
     # ```python sync
     # search_value = page.eval_on_selector("#search", "el => el.value")
     # preload_href = page.eval_on_selector("link[rel=preload]", "el => el.href")
     # html = page.eval_on_selector(".main-container", "(e, suffix) => e.outer_html + suffix", "hello")
     # ```
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.evalOnSelector`].
     def eval_on_selector(selector, expression, arg: nil)
       wrap_impl(@impl.eval_on_selector(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
@@ -525,25 +288,12 @@ module Playwright
 
     # The method finds all elements matching the specified selector within the page and passes an array of matched elements as
     # a first argument to `expression`. Returns the result of `expression` invocation.
-    # 
+    #
     # If `expression` returns a [Promise], then [`method: Page.evalOnSelectorAll`] would wait for the promise to resolve and
     # return its value.
-    # 
+    #
     # Examples:
-    # 
     #
-    # ```js
-    # const divCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);
-    # ```
-    # 
-    # ```java
-    # boolean divCounts = (boolean) page.evalOnSelectorAll("div", "(divs, min) => divs.length >= min", 10);
-    # ```
-    # 
-    # ```python async
-    # div_counts = await page.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
-    # ```
-    # 
     # ```python sync
     # div_counts = page.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
     # ```
@@ -552,170 +302,63 @@ module Playwright
     end
 
     # Returns the value of the `expression` invocation.
-    # 
+    #
     # If the function passed to the [`method: Page.evaluate`] returns a [Promise], then [`method: Page.evaluate`] would wait
     # for the promise to resolve and return its value.
-    # 
+    #
     # If the function passed to the [`method: Page.evaluate`] returns a non-[Serializable] value, then
     # [`method: Page.evaluate`] resolves to `undefined`. Playwright also supports transferring some additional values that are
     # not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
-    # 
+    #
     # Passing argument to `expression`:
-    # 
     #
-    # ```js
-    # const result = await page.evaluate(([x, y]) => {
-    #   return Promise.resolve(x * y);
-    # }, [7, 8]);
-    # console.log(result); // prints "56"
-    # ```
-    # 
-    # ```java
-    # Object result = page.evaluate("([x, y]) => {\n" +
-    #   "  return Promise.resolve(x * y);\n" +
-    #   "}", Arrays.asList(7, 8));
-    # System.out.println(result); // prints "56"
-    # ```
-    # 
-    # ```python async
-    # result = await page.evaluate("([x, y]) => Promise.resolve(x * y)", [7, 8])
-    # print(result) # prints "56"
-    # ```
-    # 
     # ```python sync
     # result = page.evaluate("([x, y]) => Promise.resolve(x * y)", [7, 8])
     # print(result) # prints "56"
     # ```
-    # 
+    #
     # A string can also be passed in instead of a function:
-    # 
     #
-    # ```js
-    # console.log(await page.evaluate('1 + 2')); // prints "3"
-    # const x = 10;
-    # console.log(await page.evaluate(`1 + ${x}`)); // prints "11"
-    # ```
-    # 
-    # ```java
-    # System.out.println(page.evaluate("1 + 2")); // prints "3"
-    # ```
-    # 
-    # ```python async
-    # print(await page.evaluate("1 + 2")) # prints "3"
-    # x = 10
-    # print(await page.evaluate(f"1 + {x}")) # prints "11"
-    # ```
-    # 
     # ```python sync
     # print(page.evaluate("1 + 2")) # prints "3"
     # x = 10
     # print(page.evaluate(f"1 + {x}")) # prints "11"
     # ```
-    # 
+    #
     # `ElementHandle` instances can be passed as an argument to the [`method: Page.evaluate`]:
-    # 
     #
-    # ```js
-    # const bodyHandle = await page.$('body');
-    # const html = await page.evaluate(([body, suffix]) => body.innerHTML + suffix, [bodyHandle, 'hello']);
-    # await bodyHandle.dispose();
-    # ```
-    # 
-    # ```java
-    # ElementHandle bodyHandle = page.querySelector("body");
-    # String html = (String) page.evaluate("([body, suffix]) => body.innerHTML + suffix", Arrays.asList(bodyHandle, "hello"));
-    # bodyHandle.dispose();
-    # ```
-    # 
-    # ```python async
-    # body_handle = await page.query_selector("body")
-    # html = await page.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
-    # await body_handle.dispose()
-    # ```
-    # 
     # ```python sync
     # body_handle = page.query_selector("body")
     # html = page.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
     # body_handle.dispose()
     # ```
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.evaluate`].
     def evaluate(expression, arg: nil)
       wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
     # Returns the value of the `expression` invocation as a `JSHandle`.
-    # 
+    #
     # The only difference between [`method: Page.evaluate`] and [`method: Page.evaluateHandle`] is that
     # [`method: Page.evaluateHandle`] returns `JSHandle`.
-    # 
+    #
     # If the function passed to the [`method: Page.evaluateHandle`] returns a [Promise], then [`method: Page.evaluateHandle`]
     # would wait for the promise to resolve and return its value.
-    # 
     #
-    # ```js
-    # const aWindowHandle = await page.evaluateHandle(() => Promise.resolve(window));
-    # aWindowHandle; // Handle for the window object.
-    # ```
-    # 
-    # ```java
-    # // Handle for the window object.
-    # JSHandle aWindowHandle = page.evaluateHandle("() => Promise.resolve(window)");
-    # ```
-    # 
-    # ```python async
-    # a_window_handle = await page.evaluate_handle("Promise.resolve(window)")
-    # a_window_handle # handle for the window object.
-    # ```
-    # 
     # ```python sync
     # a_window_handle = page.evaluate_handle("Promise.resolve(window)")
     # a_window_handle # handle for the window object.
     # ```
-    # 
+    #
     # A string can also be passed in instead of a function:
-    # 
     #
-    # ```js
-    # const aHandle = await page.evaluateHandle('document'); // Handle for the 'document'
-    # ```
-    # 
-    # ```java
-    # JSHandle aHandle = page.evaluateHandle("document"); // Handle for the "document".
-    # ```
-    # 
-    # ```python async
-    # a_handle = await page.evaluate_handle("document") # handle for the "document"
-    # ```
-    # 
     # ```python sync
     # a_handle = page.evaluate_handle("document") # handle for the "document"
     # ```
-    # 
+    #
     # `JSHandle` instances can be passed as an argument to the [`method: Page.evaluateHandle`]:
-    # 
     #
-    # ```js
-    # const aHandle = await page.evaluateHandle(() => document.body);
-    # const resultHandle = await page.evaluateHandle(body => body.innerHTML, aHandle);
-    # console.log(await resultHandle.jsonValue());
-    # await resultHandle.dispose();
-    # ```
-    # 
-    # ```java
-    # JSHandle aHandle = page.evaluateHandle("() => document.body");
-    # JSHandle resultHandle = page.evaluateHandle("([body, suffix]) => body.innerHTML + suffix", Arrays.asList(aHandle, "hello"));
-    # System.out.println(resultHandle.jsonValue());
-    # resultHandle.dispose();
-    # ```
-    # 
-    # ```python async
-    # a_handle = await page.evaluate_handle("document.body")
-    # result_handle = await page.evaluate_handle("body => body.innerHTML", a_handle)
-    # print(await result_handle.json_value())
-    # await result_handle.dispose()
-    # ```
-    # 
     # ```python sync
     # a_handle = page.evaluate_handle("document.body")
     # result_handle = page.evaluate_handle("body => body.innerHTML", a_handle)
@@ -729,92 +372,19 @@ module Playwright
     # The method adds a function called `name` on the `window` object of every frame in this page. When called, the function
     # executes `callback` and returns a [Promise] which resolves to the return value of `callback`. If the `callback` returns
     # a [Promise], it will be awaited.
-    # 
+    #
     # The first argument of the `callback` function contains information about the caller: `{ browserContext: BrowserContext,
     # page: Page, frame: Frame }`.
-    # 
+    #
     # See [`method: BrowserContext.exposeBinding`] for the context-wide version.
-    # 
+    #
     # > NOTE: Functions installed via [`method: Page.exposeBinding`] survive navigations.
-    # 
+    #
     # An example of exposing page URL to all frames in a page:
-    # 
-    #
-    # ```js
-    # const { webkit } = require('playwright');  // Or 'chromium' or 'firefox'.
-    # 
-    # (async () => {
-    #   const browser = await webkit.launch({ headless: false });
-    #   const context = await browser.newContext();
-    #   const page = await context.newPage();
-    #   await page.exposeBinding('pageURL', ({ page }) => page.url());
-    #   await page.setContent(`
-    #     <script>
-    #       async function onClick() {
-    #         document.querySelector('div').textContent = await window.pageURL();
-    #       }
-    #     </script>
-    #     <button onclick="onClick()">Click me</button>
-    #     <div></div>
-    #   `);
-    #   await page.click('button');
-    # })();
-    # ```
-    # 
-    # ```java
-    # import com.microsoft.playwright.*;
-    # 
-    # public class Example {
-    #   public static void main(String[] args) {
-    #     try (Playwright playwright = Playwright.create()) {
-    #       BrowserType webkit = playwright.webkit();
-    #       Browser browser = webkit.launch({ headless: false });
-    #       BrowserContext context = browser.newContext();
-    #       Page page = context.newPage();
-    #       page.exposeBinding("pageURL", (source, args) -> source.page().url());
-    #       page.setContent("<script>\n" +
-    #         "  async function onClick() {\n" +
-    #         "    document.querySelector('div').textContent = await window.pageURL();\n" +
-    #         "  }\n" +
-    #         "</script>\n" +
-    #         "<button onclick=\"onClick()\">Click me</button>\n" +
-    #         "<div></div>");
-    #       page.click("button");
-    #     }
-    #   }
-    # }
-    # ```
-    # 
-    # ```python async
-    # import asyncio
-    # from playwright.async_api import async_playwright
-    # 
-    # async def run(playwright):
-    #     webkit = playwright.webkit
-    #     browser = await webkit.launch(headless=false)
-    #     context = await browser.new_context()
-    #     page = await context.new_page()
-    #     await page.expose_binding("pageURL", lambda source: source["page"].url)
-    #     await page.set_content("""
-    #     <script>
-    #       async function onClick() {
-    #         document.querySelector('div').textContent = await window.pageURL();
-    #       }
-    #     </script>
-    #     <button onclick="onClick()">Click me</button>
-    #     <div></div>
-    #     """)
-    #     await page.click("button")
-    # 
-    # async def main():
-    #     async with async_playwright() as playwright:
-    #         await run(playwright)
-    # asyncio.run(main())
-    # ```
-    # 
+    #
     # ```python sync
     # from playwright.sync_api import sync_playwright
-    # 
+    #
     # def run(playwright):
     #     webkit = playwright.webkit
     #     browser = webkit.launch(headless=false)
@@ -831,59 +401,17 @@ module Playwright
     #     <div></div>
     #     """)
     #     page.click("button")
-    # 
+    #
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
-    # 
+    #
     # An example of passing an element handle:
-    # 
     #
-    # ```js
-    # await page.exposeBinding('clicked', async (source, element) => {
-    #   console.log(await element.textContent());
-    # }, { handle: true });
-    # await page.setContent(`
-    #   <script>
-    #     document.addEventListener('click', event => window.clicked(event.target));
-    #   </script>
-    #   <div>Click me</div>
-    #   <div>Or click me</div>
-    # `);
-    # ```
-    # 
-    # ```java
-    # page.exposeBinding("clicked", (source, args) -> {
-    #   ElementHandle element = (ElementHandle) args[0];
-    #   System.out.println(element.textContent());
-    #   return null;
-    # }, new Page.ExposeBindingOptions().setHandle(true));
-    # page.setContent("" +
-    #   "<script>\n" +
-    #   "  document.addEventListener('click', event => window.clicked(event.target));\n" +
-    #   "</script>\n" +
-    #   "<div>Click me</div>\n" +
-    #   "<div>Or click me</div>\n");
-    # ```
-    # 
-    # ```python async
-    # async def print(source, element):
-    #     print(await element.text_content())
-    # 
-    # await page.expose_binding("clicked", print, handle=true)
-    # await page.set_content("""
-    #   <script>
-    #     document.addEventListener('click', event => window.clicked(event.target));
-    #   </script>
-    #   <div>Click me</div>
-    #   <div>Or click me</div>
-    # """)
-    # ```
-    # 
     # ```python sync
     # def print(source, element):
     #     print(element.text_content())
-    # 
+    #
     # page.expose_binding("clicked", print, handle=true)
     # page.set_content("""
     #   <script>
@@ -899,134 +427,41 @@ module Playwright
 
     # The method adds a function called `name` on the `window` object of every frame in the page. When called, the function
     # executes `callback` and returns a [Promise] which resolves to the return value of `callback`.
-    # 
+    #
     # If the `callback` returns a [Promise], it will be awaited.
-    # 
+    #
     # See [`method: BrowserContext.exposeFunction`] for context-wide exposed function.
-    # 
+    #
     # > NOTE: Functions installed via [`method: Page.exposeFunction`] survive navigations.
-    # 
-    # An example of adding an `sha1` function to the page:
-    # 
-    #
-    # ```js
-    # const { webkit } = require('playwright');  // Or 'chromium' or 'firefox'.
-    # const crypto = require('crypto');
-    # 
-    # (async () => {
-    #   const browser = await webkit.launch({ headless: false });
-    #   const page = await browser.newPage();
-    #   await page.exposeFunction('sha1', text => crypto.createHash('sha1').update(text).digest('hex'));
-    #   await page.setContent(`
-    #     <script>
-    #       async function onClick() {
-    #         document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');
-    #       }
-    #     </script>
-    #     <button onclick="onClick()">Click me</button>
-    #     <div></div>
-    #   `);
-    #   await page.click('button');
-    # })();
-    # ```
-    # 
-    # ```java
-    # import com.microsoft.playwright.*;
-    # 
-    # import java.nio.charset.StandardCharsets;
-    # import java.security.MessageDigest;
-    # import java.security.NoSuchAlgorithmException;
-    # import java.util.Base64;
-    # 
-    # public class Example {
-    #   public static void main(String[] args) {
-    #     try (Playwright playwright = Playwright.create()) {
-    #       BrowserType webkit = playwright.webkit();
-    #       Browser browser = webkit.launch({ headless: false });
-    #       Page page = browser.newPage();
-    #       page.exposeFunction("sha1", args -> {
-    #         String text = (String) args[0];
-    #         MessageDigest crypto;
-    #         try {
-    #           crypto = MessageDigest.getInstance("SHA-1");
-    #         } catch (NoSuchAlgorithmException e) {
-    #           return null;
-    #         }
-    #         byte[] token = crypto.digest(text.getBytes(StandardCharsets.UTF_8));
-    #         return Base64.getEncoder().encodeToString(token);
-    #       });
-    #       page.setContent("<script>\n" +
-    #         "  async function onClick() {\n" +
-    #         "    document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');\n" +
-    #         "  }\n" +
-    #         "</script>\n" +
-    #         "<button onclick=\"onClick()\">Click me</button>\n" +
-    #         "<div></div>\n");
-    #       page.click("button");
-    #     }
-    #   }
-    # }
-    # ```
-    # 
-    # ```python async
-    # import asyncio
-    # import hashlib
-    # from playwright.async_api import async_playwright
-    # 
-    # async def sha1(text):
-    #     m = hashlib.sha1()
-    #     m.update(bytes(text, "utf8"))
-    #     return m.hexdigest()
-    # 
-    # 
-    # async def run(playwright):
-    #     webkit = playwright.webkit
-    #     browser = await webkit.launch(headless=False)
-    #     page = await browser.new_page()
-    #     await page.expose_function("sha1", sha1)
-    #     await page.set_content("""
-    #         <script>
-    #           async function onClick() {
-    #             document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');
-    #           }
-    #         </script>
-    #         <button onclick="onClick()">Click me</button>
-    #         <div></div>
-    #     """)
-    #     await page.click("button")
-    # 
-    # async def main():
-    #     async with async_playwright() as playwright:
-    #         await run(playwright)
-    # asyncio.run(main())
-    # ```
-    # 
+    #
+    # An example of adding a `sha256` function to the page:
+    #
     # ```python sync
     # import hashlib
     # from playwright.sync_api import sync_playwright
-    # 
-    # def sha1(text):
-    #     m = hashlib.sha1()
+    #
+    # def sha256(text):
+    #     m = hashlib.sha256()
     #     m.update(bytes(text, "utf8"))
     #     return m.hexdigest()
-    # 
-    # 
+    #
+    #
     # def run(playwright):
     #     webkit = playwright.webkit
     #     browser = webkit.launch(headless=False)
     #     page = browser.new_page()
-    #     page.expose_function("sha1", sha1)
+    #     page.expose_function("sha256", sha256)
     #     page.set_content("""
     #         <script>
     #           async function onClick() {
-    #             document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');
+    #             document.querySelector('div').textContent = await window.sha256('PLAYWRIGHT');
     #           }
     #         </script>
     #         <button onclick="onClick()">Click me</button>
     #         <div></div>
     #     """)
     #     page.click("button")
-    # 
+    #
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
@@ -1035,50 +470,35 @@ module Playwright
     end
 
     # This method waits for an element matching `selector`, waits for [actionability](./actionability.md) checks, focuses the
-    # element, fills it and triggers an `input` event after filling. If the element is inside the `<label>` element that has
-    # associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), that control will be
-    # filled instead. If the element to be filled is not an `<input>`, `<textarea>` or `[contenteditable]` element, this
-    # method throws an error. Note that you can pass an empty string to clear the input field.
-    # 
+    # element, fills it and triggers an `input` event after filling. Note that you can pass an empty string to clear the input
+    # field.
+    #
+    # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error.
+    # However, if the element is inside the `<label>` element that has an associated
+    # [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled
+    # instead.
+    #
     # To send fine-grained keyboard events, use [`method: Page.type`].
-    # 
-    # Shortcut for main frame's [`method: Frame.fill`]
+    #
+    # Shortcut for main frame's [`method: Frame.fill`].
     def fill(selector, value, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.fill(unwrap_impl(selector), unwrap_impl(value), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the method
     # waits until a matching element appears in the DOM.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.focus`].
     def focus(selector, timeout: nil)
       wrap_impl(@impl.focus(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns frame matching the specified criteria. Either `name` or `url` must be specified.
-    # 
     #
-    # ```js
-    # const frame = page.frame('frame-name');
-    # ```
-    # 
-    # ```java
-    # Frame frame = page.frame("frame-name");
-    # ```
-    # 
     # ```py
     # frame = page.frame(name="frame-name")
     # ```
-    # 
     #
-    # ```js
-    # const frame = page.frame({ url: /.*domain.*/ });
-    # ```
-    # 
-    # ```java
-    # Frame frame = page.frameByUrl(Pattern.compile(".*domain.*");
-    # ```
-    # 
     # ```py
     # frame = page.frame(url=r".*domain.*")
     # ```
@@ -1098,7 +518,7 @@ module Playwright
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
     # last redirect. If can not go back, returns `null`.
-    # 
+    #
     # Navigate to the previous page in history.
     def go_back(timeout: nil, waitUntil: nil)
       wrap_impl(@impl.go_back(timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
@@ -1106,7 +526,7 @@ module Playwright
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
     # last redirect. If can not go forward, returns `null`.
-    # 
+    #
     # Navigate to the next page in history.
     def go_forward(timeout: nil, waitUntil: nil)
       wrap_impl(@impl.go_forward(timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
@@ -1114,23 +534,23 @@ module Playwright
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
     # last redirect.
-    # 
+    #
     # `page.goto` will throw an error if:
     # - there's an SSL error (e.g. in case of self-signed certificates).
     # - target URL is invalid.
     # - the `timeout` is exceeded during navigation.
     # - the remote server does not respond or is unreachable.
     # - the main resource failed to load.
-    # 
+    #
     # `page.goto` will not throw an error when any valid HTTP status code is returned by the remote server, including 404 "Not
     # Found" and 500 "Internal Server Error".  The status code for such responses can be retrieved by calling
     # [`method: Response.status`].
-    # 
+    #
     # > NOTE: `page.goto` either throws an error or returns a main resource response. The only exceptions are navigation to
     # `about:blank` or navigation to the same URL with a different hash, which would succeed and return `null`.
     # > NOTE: Headless mode doesn't support navigation to a PDF document. See the
     # [upstream issue](https://bugs.chromium.org/p/chromium/issues/detail?id=761295).
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.goto`]
     def goto(url, referer: nil, timeout: nil, waitUntil: nil)
       wrap_impl(@impl.goto(unwrap_impl(url), referer: unwrap_impl(referer), timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
@@ -1143,18 +563,19 @@ module Playwright
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.mouse`] to hover over the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.hover`].
     def hover(
           selector,
           force: nil,
           modifiers: nil,
           position: nil,
-          timeout: nil)
-      wrap_impl(@impl.hover(unwrap_impl(selector), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
+          timeout: nil,
+          trial: nil)
+      wrap_impl(@impl.hover(unwrap_impl(selector), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
     end
 
     # Returns `element.innerHTML`.
@@ -1216,10 +637,10 @@ module Playwright
 
     # Pauses script execution. Playwright will stop executing the script and wait for the user to either press 'Resume' button
     # in the page overlay or to call `playwright.resume()` in the DevTools console.
-    # 
+    #
     # User can inspect selectors or perform manual steps while paused. Resume will continue running the original script from
     # the place it was paused.
-    # 
+    #
     # > NOTE: This method requires Playwright to be started in a headed mode, with a falsy `headless` value in the
     # [`method: BrowserType.launch`].
     def pause
@@ -1227,54 +648,35 @@ module Playwright
     end
 
     # Returns the PDF buffer.
-    # 
+    #
     # > NOTE: Generating a pdf is currently only supported in Chromium headless.
-    # 
+    #
     # `page.pdf()` generates a pdf of the page with `print` css media. To generate a pdf with `screen` media, call
     # [`method: Page.emulateMedia`] before calling `page.pdf()`:
-    # 
+    #
     # > NOTE: By default, `page.pdf()` generates a pdf with modified colors for printing. Use the
     # [`-webkit-print-color-adjust`](https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-print-color-adjust) property to
     # force rendering of exact colors.
-    # 
     #
-    # ```js
-    # // Generates a PDF with 'screen' media type.
-    # await page.emulateMedia({media: 'screen'});
-    # await page.pdf({path: 'page.pdf'});
-    # ```
-    # 
-    # ```java
-    # // Generates a PDF with "screen" media type.
-    # page.emulateMedia(new Page.EmulateMediaOptions().setMedia(Media.SCREEN));
-    # page.pdf(new Page.PdfOptions().setPath(Paths.get("page.pdf")));
-    # ```
-    # 
-    # ```python async
-    # # generates a pdf with "screen" media type.
-    # await page.emulate_media(media="screen")
-    # await page.pdf(path="page.pdf")
-    # ```
-    # 
     # ```python sync
     # # generates a pdf with "screen" media type.
     # page.emulate_media(media="screen")
     # page.pdf(path="page.pdf")
     # ```
-    # 
+    #
     # The `width`, `height`, and `margin` options accept values labeled with units. Unlabeled values are treated as pixels.
-    # 
+    #
     # A few examples:
     # - `page.pdf({width: 100})` - prints with width set to 100 pixels
     # - `page.pdf({width: '100px'})` - prints with width set to 100 pixels
     # - `page.pdf({width: '10cm'})` - prints with width set to 10 centimeters.
-    # 
+    #
     # All possible units are:
     # - `px` - pixel
     # - `in` - inch
     # - `cm` - centimeter
     # - `mm` - millimeter
-    # 
+    #
     # The `format` options are:
     # - `Letter`: 8.5in x 11in
     # - `Legal`: 8.5in x 14in
@@ -1287,7 +689,7 @@ module Playwright
     # - `A4`: 8.27in x 11.7in
     # - `A5`: 5.83in x 8.27in
     # - `A6`: 4.13in x 5.83in
-    # 
+    #
     # > NOTE: `headerTemplate` and `footerTemplate` markup have the following limitations: > 1. Script tags inside templates
     # are not evaluated. > 2. Page styles are not visible inside templates.
     def pdf(
@@ -1308,60 +710,24 @@ module Playwright
     end
 
     # Focuses the element, and then uses [`method: Keyboard.down`] and [`method: Keyboard.up`].
-    # 
+    #
     # `key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
     # value or a single character to generate the text for. A superset of the `key` values can be found
     # [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:
-    # 
+    #
     # `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,
     # `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`, etc.
-    # 
+    #
     # Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
-    # 
+    #
     # Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
-    # 
+    #
     # If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective
     # texts.
-    # 
+    #
     # Shortcuts such as `key: "Control+o"` or `key: "Control+Shift+T"` are supported as well. When specified with the
     # modifier, modifier is pressed and being held while the subsequent key is being pressed.
-    # 
-    #
-    # ```js
-    # const page = await browser.newPage();
-    # await page.goto('https://keycode.info');
-    # await page.press('body', 'A');
-    # await page.screenshot({ path: 'A.png' });
-    # await page.press('body', 'ArrowLeft');
-    # await page.screenshot({ path: 'ArrowLeft.png' });
-    # await page.press('body', 'Shift+O');
-    # await page.screenshot({ path: 'O.png' });
-    # await browser.close();
-    # ```
-    # 
-    # ```java
-    # Page page = browser.newPage();
-    # page.navigate("https://keycode.info");
-    # page.press("body", "A");
-    # page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("A.png")));
-    # page.press("body", "ArrowLeft");
-    # page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("ArrowLeft.png" )));
-    # page.press("body", "Shift+O");
-    # page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("O.png" )));
-    # ```
-    # 
-    # ```python async
-    # page = await browser.new_page()
-    # await page.goto("https://keycode.info")
-    # await page.press("body", "A")
-    # await page.screenshot(path="a.png")
-    # await page.press("body", "ArrowLeft")
-    # await page.screenshot(path="arrow_left.png")
-    # await page.press("body", "Shift+O")
-    # await page.screenshot(path="o.png")
-    # await browser.close()
-    # ```
-    # 
+    #
     # ```python sync
     # page = browser.new_page()
     # page.goto("https://keycode.info")
@@ -1383,8 +749,8 @@ module Playwright
     end
 
     # The method finds an element matching the specified selector within the page. If no elements match the selector, the
-    # return value resolves to `null`.
-    # 
+    # return value resolves to `null`. To wait for an element on the page, use [`method: Page.waitForSelector`].
+    #
     # Shortcut for main frame's [`method: Frame.querySelector`].
     def query_selector(selector)
       wrap_impl(@impl.query_selector(unwrap_impl(selector)))
@@ -1392,7 +758,7 @@ module Playwright
 
     # The method finds all elements matching the specified selector within the page. If no elements match the selector, the
     # return value resolves to `[]`.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.querySelectorAll`].
     def query_selector_all(selector)
       wrap_impl(@impl.query_selector_all(unwrap_impl(selector)))
@@ -1405,78 +771,46 @@ module Playwright
     end
 
     # Routing provides the capability to modify network requests that are made by a page.
-    # 
+    #
     # Once routing is enabled, every request matching the url pattern will stall unless it's continued, fulfilled or aborted.
-    # 
+    #
     # > NOTE: The handler will only be called for the first url if the response is a redirect.
-    # 
+    #
     # An example of a naive handler that aborts all image requests:
-    # 
     #
-    # ```js
-    # const page = await browser.newPage();
-    # await page.route('**/*.{png,jpg,jpeg}', route => route.abort());
-    # await page.goto('https://example.com');
-    # await browser.close();
-    # ```
-    # 
-    # ```java
-    # Page page = browser.newPage();
-    # page.route("**/*.{png,jpg,jpeg}", route -> route.abort());
-    # page.navigate("https://example.com");
-    # browser.close();
-    # ```
-    # 
-    # ```python async
-    # page = await browser.new_page()
-    # await page.route("**/*.{png,jpg,jpeg}", lambda route: route.abort())
-    # await page.goto("https://example.com")
-    # await browser.close()
-    # ```
-    # 
     # ```python sync
     # page = browser.new_page()
     # page.route("**/*.{png,jpg,jpeg}", lambda route: route.abort())
     # page.goto("https://example.com")
     # browser.close()
     # ```
-    # 
+    #
     # or the same snippet using a regex pattern instead:
-    # 
     #
-    # ```js
-    # const page = await browser.newPage();
-    # await page.route(/(\.png$)|(\.jpg$)/, route => route.abort());
-    # await page.goto('https://example.com');
-    # await browser.close();
-    # ```
-    # 
-    # ```java
-    # Page page = browser.newPage();
-    # page.route(Pattern.compile("(\\.png$)|(\\.jpg$)"),route -> route.abort());
-    # page.navigate("https://example.com");
-    # browser.close();
-    # ```
-    # 
-    # ```python async
-    # page = await browser.new_page()
-    # await page.route(re.compile(r"(\.png$)|(\.jpg$)"), lambda route: route.abort())
-    # await page.goto("https://example.com")
-    # await browser.close()
-    # ```
-    # 
     # ```python sync
     # page = browser.new_page()
     # page.route(re.compile(r"(\.png$)|(\.jpg$)"), lambda route: route.abort())
     # page.goto("https://example.com")
     # browser.close()
     # ```
-    # 
+    #
+    # It is possible to examine the request to decide the route action. For example, mocking all requests that contain some
+    # post data, and leaving all other requests as is:
+    #
+    # ```python sync
+    # def handle_route(route):
+    #   if ("my-string" in route.request.post_data)
+    #     route.fulfill(body="mocked-data")
+    #   else
+    #     route.continue_()
+    # page.route("/api/**", handle_route)
+    # ```
+    #
     # Page routes take precedence over browser context routes (set up with [`method: BrowserContext.route`]) when request
     # matches both handlers.
-    # 
+    #
     # To remove a route with its handler you can use [`method: Page.unroute`].
-    # 
+    #
     # > NOTE: Enabling routing disables http cache.
     def route(url, handler)
       wrap_impl(@impl.route(unwrap_impl(url), unwrap_impl(handler)))
@@ -1494,44 +828,17 @@ module Playwright
       wrap_impl(@impl.screenshot(clip: unwrap_impl(clip), fullPage: unwrap_impl(fullPage), omitBackground: unwrap_impl(omitBackground), path: unwrap_impl(path), quality: unwrap_impl(quality), timeout: unwrap_impl(timeout), type: unwrap_impl(type)))
     end
 
+    # This method waits for an element matching `selector`, waits for [actionability](./actionability.md) checks, waits until
+    # all specified options are present in the `<select>` element and selects these options.
+    #
+    # If the target element is not a `<select>` element, this method throws an error. However, if the element is inside the
+    # `<label>` element that has an associated
+    # [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be used instead.
+    #
     # Returns the array of option values that have been successfully selected.
-    # 
-    # Triggers a `change` and `input` event once all the provided options have been selected. If there's no `<select>` element
-    # matching `selector`, the method throws an error.
-    # 
-    # Will wait until all specified options are present in the `<select>` element.
-    # 
-    #
-    # ```js
-    # // single selection matching the value
-    # page.selectOption('select#colors', 'blue');
-    # 
-    # // single selection matching the label
-    # page.selectOption('select#colors', { label: 'Blue' });
-    # 
-    # // multiple selection
-    # page.selectOption('select#colors', ['red', 'green', 'blue']);
-    # 
-    # ```
-    # 
-    # ```java
-    # // single selection matching the value
-    # page.selectOption("select#colors", "blue");
-    # // single selection matching both the value and the label
-    # page.selectOption("select#colors", new SelectOption().setLabel("Blue"));
-    # // multiple selection
-    # page.selectOption("select#colors", new String[] {"red", "green", "blue"});
-    # ```
-    # 
-    # ```python async
-    # # single selection matching the value
-    # await page.select_option("select#colors", "blue")
-    # # single selection matching the label
-    # await page.select_option("select#colors", label="blue")
-    # # multiple selection
-    # await page.select_option("select#colors", value=["red", "green", "blue"])
-    # ```
-    # 
+    #
+    # Triggers a `change` and `input` event once all the provided options have been selected.
+    #
     # ```python sync
     # # single selection matching the value
     # page.select_option("select#colors", "blue")
@@ -1540,8 +847,8 @@ module Playwright
     # # multiple selection
     # page.select_option("select#colors", value=["red", "green", "blue"])
     # ```
-    # 
-    # Shortcut for main frame's [`method: Frame.selectOption`]
+    #
+    # Shortcut for main frame's [`method: Frame.selectOption`].
     def select_option(
           selector,
           element: nil,
@@ -1566,7 +873,7 @@ module Playwright
     # - [`method: Page.setContent`]
     # - [`method: Page.waitForNavigation`]
     # - [`method: Page.waitForURL`]
-    # 
+    #
     # > NOTE: [`method: Page.setDefaultNavigationTimeout`] takes priority over [`method: Page.setDefaultTimeout`],
     # [`method: BrowserContext.setDefaultTimeout`] and [`method: BrowserContext.setDefaultNavigationTimeout`].
     def set_default_navigation_timeout(timeout)
@@ -1575,7 +882,7 @@ module Playwright
     alias_method :default_navigation_timeout=, :set_default_navigation_timeout
 
     # This setting will change the default maximum time for all the methods accepting `timeout` option.
-    # 
+    #
     # > NOTE: [`method: Page.setDefaultNavigationTimeout`] takes priority over [`method: Page.setDefaultTimeout`].
     def set_default_timeout(timeout)
       wrap_impl(@impl.set_default_timeout(unwrap_impl(timeout)))
@@ -1583,7 +890,7 @@ module Playwright
     alias_method :default_timeout=, :set_default_timeout
 
     # The extra HTTP headers will be sent with every request the page initiates.
-    # 
+    #
     # > NOTE: [`method: Page.setExtraHTTPHeaders`] does not guarantee the order of headers in the outgoing requests.
     def set_extra_http_headers(headers)
       wrap_impl(@impl.set_extra_http_headers(unwrap_impl(headers)))
@@ -1592,7 +899,7 @@ module Playwright
 
     # This method expects `selector` to point to an
     # [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input).
-    # 
+    #
     # Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then they
     # are resolved relative to the the current working directory. For empty array, clears the selected files.
     def set_input_files(selector, files, noWaitAfter: nil, timeout: nil)
@@ -1601,32 +908,10 @@ module Playwright
 
     # In the case of multiple pages in a single browser, each page can have its own viewport size. However,
     # [`method: Browser.newContext`] allows to set viewport size (and more) for all pages in the context at once.
-    # 
+    #
     # `page.setViewportSize` will resize the page. A lot of websites don't expect phones to change size, so you should set the
     # viewport size before navigating to the page.
-    # 
-    #
-    # ```js
-    # const page = await browser.newPage();
-    # await page.setViewportSize({
-    #   width: 640,
-    #   height: 480,
-    # });
-    # await page.goto('https://example.com');
-    # ```
-    # 
-    # ```java
-    # Page page = browser.newPage();
-    # page.setViewportSize(640, 480);
-    # page.navigate("https://example.com");
-    # ```
-    # 
-    # ```python async
-    # page = await browser.new_page()
-    # await page.set_viewport_size({"width": 640, "height": 480})
-    # await page.goto("https://example.com")
-    # ```
-    # 
+    #
     # ```python sync
     # page = browser.new_page()
     # page.set_viewport_size({"width": 640, "height": 480})
@@ -1644,12 +929,12 @@ module Playwright
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.touchscreen`] to tap the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    # 
+    #
     # > NOTE: [`method: Page.tap`] requires that the `hasTouch` option of the browser context be set to true.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.tap`].
     def tap_point(
           selector,
@@ -1657,8 +942,9 @@ module Playwright
           modifiers: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
-      wrap_impl(@impl.tap_point(unwrap_impl(selector), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
+          timeout: nil,
+          trial: nil)
+      wrap_impl(@impl.tap_point(unwrap_impl(selector), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
     end
 
     # Returns `element.textContent`.
@@ -1673,32 +959,14 @@ module Playwright
 
     # Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text. `page.type` can be used to send
     # fine-grained keyboard events. To fill values in form fields, use [`method: Page.fill`].
-    # 
+    #
     # To press a special key, like `Control` or `ArrowDown`, use [`method: Keyboard.press`].
-    # 
     #
-    # ```js
-    # await page.type('#mytextarea', 'Hello'); // Types instantly
-    # await page.type('#mytextarea', 'World', {delay: 100}); // Types slower, like a user
-    # ```
-    # 
-    # ```java
-    # // Types instantly
-    # page.type("#mytextarea", "Hello");
-    # // Types slower, like a user
-    # page.type("#mytextarea", "World", new Page.TypeOptions().setDelay(100));
-    # ```
-    # 
-    # ```python async
-    # await page.type("#mytextarea", "hello") # types instantly
-    # await page.type("#mytextarea", "world", delay=100) # types slower, like a user
-    # ```
-    # 
     # ```python sync
     # page.type("#mytextarea", "hello") # types instantly
     # page.type("#mytextarea", "world", delay=100) # types slower, like a user
     # ```
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.type`].
     def type(
           selector,
@@ -1719,18 +987,19 @@ module Playwright
     # 1. Use [`property: Page.mouse`] to click in the center of the element.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
     # 1. Ensure that the element is now unchecked. If not, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.uncheck`].
     def uncheck(
           selector,
           force: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
-      wrap_impl(@impl.uncheck(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
+          timeout: nil,
+          trial: nil)
+      wrap_impl(@impl.uncheck(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
     end
 
     # Removes a route created with [`method: Page.route`]. When `handler` is not specified, removes all routes for the `url`.
@@ -1754,7 +1023,7 @@ module Playwright
 
     # Performs action and waits for a `ConsoleMessage` to be logged by in the page. If predicate is provided, it passes
     # `ConsoleMessage` value into the `predicate` function and waits for `predicate(message)` to return a truthy value. Will
-    # throw an error if the page is closed before the console event is fired.
+    # throw an error if the page is closed before the [`event: Page.console`] event is fired.
     def expect_console_message(predicate: nil, timeout: nil, &block)
       wrap_impl(@impl.expect_console_message(predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end
@@ -1768,21 +1037,7 @@ module Playwright
 
     # Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
     # value. Will throw an error if the page is closed before the event is fired. Returns the event data value.
-    # 
     #
-    # ```js
-    # const [frame, _] = await Promise.all([
-    #   page.waitForEvent('framenavigated'),
-    #   page.click('button')
-    # ]);
-    # ```
-    # 
-    # ```python async
-    # async with page.expect_event("framenavigated") as event_info:
-    #     await page.click("button")
-    # frame = await event_info.value
-    # ```
-    # 
     # ```python sync
     # with page.expect_event("framenavigated") as event_info:
     #     page.click("button")
@@ -1800,61 +1055,12 @@ module Playwright
     end
 
     # Returns when the `expression` returns a truthy value. It resolves to a JSHandle of the truthy value.
-    # 
+    #
     # The [`method: Page.waitForFunction`] can be used to observe viewport size change:
-    # 
-    #
-    # ```js
-    # const { webkit } = require('playwright');  // Or 'chromium' or 'firefox'.
-    # 
-    # (async () => {
-    #   const browser = await webkit.launch();
-    #   const page = await browser.newPage();
-    #   const watchDog = page.waitForFunction(() => window.innerWidth < 100);
-    #   await page.setViewportSize({width: 50, height: 50});
-    #   await watchDog;
-    #   await browser.close();
-    # })();
-    # ```
-    # 
-    # ```java
-    # import com.microsoft.playwright.*;
-    # 
-    # public class Example {
-    #   public static void main(String[] args) {
-    #     try (Playwright playwright = Playwright.create()) {
-    #       BrowserType webkit = playwright.webkit();
-    #       Browser browser = webkit.launch();
-    #       Page page = browser.newPage();
-    #       page.setViewportSize(50,  50);
-    #       page.waitForFunction("() => window.innerWidth < 100");
-    #       browser.close();
-    #     }
-    #   }
-    # }
-    # ```
-    # 
-    # ```python async
-    # import asyncio
-    # from playwright.async_api import async_playwright
-    # 
-    # async def run(playwright):
-    #     webkit = playwright.webkit
-    #     browser = await webkit.launch()
-    #     page = await browser.new_page()
-    #     await page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
-    #     await page.wait_for_function("() => window.x > 0")
-    #     await browser.close()
-    # 
-    # async def main():
-    #     async with async_playwright() as playwright:
-    #         await run(playwright)
-    # asyncio.run(main())
-    # ```
-    # 
+    #
     # ```python sync
     # from playwright.sync_api import sync_playwright
-    # 
+    #
     # def run(playwright):
     #     webkit = playwright.webkit
     #     browser = webkit.launch()
@@ -1862,92 +1068,33 @@ module Playwright
     #     page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
     #     page.wait_for_function("() => window.x > 0")
     #     browser.close()
-    # 
+    #
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
-    # 
+    #
     # To pass an argument to the predicate of [`method: Page.waitForFunction`] function:
-    # 
     #
-    # ```js
-    # const selector = '.foo';
-    # await page.waitForFunction(selector => !!document.querySelector(selector), selector);
-    # ```
-    # 
-    # ```java
-    # String selector = ".foo";
-    # page.waitForFunction("selector => !!document.querySelector(selector)", selector);
-    # ```
-    # 
-    # ```python async
-    # selector = ".foo"
-    # await page.wait_for_function("selector => !!document.querySelector(selector)", selector)
-    # ```
-    # 
     # ```python sync
     # selector = ".foo"
     # page.wait_for_function("selector => !!document.querySelector(selector)", selector)
     # ```
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.waitForFunction`].
     def wait_for_function(expression, arg: nil, polling: nil, timeout: nil)
       wrap_impl(@impl.wait_for_function(unwrap_impl(expression), arg: unwrap_impl(arg), polling: unwrap_impl(polling), timeout: unwrap_impl(timeout)))
     end
 
     # Returns when the required load state has been reached.
-    # 
+    #
     # This resolves when the page reaches a required load state, `load` by default. The navigation must have been committed
     # when this method is called. If current document has already reached the required state, resolves immediately.
-    # 
     #
-    # ```js
-    # await page.click('button'); // Click triggers navigation.
-    # await page.waitForLoadState(); // The promise resolves after 'load' event.
-    # ```
-    # 
-    # ```java
-    # page.click("button"); // Click triggers navigation.
-    # page.waitForLoadState(); // The promise resolves after "load" event.
-    # ```
-    # 
-    # ```python async
-    # await page.click("button") # click triggers navigation.
-    # await page.wait_for_load_state() # the promise resolves after "load" event.
-    # ```
-    # 
     # ```python sync
     # page.click("button") # click triggers navigation.
     # page.wait_for_load_state() # the promise resolves after "load" event.
     # ```
-    # 
-    #
-    # ```js
-    # const [popup] = await Promise.all([
-    #   page.waitForEvent('popup'),
-    #   page.click('button'), // Click triggers a popup.
-    # ])
-    # await popup.waitForLoadState('domcontentloaded'); // The promise resolves after 'domcontentloaded' event.
-    # console.log(await popup.title()); // Popup is ready to use.
-    # ```
-    # 
-    # ```java
-    # Page popup = page.waitForPopup(() -> {
-    #   page.click("button"); // Click triggers a popup.
-    # });
-    # popup.waitForLoadState(LoadState.DOMCONTENTLOADED);
-    # System.out.println(popup.title()); // Popup is ready to use.
-    # ```
-    # 
-    # ```python async
-    # async with page.expect_popup() as page_info:
-    #     await page.click("button") # click triggers a popup.
-    # popup = await page_info.value
-    #  # Following resolves after "domcontentloaded" event.
-    # await popup.wait_for_load_state("domcontentloaded")
-    # print(await popup.title()) # popup is ready to use.
-    # ```
-    # 
+    #
     # ```python sync
     # with page.expect_popup() as page_info:
     #     page.click("button") # click triggers a popup.
@@ -1956,7 +1103,7 @@ module Playwright
     # popup.wait_for_load_state("domcontentloaded")
     # print(popup.title()) # popup is ready to use.
     # ```
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.waitForLoadState`].
     def wait_for_load_state(state: nil, timeout: nil)
       wrap_impl(@impl.wait_for_load_state(state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
@@ -1965,41 +1112,20 @@ module Playwright
     # Waits for the main frame navigation and returns the main resource response. In case of multiple redirects, the
     # navigation will resolve with the response of the last redirect. In case of navigation to a different anchor or
     # navigation due to History API usage, the navigation will resolve with `null`.
-    # 
+    #
     # This resolves when the page navigates to a new URL or reloads. It is useful for when you run code which will indirectly
     # cause the page to navigate. e.g. The click target has an `onclick` handler that triggers navigation from a `setTimeout`.
     # Consider this example:
-    # 
     #
-    # ```js
-    # const [response] = await Promise.all([
-    #   page.waitForNavigation(), // The promise resolves after navigation has finished
-    #   page.click('a.delayed-navigation'), // Clicking the link will indirectly cause a navigation
-    # ]);
-    # ```
-    # 
-    # ```java
-    # // The method returns after navigation has finished
-    # Response response = page.waitForNavigation(() -> {
-    #   page.click("a.delayed-navigation"); // Clicking the link will indirectly cause a navigation
-    # });
-    # ```
-    # 
-    # ```python async
-    # async with page.expect_navigation():
-    #     await page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
-    # # Resolves after navigation has finished
-    # ```
-    # 
     # ```python sync
     # with page.expect_navigation():
     #     page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
     # # Resolves after navigation has finished
     # ```
-    # 
+    #
     # > NOTE: Usage of the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API) to change the URL is
     # considered a navigation.
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.waitForNavigation`].
     def expect_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
       wrap_impl(@impl.expect_navigation(timeout: unwrap_impl(timeout), url: unwrap_impl(url), waitUntil: unwrap_impl(waitUntil), &wrap_block_call(block)))
@@ -2012,162 +1138,60 @@ module Playwright
       wrap_impl(@impl.expect_popup(predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end
 
-    # Waits for the matching request and returns it.
-    # 
+    # Waits for the matching request and returns it.  See [waiting for event](./events.md#waiting-for-event) for more details
+    # about events.
     #
-    # ```js
-    # const firstRequest = await page.waitForRequest('http://example.com/resource');
-    # const finalRequest = await page.waitForRequest(request => request.url() === 'http://example.com' && request.method() === 'GET');
-    # return firstRequest.url();
-    # ```
-    # 
-    # ```java
-    # Request firstRequest = page.waitForRequest("http://example.com/resource");
-    # Object finalRequest = page.waitForRequest(
-    #   request -> "http://example.com".equals(request.url()) && "GET".equals(request.method()), () -> {});
-    # return firstRequest.url();
-    # ```
-    # 
-    # ```python async
-    # async with page.expect_request("http://example.com/resource") as first:
-    #     await page.click('button')
-    # first_request = await first.value
-    # 
-    # async with page.expect_request(lambda request: request.url == "http://example.com" and request.method == "get") as second:
-    #     await page.click('img')
-    # second_request = await second.value
-    # ```
-    # 
     # ```python sync
     # with page.expect_request("http://example.com/resource") as first:
     #     page.click('button')
     # first_request = first.value
-    # 
+    #
+    # # or with a lambda
     # with page.expect_request(lambda request: request.url == "http://example.com" and request.method == "get") as second:
     #     page.click('img')
     # second_request = second.value
     # ```
-    # 
-    #
-    # ```js
-    # await page.waitForRequest(request => request.url().searchParams.get('foo') === 'bar' && request.url().searchParams.get('foo2') === 'bar2');
-    # ```
-    def expect_request(urlOrPredicate, timeout: nil)
-      wrap_impl(@impl.expect_request(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout)))
+    def expect_request(urlOrPredicate, timeout: nil, &block)
+      wrap_impl(@impl.expect_request(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+    end
+
+    # Performs action and waits for a `Request` to finish loading. If predicate is provided, it passes `Request` value into
+    # the `predicate` function and waits for `predicate(request)` to return a truthy value. Will throw an error if the page is
+    # closed before the [`event: Page.requestFinished`] event is fired.
+    def expect_request_finished(predicate: nil, timeout: nil)
+      raise NotImplementedError.new('expect_request_finished is not implemented yet.')
     end
 
-    # Returns the matched response.
-    # 
+    # Returns the matched response. See [waiting for event](./events.md#waiting-for-event) for more details about events.
     #
-    # ```js
-    # const firstResponse = await page.waitForResponse('https://example.com/resource');
-    # const finalResponse = await page.waitForResponse(response => response.url() === 'https://example.com' && response.status() === 200);
-    # return finalResponse.ok();
-    # ```
-    # 
-    # ```java
-    # Response firstResponse = page.waitForResponse("https://example.com/resource", () -> {});
-    # Response finalResponse = page.waitForResponse(response -> "https://example.com".equals(response.url()) && response.status() == 200, () -> {});
-    # return finalResponse.ok();
-    # ```
-    # 
-    # ```python async
-    # async with page.expect_response("https://example.com/resource") as response_info:
-    #     await page.click("input")
-    # response = response_info.value
-    # return response.ok
-    # 
-    # # or with a lambda
-    # async with page.expect_response(lambda response: response.url == "https://example.com" and response.status === 200) as response_info:
-    #     await page.click("input")
-    # response = response_info.value
-    # return response.ok
-    # ```
-    # 
     # ```python sync
     # with page.expect_response("https://example.com/resource") as response_info:
     #     page.click("input")
     # response = response_info.value
     # return response.ok
-    # 
+    #
     # # or with a lambda
     # with page.expect_response(lambda response: response.url == "https://example.com" and response.status === 200) as response_info:
     #     page.click("input")
     # response = response_info.value
     # return response.ok
     # ```
-    def expect_response(urlOrPredicate, timeout: nil)
-      wrap_impl(@impl.expect_response(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout)))
+    def expect_response(urlOrPredicate, timeout: nil, &block)
+      wrap_impl(@impl.expect_response(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end
 
     # Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
     # `detached`.
-    # 
+    #
     # Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
     # the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the
     # selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
-    # 
+    #
     # This method works across navigations:
-    # 
-    #
-    # ```js
-    # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
-    # 
-    # (async () => {
-    #   const browser = await chromium.launch();
-    #   const page = await browser.newPage();
-    #   for (let currentURL of ['https://google.com', 'https://bbc.com']) {
-    #     await page.goto(currentURL);
-    #     const element = await page.waitForSelector('img');
-    #     console.log('Loaded image: ' + await element.getAttribute('src'));
-    #   }
-    #   await browser.close();
-    # })();
-    # ```
-    # 
-    # ```java
-    # import com.microsoft.playwright.*;
-    # 
-    # public class Example {
-    #   public static void main(String[] args) {
-    #     try (Playwright playwright = Playwright.create()) {
-    #       BrowserType chromium = playwright.chromium();
-    #       Browser browser = chromium.launch();
-    #       Page page = browser.newPage();
-    #       for (String currentURL : Arrays.asList("https://google.com", "https://bbc.com")) {
-    #         page.navigate(currentURL);
-    #         ElementHandle element = page.waitForSelector("img");
-    #         System.out.println("Loaded image: " + element.getAttribute("src"));
-    #       }
-    #       browser.close();
-    #     }
-    #   }
-    # }
-    # ```
-    # 
-    # ```python async
-    # import asyncio
-    # from playwright.async_api import async_playwright
-    # 
-    # async def run(playwright):
-    #     chromium = playwright.chromium
-    #     browser = await chromium.launch()
-    #     page = await browser.new_page()
-    #     for current_url in ["https://google.com", "https://bbc.com"]:
-    #         await page.goto(current_url, wait_until="domcontentloaded")
-    #         element = await page.wait_for_selector("img")
-    #         print("Loaded image: " + str(await element.get_attribute("src")))
-    #     await browser.close()
-    # 
-    # async def main():
-    #     async with async_playwright() as playwright:
-    #         await run(playwright)
-    # asyncio.run(main())
-    # ```
-    # 
+    #
     # ```python sync
     # from playwright.sync_api import sync_playwright
-    # 
+    #
     # def run(playwright):
     #     chromium = playwright.chromium
     #     browser = chromium.launch()
@@ -2177,7 +1201,7 @@ module Playwright
     #         element = page.wait_for_selector("img")
     #         print("Loaded image: " + str(element.get_attribute("src")))
     #     browser.close()
-    # 
+    #
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
@@ -2186,64 +1210,39 @@ module Playwright
     end
 
     # Waits for the given `timeout` in milliseconds.
-    # 
+    #
     # Note that `page.waitForTimeout()` should only be used for debugging. Tests using the timer in production are going to be
     # flaky. Use signals such as network events, selectors becoming visible and others instead.
-    # 
     #
-    # ```js
-    # // wait for 1 second
-    # await page.waitForTimeout(1000);
-    # ```
-    # 
-    # ```java
-    # // wait for 1 second
-    # page.waitForTimeout(1000);
-    # ```
-    # 
-    # ```python async
-    # # wait for 1 second
-    # await page.wait_for_timeout(1000)
-    # ```
-    # 
     # ```python sync
     # # wait for 1 second
     # page.wait_for_timeout(1000)
     # ```
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.waitForTimeout`].
     def wait_for_timeout(timeout)
       raise NotImplementedError.new('wait_for_timeout is not implemented yet.')
     end
 
     # Waits for the main frame to navigate to the given URL.
-    # 
     #
-    # ```js
-    # await page.click('a.delayed-navigation'); // Clicking the link will indirectly cause a navigation
-    # await page.waitForURL('**/target.html');
-    # ```
-    # 
-    # ```java
-    # page.click("a.delayed-navigation"); // Clicking the link will indirectly cause a navigation
-    # page.waitForURL("**/target.html");
-    # ```
-    # 
-    # ```python async
-    # await page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
-    # await page.wait_for_url("**/target.html")
-    # ```
-    # 
     # ```python sync
     # page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
     # page.wait_for_url("**/target.html")
     # ```
-    # 
+    #
     # Shortcut for main frame's [`method: Frame.waitForURL`].
     def wait_for_url(url, timeout: nil, waitUntil: nil)
       wrap_impl(@impl.wait_for_url(unwrap_impl(url), timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
 
+    # Performs action and waits for a new `WebSocket`. If predicate is provided, it passes `WebSocket` value into the
+    # `predicate` function and waits for `predicate(webSocket)` to return a truthy value. Will throw an error if the page is
+    # closed before the WebSocket event is fired.
+    def expect_websocket(predicate: nil, timeout: nil)
+      raise NotImplementedError.new('expect_websocket is not implemented yet.')
+    end
+
     # Performs action and waits for a new `Worker`. If predicate is provided, it passes `Worker` value into the `predicate`
     # function and waits for `predicate(worker)` to return a truthy value. Will throw an error if the page is closed before
     # the worker event is fired.
@@ -2253,16 +1252,16 @@ module Playwright
 
     # This method returns all of the dedicated [WebWorkers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API)
     # associated with the page.
-    # 
+    #
     # > NOTE: This does not contain ServiceWorkers
     def workers
       raise NotImplementedError.new('workers is not implemented yet.')
     end
 
     # > NOTE: In most cases, you should use [`method: Page.waitForEvent`].
-    # 
+    #
     # Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function and
-    # waits for `predicate(event)` to return a truthy value. Will throw an error if the socket is closed before the `event` is
+    # waits for `predicate(event)` to return a truthy value. Will throw an error if the page is closed before the `event` is
     # fired.
     def wait_for_event(event, predicate: nil, timeout: nil)
       raise NotImplementedError.new('wait_for_event is not implemented yet.')
@@ -2278,11 +1277,6 @@ module Playwright
       wrap_impl(@impl.start_js_coverage(resetOnNavigation: unwrap_impl(resetOnNavigation), reportAnonymousScripts: unwrap_impl(reportAnonymousScripts)))
     end
 
-    # @nodoc
-    def stop_js_coverage
-      wrap_impl(@impl.stop_js_coverage)
-    end
-
     # @nodoc
     def start_css_coverage(resetOnNavigation: nil, reportAnonymousScripts: nil)
       wrap_impl(@impl.start_css_coverage(resetOnNavigation: unwrap_impl(resetOnNavigation), reportAnonymousScripts: unwrap_impl(reportAnonymousScripts)))
@@ -2293,6 +1287,11 @@ module Playwright
       wrap_impl(@impl.stop_css_coverage)
     end
 
+    # @nodoc
+    def stop_js_coverage
+      wrap_impl(@impl.stop_js_coverage)
+    end
+
     # @nodoc
     def guid
       wrap_impl(@impl.guid)