playwright-ruby-client 0.5.9 → 0.6.3

data/lib/playwright_api/browser_type.rb

@@ -1,58 +1,10 @@
 module Playwright
   # BrowserType provides methods to launch a specific browser instance or connect to an existing one. The following is a
   # typical example of using Playwright to drive automation:
-  # 
   #
-  # ```js
-  # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
-  # 
-  # (async () => {
-  #   const browser = await chromium.launch();
-  #   const page = await browser.newPage();
-  #   await page.goto('https://example.com');
-  #   // other actions...
-  #   await browser.close();
-  # })();
-  # ```
-  # 
-  # ```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();
-  #       page.navigate("https://example.com");
-  #       // other actions...
-  #       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()
-  #     await page.goto("https://example.com")
-  #     # other actions...
-  #     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()
@@ -60,46 +12,46 @@ module Playwright
   #     page.goto("https://example.com")
   #     # other actions...
   #     browser.close()
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
   class BrowserType < PlaywrightApi
 
+    # This methods attaches Playwright to an existing browser instance.
+    def connect(wsEndpoint, headers: nil, slowMo: nil, timeout: nil)
+      raise NotImplementedError.new('connect is not implemented yet.')
+    end
+
+    # This methods attaches Playwright to an existing browser instance using the Chrome DevTools Protocol.
+    #
+    # The default browser context is accessible via [`method: Browser.contexts`].
+    #
+    # > NOTE: Connecting over the Chrome DevTools Protocol is only supported for Chromium-based browsers.
+    def connect_over_cdp(
+          endpointURL,
+          headers: nil,
+          slowMo: nil,
+          timeout: nil,
+          &block)
+      wrap_impl(@impl.connect_over_cdp(unwrap_impl(endpointURL), headers: unwrap_impl(headers), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+    end
+
     # A path where Playwright expects to find a bundled browser executable.
     def executable_path
       wrap_impl(@impl.executable_path)
     end
 
     # Returns the browser instance.
-    # 
+    #
     # You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
-    # 
     #
-    # ```js
-    # const browser = await chromium.launch({  // Or 'firefox' or 'webkit'.
-    #   ignoreDefaultArgs: ['--mute-audio']
-    # });
-    # ```
-    # 
-    # ```java
-    # // Or "firefox" or "webkit".
-    # Browser browser = chromium.launch(new BrowserType.LaunchOptions()
-    #   .setIgnoreDefaultArgs(Arrays.asList("--mute-audio")));
-    # ```
-    # 
-    # ```python async
-    # browser = await playwright.chromium.launch( # or "firefox" or "webkit".
-    #     ignore_default_args=["--mute-audio"]
-    # )
-    # ```
-    # 
     # ```python sync
     # browser = playwright.chromium.launch( # or "firefox" or "webkit".
     #     ignore_default_args=["--mute-audio"]
     # )
     # ```
-    # 
+    #
     # > **Chromium-only** Playwright can also be used to control the Google Chrome or Microsoft Edge browsers, but it works
     # best with the version of Chromium it is bundled with. There is no guarantee it will work with any other version. Use
     # `executablePath` option with extreme caution.
@@ -131,12 +83,13 @@ module Playwright
           proxy: nil,
           slowMo: nil,
           timeout: nil,
+          traceDir: nil,
           &block)
-      wrap_impl(@impl.launch(args: unwrap_impl(args), channel: unwrap_impl(channel), chromiumSandbox: unwrap_impl(chromiumSandbox), devtools: unwrap_impl(devtools), downloadsPath: unwrap_impl(downloadsPath), env: unwrap_impl(env), executablePath: unwrap_impl(executablePath), firefoxUserPrefs: unwrap_impl(firefoxUserPrefs), handleSIGHUP: unwrap_impl(handleSIGHUP), handleSIGINT: unwrap_impl(handleSIGINT), handleSIGTERM: unwrap_impl(handleSIGTERM), headless: unwrap_impl(headless), ignoreDefaultArgs: unwrap_impl(ignoreDefaultArgs), proxy: unwrap_impl(proxy), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+      wrap_impl(@impl.launch(args: unwrap_impl(args), channel: unwrap_impl(channel), chromiumSandbox: unwrap_impl(chromiumSandbox), devtools: unwrap_impl(devtools), downloadsPath: unwrap_impl(downloadsPath), env: unwrap_impl(env), executablePath: unwrap_impl(executablePath), firefoxUserPrefs: unwrap_impl(firefoxUserPrefs), handleSIGHUP: unwrap_impl(handleSIGHUP), handleSIGINT: unwrap_impl(handleSIGINT), handleSIGTERM: unwrap_impl(handleSIGTERM), headless: unwrap_impl(headless), ignoreDefaultArgs: unwrap_impl(ignoreDefaultArgs), proxy: unwrap_impl(proxy), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), traceDir: unwrap_impl(traceDir), &wrap_block_call(block)))
     end
 
     # Returns the persistent browser context instance.
-    # 
+    #
     # Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this
     # context will automatically close the browser.
     def launch_persistent_context(
@@ -173,10 +126,12 @@ module Playwright
           record_har_path: nil,
           record_video_dir: nil,
           record_video_size: nil,
+          reducedMotion: nil,
           screen: nil,
           slowMo: nil,
           timeout: nil,
           timezoneId: nil,
+          traceDir: nil,
           userAgent: nil,
           viewport: nil)
       raise NotImplementedError.new('launch_persistent_context is not implemented yet.')
@@ -187,11 +142,6 @@ module Playwright
       wrap_impl(@impl.name)
     end
 
-    # @nodoc
-    def connect_over_cdp(endpointURL, slowMo: nil, timeout: nil, &block)
-      wrap_impl(@impl.connect_over_cdp(unwrap_impl(endpointURL), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)

data/lib/playwright_api/cdp_session.rb

@@ -1,39 +1,16 @@
 module Playwright
   # - extends: [EventEmitter]
-  # 
+  #
   # The `CDPSession` instances are used to talk raw Chrome Devtools Protocol:
   # - protocol methods can be called with `session.send` method.
   # - protocol events can be subscribed to with `session.on` method.
-  # 
+  #
   # Useful links:
   # - Documentation on DevTools Protocol can be found here:
   #   [DevTools Protocol Viewer](https://chromedevtools.github.io/devtools-protocol/).
   # - Getting Started with DevTools Protocol:
   #   https://github.com/aslushnikov/getting-started-with-cdp/blob/master/README.md
-  # 
   #
-  # ```js
-  # const client = await page.context().newCDPSession(page);
-  # await client.send('Animation.enable');
-  # client.on('Animation.animationCreated', () => console.log('Animation created!'));
-  # const response = await client.send('Animation.getPlaybackRate');
-  # console.log('playback rate is ' + response.playbackRate);
-  # await client.send('Animation.setPlaybackRate', {
-  #   playbackRate: response.playbackRate / 2
-  # });
-  # ```
-  # 
-  # ```python async
-  # client = await page.context().new_cdp_session(page)
-  # await client.send("animation.enable")
-  # client.on("animation.animation_created", lambda: print("animation created!"))
-  # response = await client.send("animation.get_playback_rate")
-  # print("playback rate is " + response["playback_rate"])
-  # await client.send("animation.set_playback_rate", {
-  #     playback_rate: response["playback_rate"] / 2
-  # })
-  # ```
-  # 
   # ```python sync
   # client = page.context().new_cdp_session(page)
   # client.send("animation.enable")

data/lib/playwright_api/console_message.rb

@@ -2,6 +2,7 @@ module Playwright
   # `ConsoleMessage` objects are dispatched by page via the [`event: Page.console`] event.
   class ConsoleMessage < PlaywrightApi
 
+    # List of arguments passed to a `console` function call. See also [`event: Page.console`].
     def args
       wrap_impl(@impl.args)
     end
@@ -10,6 +11,7 @@ module Playwright
       wrap_impl(@impl.location)
     end
 
+    # The text of the console message.
     def text
       wrap_impl(@impl.text)
     end

data/lib/playwright_api/dialog.rb

@@ -1,73 +1,15 @@
 module Playwright
   # `Dialog` objects are dispatched by page via the [`event: Page.dialog`] event.
-  # 
+  #
   # An example of using `Dialog` class:
-  # 
   #
-  # ```js
-  # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
-  # 
-  # (async () => {
-  #   const browser = await chromium.launch();
-  #   const page = await browser.newPage();
-  #   page.on('dialog', async dialog => {
-  #     console.log(dialog.message());
-  #     await dialog.dismiss();
-  #   });
-  #   await page.evaluate(() => alert('1'));
-  #   await browser.close();
-  # })();
-  # ```
-  # 
-  # ```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();
-  #       page.onDialog(dialog -> {
-  #         System.out.println(dialog.message());
-  #         dialog.dismiss();
-  #       });
-  #       page.evaluate("alert('1')");
-  #       browser.close();
-  #     }
-  #   }
-  # }
-  # ```
-  # 
-  # ```python async
-  # import asyncio
-  # from playwright.async_api import async_playwright
-  # 
-  # async def handle_dialog(dialog):
-  #     print(dialog.message)
-  #     await dialog.dismiss()
-  # 
-  # async def run(playwright):
-  #     chromium = playwright.chromium
-  #     browser = await chromium.launch()
-  #     page = await browser.new_page()
-  #     page.on("dialog", handle_dialog)
-  #     page.evaluate("alert('1')")
-  #     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 handle_dialog(dialog):
   #     print(dialog.message)
   #     dialog.dismiss()
-  # 
+  #
   # def run(playwright):
   #     chromium = playwright.chromium
   #     browser = chromium.launch()
@@ -75,11 +17,11 @@ module Playwright
   #     page.on("dialog", handle_dialog)
   #     page.evaluate("alert('1')")
   #     browser.close()
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
-  # 
+  #
   # > NOTE: Dialogs are dismissed automatically, unless there is a [`event: Page.dialog`] listener. When listener is
   # present, it **must** either [`method: Dialog.accept`] or [`method: Dialog.dismiss`] the dialog - otherwise the page will
   # [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the dialog, and

data/lib/playwright_api/element_handle.rb

@@ -2,64 +2,13 @@ require_relative './js_handle.rb'
 
 module Playwright
   # - extends: `JSHandle`
-  # 
+  #
   # ElementHandle represents an in-page DOM element. ElementHandles can be created with the [`method: Page.querySelector`]
   # method.
-  # 
   #
-  # ```js
-  # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
-  # 
-  # (async () => {
-  #   const browser = await chromium.launch();
-  #   const page = await browser.newPage();
-  #   await page.goto('https://example.com');
-  #   const hrefElement = await page.$('a');
-  #   await hrefElement.click();
-  #   // ...
-  # })();
-  # ```
-  # 
-  # ```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();
-  #       page.navigate("https://example.com");
-  #       ElementHandle hrefElement = page.querySelector("a");
-  #       hrefElement.click();
-  #       // ...
-  #     }
-  #   }
-  # }
-  # ```
-  # 
-  # ```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()
-  #     await page.goto("https://example.com")
-  #     href_element = await page.query_selector("a")
-  #     await href_element.click()
-  #     # ...
-  # 
-  # 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()
@@ -68,47 +17,31 @@ module Playwright
   #     href_element = page.query_selector("a")
   #     href_element.click()
   #     # ...
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
-  # 
+  #
   # ElementHandle prevents DOM element from garbage collection unless the handle is disposed with
   # [`method: JSHandle.dispose`]. ElementHandles are auto-disposed when their origin frame gets navigated.
-  # 
+  #
   # ElementHandle instances can be used as an argument in [`method: Page.evalOnSelector`] and [`method: Page.evaluate`]
   # methods.
   class ElementHandle < JSHandle
 
     # This method returns the bounding box of the element, or `null` if the element is not visible. The bounding box is
     # calculated relative to the main frame viewport - which is usually the same as the browser window.
-    # 
+    #
     # Scrolling affects the returned bonding box, similarly to
     # [Element.getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect). That
     # means `x` and/or `y` may be negative.
-    # 
+    #
     # Elements from child frames return the bounding box relative to the main frame, unlike the
     # [Element.getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
-    # 
+    #
     # Assuming the page is static, it is safe to use bounding box coordinates to perform input. For example, the following
     # snippet should click the center of the element.
-    # 
     #
-    # ```js
-    # const box = await elementHandle.boundingBox();
-    # await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
-    # ```
-    # 
-    # ```java
-    # BoundingBox box = elementHandle.boundingBox();
-    # page.mouse().click(box.x + box.width / 2, box.y + box.height / 2);
-    # ```
-    # 
-    # ```python async
-    # box = await element_handle.bounding_box()
-    # await page.mouse.click(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
-    # ```
-    # 
     # ```python sync
     # box = element_handle.bounding_box()
     # page.mouse.click(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
@@ -125,13 +58,18 @@ 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.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    def check(force: nil, noWaitAfter: nil, position: nil, timeout: nil)
-      wrap_impl(@impl.check(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
+    def check(
+          force: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+      wrap_impl(@impl.check(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
     end
 
     # This method clicks the element by performing the following steps:
@@ -139,9 +77,9 @@ 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.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
     def click(
@@ -152,8 +90,9 @@ module Playwright
           modifiers: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
-      wrap_impl(@impl.click(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(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
 
     # Returns the content frame for element handles referencing iframe nodes, or `null` otherwise
@@ -167,12 +106,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.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    # 
+    #
     # > NOTE: `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
     def dblclick(
           button: nil,
@@ -181,34 +120,22 @@ module Playwright
           modifiers: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
-      wrap_impl(@impl.dblclick(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(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 elementHandle.dispatchEvent('click');
-    # ```
-    # 
-    # ```java
-    # elementHandle.dispatchEvent("click");
-    # ```
-    # 
-    # ```python async
-    # await element_handle.dispatch_event("click")
-    # ```
-    # 
     # ```python sync
     # element_handle.dispatch_event("click")
     # ```
-    # 
+    #
     # Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
     # and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
-    # 
+    #
     # 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)
@@ -217,30 +144,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 elementHandle.dispatchEvent('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);
-    # elementHandle.dispatchEvent("dragstart", arg);
-    # ```
-    # 
-    # ```python async
-    # # note you can only create data_transfer in chromium and firefox
-    # data_transfer = await page.evaluate_handle("new DataTransfer()")
-    # await element_handle.dispatch_event("#source", "dragstart", {"dataTransfer": data_transfer})
-    # ```
-    # 
     # ```python sync
     # # note you can only create data_transfer in chromium and firefox
     # data_transfer = page.evaluate_handle("new DataTransfer()")
@@ -251,35 +157,16 @@ module Playwright
     end
 
     # Returns the return value of `expression`.
-    # 
+    #
     # The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a first
     # argument to `expression`. See [Working with selectors](./selectors.md) for more details. If no elements match the
     # selector, the method throws an error.
-    # 
+    #
     # If `expression` returns a [Promise], then [`method: ElementHandle.evalOnSelector`] would wait for the promise to resolve
     # and return its value.
-    # 
+    #
     # Examples:
-    # 
     #
-    # ```js
-    # const tweetHandle = await page.$('.tweet');
-    # expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe('100');
-    # expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');
-    # ```
-    # 
-    # ```java
-    # ElementHandle tweetHandle = page.querySelector(".tweet");
-    # assertEquals("100", tweetHandle.evalOnSelector(".like", "node => node.innerText"));
-    # assertEquals("10", tweetHandle.evalOnSelector(".retweets", "node => node.innerText"));
-    # ```
-    # 
-    # ```python async
-    # tweet_handle = await page.query_selector(".tweet")
-    # assert await tweet_handle.eval_on_selector(".like", "node => node.innerText") == "100"
-    # assert await tweet_handle.eval_on_selector(".retweets", "node => node.innerText") = "10"
-    # ```
-    # 
     # ```python sync
     # tweet_handle = page.query_selector(".tweet")
     # assert tweet_handle.eval_on_selector(".like", "node => node.innerText") == "100"
@@ -290,38 +177,22 @@ module Playwright
     end
 
     # Returns the return value of `expression`.
-    # 
+    #
     # The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array of
     # matched elements as a first argument to `expression`. See [Working with selectors](./selectors.md) for more details.
-    # 
+    #
     # If `expression` returns a [Promise], then [`method: ElementHandle.evalOnSelectorAll`] would wait for the promise to
     # resolve and return its value.
-    # 
+    #
     # Examples:
-    # 
+    #
     # ```html
     # <div class="feed">
     #   <div class="tweet">Hello!</div>
     #   <div class="tweet">Hi!</div>
     # </div>
     # ```
-    # 
     #
-    # ```js
-    # const feedHandle = await page.$('.feed');
-    # expect(await feedHandle.$$eval('.tweet', nodes => nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!']);
-    # ```
-    # 
-    # ```java
-    # ElementHandle feedHandle = page.querySelector(".feed");
-    # assertEquals(Arrays.asList("Hello!", "Hi!"), feedHandle.evalOnSelectorAll(".tweet", "nodes => nodes.map(n => n.innerText)"));
-    # ```
-    # 
-    # ```python async
-    # feed_handle = await page.query_selector(".feed")
-    # assert await feed_handle.eval_on_selector_all(".tweet", "nodes => nodes.map(n => n.innerText)") == ["hello!", "hi!"]
-    # ```
-    # 
     # ```python sync
     # feed_handle = page.query_selector(".feed")
     # assert feed_handle.eval_on_selector_all(".tweet", "nodes => nodes.map(n => n.innerText)") == ["hello!", "hi!"]
@@ -331,10 +202,14 @@ module Playwright
     end
 
     # This method 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.
+    # 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: ElementHandle.type`].
     def fill(value, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.fill(unwrap_impl(value), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
@@ -355,13 +230,18 @@ 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.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    def hover(force: nil, modifiers: nil, position: nil, timeout: nil)
-      wrap_impl(@impl.hover(force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
+    def hover(
+          force: nil,
+          modifiers: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+      wrap_impl(@impl.hover(force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
     end
 
     # Returns the `element.innerHTML`.
@@ -410,21 +290,21 @@ 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.
     def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
@@ -444,7 +324,7 @@ module Playwright
     end
 
     # Returns the buffer with the captured screenshot.
-    # 
+    #
     # This method waits for the [actionability](./actionability.md) checks, then scrolls element into view before taking a
     # screenshot. If the element is detached from DOM, the method throws an error.
     def screenshot(
@@ -459,50 +339,24 @@ module Playwright
     # This method waits for [actionability](./actionability.md) checks, then tries to scroll element into view, unless it is
     # completely visible as defined by
     # [IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)'s `ratio`.
-    # 
+    #
     # Throws when `elementHandle` does not point to an element
     # [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
     def scroll_into_view_if_needed(timeout: nil)
       wrap_impl(@impl.scroll_into_view_if_needed(timeout: unwrap_impl(timeout)))
     end
 
+    # This method 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 element is not a `<select>`
-    # element, the method throws an error.
-    # 
-    # Will wait until all specified options are present in the `<select>` element.
-    # 
-    #
-    # ```js
-    # // single selection matching the value
-    # handle.selectOption('blue');
-    # 
-    # // single selection matching the label
-    # handle.selectOption({ label: 'Blue' });
-    # 
-    # // multiple selection
-    # handle.selectOption(['red', 'green', 'blue']);
-    # ```
-    # 
-    # ```java
-    # // single selection matching the value
-    # handle.selectOption("blue");
-    # // single selection matching the label
-    # handle.selectOption(new SelectOption().setLabel("Blue"));
-    # // multiple selection
-    # handle.selectOption(new String[] {"red", "green", "blue"});
-    # ```
-    # 
-    # ```python async
-    # # single selection matching the value
-    # await handle.select_option("blue")
-    # # single selection matching the label
-    # await handle.select_option(label="blue")
-    # # multiple selection
-    # await handle.select_option(value=["red", "green", "blue"])
-    # ```
-    # 
+    #
+    # Triggers a `change` and `input` event once all the provided options have been selected.
+    #
     # ```python sync
     # # single selection matching the value
     # handle.select_option("blue")
@@ -511,7 +365,7 @@ module Playwright
     # # multiple selection
     # handle.select_option(value=["red", "green", "blue"])
     # ```
-    # 
+    #
     # ```python sync
     # # single selection matching the value
     # handle.select_option("blue")
@@ -540,7 +394,7 @@ module Playwright
 
     # This method expects `elementHandle` 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(files, noWaitAfter: nil, timeout: nil)
@@ -553,20 +407,21 @@ 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.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    # 
+    #
     # > NOTE: `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.
     def tap_point(
           force: nil,
           modifiers: nil,
           noWaitAfter: nil,
           position: nil,
-          timeout: nil)
-      wrap_impl(@impl.tap_point(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(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 the `node.textContent`.
@@ -575,51 +430,16 @@ module Playwright
     end
 
     # Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
-    # 
+    #
     # To press a special key, like `Control` or `ArrowDown`, use [`method: ElementHandle.press`].
-    # 
     #
-    # ```js
-    # await elementHandle.type('Hello'); // Types instantly
-    # await elementHandle.type('World', {delay: 100}); // Types slower, like a user
-    # ```
-    # 
-    # ```java
-    # elementHandle.type("Hello"); // Types instantly
-    # elementHandle.type("World", new ElementHandle.TypeOptions().setDelay(100)); // Types slower, like a user
-    # ```
-    # 
-    # ```python async
-    # await element_handle.type("hello") # types instantly
-    # await element_handle.type("world", delay=100) # types slower, like a user
-    # ```
-    # 
     # ```python sync
     # element_handle.type("hello") # types instantly
     # element_handle.type("world", delay=100) # types slower, like a user
     # ```
-    # 
+    #
     # An example of typing into a text field and then submitting the form:
-    # 
     #
-    # ```js
-    # const elementHandle = await page.$('input');
-    # await elementHandle.type('some text');
-    # await elementHandle.press('Enter');
-    # ```
-    # 
-    # ```java
-    # ElementHandle elementHandle = page.querySelector("input");
-    # elementHandle.type("some text");
-    # elementHandle.press("Enter");
-    # ```
-    # 
-    # ```python async
-    # element_handle = await page.query_selector("input")
-    # await element_handle.type("some text")
-    # await element_handle.press("Enter")
-    # ```
-    # 
     # ```python sync
     # element_handle = page.query_selector("input")
     # element_handle.type("some text")
@@ -637,17 +457,22 @@ 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.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    def uncheck(force: nil, noWaitAfter: nil, position: nil, timeout: nil)
-      wrap_impl(@impl.uncheck(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
+    def uncheck(
+          force: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+      wrap_impl(@impl.uncheck(force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
     end
 
     # Returns when the element satisfies the `state`.
-    # 
+    #
     # Depending on the `state` parameter, this method waits for one of the [actionability](./actionability.md) checks to pass.
     # This method throws when the element is detached while waiting, unless waiting for the `"hidden"` state.
     # - `"visible"` Wait until the element is [visible](./actionability.md#visible).
@@ -658,7 +483,7 @@ module Playwright
     # - `"enabled"` Wait until the element is [enabled](./actionability.md#enabled).
     # - `"disabled"` Wait until the element is [not enabled](./actionability.md#enabled).
     # - `"editable"` Wait until the element is [editable](./actionability.md#editable).
-    # 
+    #
     # If the element does not satisfy the condition for the `timeout` milliseconds, this method will throw.
     def wait_for_element_state(state, timeout: nil)
       wrap_impl(@impl.wait_for_element_state(unwrap_impl(state), timeout: unwrap_impl(timeout)))
@@ -666,42 +491,19 @@ module Playwright
 
     # Returns element specified by selector when it satisfies `state` option. Returns `null` if waiting for `hidden` or
     # `detached`.
-    # 
+    #
     # Wait for the `selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom, or
     # become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the method
     # will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will
     # throw.
-    # 
     #
-    # ```js
-    # await page.setContent(`<div><span></span></div>`);
-    # const div = await page.$('div');
-    # // Waiting for the 'span' selector relative to the div.
-    # const span = await div.waitForSelector('span', { state: 'attached' });
-    # ```
-    # 
-    # ```java
-    # page.setContent("<div><span></span></div>");
-    # ElementHandle div = page.querySelector("div");
-    # // Waiting for the "span" selector relative to the div.
-    # ElementHandle span = div.waitForSelector("span", new ElementHandle.WaitForSelectorOptions()
-    #   .setState(WaitForSelectorState.ATTACHED));
-    # ```
-    # 
-    # ```python async
-    # await page.set_content("<div><span></span></div>")
-    # div = await page.query_selector("div")
-    # # waiting for the "span" selector relative to the div.
-    # span = await div.wait_for_selector("span", state="attached")
-    # ```
-    # 
     # ```python sync
     # page.set_content("<div><span></span></div>")
     # div = page.query_selector("div")
     # # waiting for the "span" selector relative to the div.
     # span = div.wait_for_selector("span", state="attached")
     # ```
-    # 
+    #
     # > NOTE: This method does not work across navigations, use [`method: Page.waitForSelector`] instead.
     def wait_for_selector(selector, state: nil, timeout: nil)
       wrap_impl(@impl.wait_for_selector(unwrap_impl(selector), state: unwrap_impl(state), timeout: unwrap_impl(timeout)))