playwright-ruby-client 0.5.10 → 0.6.0

data/lib/playwright_api/browser_type.rb

@@ -64,8 +64,46 @@ module Playwright
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
+  # 
+  # ```csharp
+  # using Microsoft.Playwright;
+  # using System.Threading.Tasks;
+  # 
+  # class BrowserTypeExamples
+  # {
+  #     public static async Task Run()
+  #     {
+  #         using var playwright = await Playwright.CreateAsync();
+  #         var chromium = playwright.Chromium;
+  #         var browser = await chromium.LaunchAsync();
+  #         var page = await browser.NewPageAsync();
+  #         await page.GoToAsync("https://www.bing.com");
+  #         // other actions
+  #         await browser.CloseAsync();
+  #     }
+  # }
+  # ```
   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)
@@ -100,6 +138,10 @@ module Playwright
     # )
     # ```
     # 
+    # ```csharp
+    # var browser = await playwright.Chromium.LaunchAsync(ignoreDefaultArgs: new[] { "--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,8 +173,9 @@ 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.
@@ -177,6 +220,7 @@ module Playwright
           slowMo: nil,
           timeout: nil,
           timezoneId: nil,
+          traceDir: nil,
           userAgent: nil,
           viewport: nil)
       raise NotImplementedError.new('launch_persistent_context is not implemented yet.')
@@ -187,11 +231,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 off(event, callback)

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

@@ -80,6 +80,29 @@ module Playwright
   #     run(playwright)
   # ```
   # 
+  # ```csharp
+  # using Microsoft.Playwright;
+  # using System.Threading.Tasks;
+  # 
+  # class DialogExample
+  # {
+  #     public static async Task Run()
+  #     {
+  #         using var playwright = await Playwright.CreateAsync();
+  #         await using var browser = await playwright.Chromium.LaunchAsync();
+  #         var page = await browser.NewPageAsync();
+  # 
+  #         page.Dialog += async (_, dialog) =>
+  #         {
+  #             System.Console.WriteLine(dialog.Message);
+  #             await dialog.DismissAsync();
+  #         };
+  # 
+  #         await page.EvaluateAsync("alert('1');");
+  #     }
+  # }
+  # ```
+  # 
   # > 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

@@ -73,6 +73,24 @@ module Playwright
   #     run(playwright)
   # ```
   # 
+  # ```csharp
+  # using Microsoft.Playwright;
+  # using System.Threading.Tasks;
+  # 
+  # class HandleExamples
+  # {
+  #     public static async Task Run()
+  #     {
+  #         using var playwright = await Playwright.CreateAsync();
+  #         var browser = await playwright.Chromium.LaunchAsync(headless: false);
+  #         var page = await browser.NewPageAsync();
+  #         await page.GotoAsync("https://www.bing.com");
+  #         var handle = await page.QuerySelectorAsync("a");
+  #         await handle.ClickAsync();
+  #     }
+  # }
+  # ```
+  # 
   # 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.
   # 
@@ -113,6 +131,11 @@ module Playwright
     # box = element_handle.bounding_box()
     # page.mouse.click(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
     # ```
+    # 
+    # ```csharp
+    # var box = await elementHandle.BoundingBoxAsync();
+    # await page.Mouse.ClickAsync(box.X + box.Width / 2, box.Y + box.Height / 2);
+    # ```
     def bounding_box
       wrap_impl(@impl.bounding_box)
     end
@@ -130,8 +153,13 @@ module Playwright
     # 
     # 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:
@@ -152,8 +180,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
@@ -181,8 +210,9 @@ 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,
@@ -206,6 +236,10 @@ module Playwright
     # element_handle.dispatch_event("click")
     # ```
     # 
+    # ```csharp
+    # await elementHandle.DispatchEventAsync("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.
     # 
@@ -246,6 +280,14 @@ module Playwright
     # data_transfer = page.evaluate_handle("new DataTransfer()")
     # element_handle.dispatch_event("#source", "dragstart", {"dataTransfer": data_transfer})
     # ```
+    # 
+    # ```csharp
+    # var handle = await page.EvaluateHandleAsync("() => new DataTransfer()");
+    # await handle.AsElement.DispatchEventAsync("dragstart", new Dictionary<string, object>
+    # {
+    #     { "dataTransfer", dataTransfer }
+    # });
+    # ```
     def dispatch_event(type, eventInit: nil)
       wrap_impl(@impl.dispatch_event(unwrap_impl(type), eventInit: unwrap_impl(eventInit)))
     end
@@ -285,6 +327,12 @@ module Playwright
     # assert tweet_handle.eval_on_selector(".like", "node => node.innerText") == "100"
     # assert tweet_handle.eval_on_selector(".retweets", "node => node.innerText") = "10"
     # ```
+    # 
+    # ```csharp
+    # var tweetHandle = await page.QuerySelectorAsync(".tweet");
+    # Assert.Equals("100", await tweetHandle.EvalOnSelectorAsync(".like", "node => node.innerText"));
+    # Assert.Equals("10", await tweetHandle.EvalOnSelectorAsync(".retweets", "node => node.innerText"));
+    # ```
     def eval_on_selector(selector, expression, arg: nil)
       wrap_impl(@impl.eval_on_selector(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
@@ -326,15 +374,24 @@ module Playwright
     # feed_handle = page.query_selector(".feed")
     # assert feed_handle.eval_on_selector_all(".tweet", "nodes => nodes.map(n => n.innerText)") == ["hello!", "hi!"]
     # ```
+    # 
+    # ```csharp
+    # var feedHandle = await page.QuerySelectorAsync(".feed");
+    # Assert.Equals(new [] { "Hello!", "Hi!" }, await feedHandle.EvalOnSelectorAllAsync<string[]>(".tweet", "nodes => nodes.map(n => n.innerText)"));
+    # ```
     def eval_on_selector_all(selector, expression, arg: nil)
       wrap_impl(@impl.eval_on_selector_all(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
     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
@@ -360,8 +417,13 @@ module Playwright
     # 
     # 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`.
@@ -466,12 +528,16 @@ module Playwright
       wrap_impl(@impl.scroll_into_view_if_needed(timeout: unwrap_impl(timeout)))
     end
 
-    # Returns the array of option values that have been successfully selected.
+    # 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.
     # 
-    # 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.
+    # Returns the array of option values that have been successfully selected.
     # 
-    # Will wait until all specified options are present in the `<select>` element.
+    # Triggers a `change` and `input` event once all the provided options have been selected.
     # 
     #
     # ```js
@@ -522,6 +588,20 @@ module Playwright
     # # multiple selection for blue, red and second option
     # handle.select_option(value="blue", { index: 2 }, "red")
     # ```
+    # 
+    # ```csharp
+    # // single selection matching the value
+    # await handle.SelectOptionAsync(new[] { "blue" });
+    # // single selection matching the label
+    # await handle.SelectOptionAsync(new[] { new SelectOptionValue() { Label = "blue" } });
+    # // multiple selection
+    # await handle.SelectOptionAsync(new[] { "red", "green", "blue" });
+    # // multiple selection for blue, red and second option
+    # await handle.SelectOptionAsync(new[] {
+    #     new SelectOptionValue() { Label = "blue" },
+    #     new SelectOptionValue() { Index = 2 },
+    #     new SelectOptionValue() { Value = "red" }});
+    # ```
     def select_option(
           element: nil,
           index: nil,
@@ -565,8 +645,9 @@ module Playwright
           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`.
@@ -599,6 +680,11 @@ module Playwright
     # element_handle.type("world", delay=100) # types slower, like a user
     # ```
     # 
+    # ```csharp
+    # await elementHandle.TypeAsync("Hello"); // Types instantly
+    # await elementHandle.TypeAsync("World", delay: 100); // Types slower, like a user
+    # ```
+    # 
     # An example of typing into a text field and then submitting the form:
     # 
     #
@@ -625,6 +711,12 @@ module Playwright
     # element_handle.type("some text")
     # element_handle.press("Enter")
     # ```
+    # 
+    # ```csharp
+    # var elementHandle = await page.QuerySelectorAsync("input");
+    # await elementHandle.TypeAsync("some text");
+    # await elementHandle.PressAsync("Enter");
+    # ```
     def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
@@ -642,8 +734,13 @@ module Playwright
     # 
     # 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`.
@@ -702,6 +799,13 @@ module Playwright
     # span = div.wait_for_selector("span", state="attached")
     # ```
     # 
+    # ```csharp
+    # await page.SetContentAsync("<div><span></span></div>");
+    # var div = await page.QuerySelectorAsync("div");
+    # // Waiting for the "span" selector relative to the div.
+    # var span = await page.WaitForSelectorAsync("span", WaitForSelectorState.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)))

data/lib/playwright_api/file_chooser.rb

@@ -28,6 +28,13 @@ module Playwright
   # file_chooser = fc_info.value
   # file_chooser.set_files("myfile.pdf")
   # ```
+  # 
+  # ```csharp
+  # var waitForFileChooserTask = page.WaitForFileChooserAsync();
+  # await page.ClickAsync("upload");
+  # var fileChooser = await waitForFileChooserTask;
+  # await fileChooser.SetFilesAsync("temp.txt");
+  # ```
   class FileChooser < PlaywrightApi
 
     # Returns input element associated with this file chooser.

data/lib/playwright_api/frame.rb

@@ -96,6 +96,32 @@ module Playwright
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
+  # 
+  # ```csharp
+  # using Microsoft.Playwright;
+  # using System;
+  # using System.Threading.Tasks;
+  # 
+  # class FrameExamples
+  # {
+  #     public static async Task Main()
+  #     {
+  #         using var playwright = await Playwright.CreateAsync();
+  #         await using var browser = await playwright.Firefox.LaunchAsync();
+  #         var page = await browser.NewPageAsync();
+  # 
+  #         await page.GotoAsync("https://www.bing.com");
+  #         DumpFrameTree(page.MainFrame, string.Empty);
+  #     }
+  # 
+  #     private static void DumpFrameTree(IFrame frame, string indent)
+  #     {
+  #         Console.WriteLine($"{indent}{frame.Url}");
+  #         foreach (var child in frame.ChildFrames)
+  #             DumpFrameTree(child, indent + " ");
+  #     }
+  # }
+  # ```
   class Frame < PlaywrightApi
 
     # Returns the added tag when the script's onload fires or when the script content was injected into frame.
@@ -131,8 +157,9 @@ module Playwright
           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
 
     def child_frames
@@ -158,8 +185,9 @@ 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
 
     # Gets the full HTML contents of the frame, including the doctype.
@@ -188,8 +216,9 @@ 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,
@@ -213,6 +242,10 @@ module Playwright
     # frame.dispatch_event("button#submit", "click")
     # ```
     # 
+    # ```csharp
+    # await frame.DispatchEventAsync("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.
     # 
@@ -253,6 +286,12 @@ module Playwright
     # data_transfer = frame.evaluate_handle("new DataTransfer()")
     # frame.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
     # ```
+    # 
+    # ```csharp
+    # // Note you can only create DataTransfer in Chromium and Firefox
+    # var dataTransfer = await frame.EvaluateHandleAsync("() => new DataTransfer()");
+    # await frame.DispatchEventAsync("#source", "dragstart", new { dataTransfer });
+    # ```
     def dispatch_event(selector, type, eventInit: nil, timeout: nil)
       wrap_impl(@impl.dispatch_event(unwrap_impl(selector), unwrap_impl(type), eventInit: unwrap_impl(eventInit), timeout: unwrap_impl(timeout)))
     end
@@ -292,6 +331,12 @@ module Playwright
     # preload_href = frame.eval_on_selector("link[rel=preload]", "el => el.href")
     # html = frame.eval_on_selector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello")
     # ```
+    # 
+    # ```csharp
+    # var searchValue = await frame.EvalOnSelectorAsync<string>("#search", "el => el.value");
+    # var preloadHref = await frame.EvalOnSelectorAsync<string>("link[rel=preload]", "el => el.href");
+    # var html = await frame.EvalOnSelectorAsync(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello");
+    # ```
     def eval_on_selector(selector, expression, arg: nil)
       wrap_impl(@impl.eval_on_selector(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
@@ -322,6 +367,10 @@ module Playwright
     # ```python sync
     # divs_counts = frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
     # ```
+    # 
+    # ```csharp
+    # var divsCount = await frame.EvalOnSelectorAllAsync<bool>("div", "(divs, min) => divs.length >= min", 10);
+    # ```
     def eval_on_selector_all(selector, expression, arg: nil)
       wrap_impl(@impl.eval_on_selector_all(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
@@ -360,6 +409,11 @@ module Playwright
     # print(result) # prints "56"
     # ```
     # 
+    # ```csharp
+    # var result = await frame.EvaluateAsync<int>("([x, y]) => Promise.resolve(x * y)", new[] { 7, 8 });
+    # Console.WriteLine(result);
+    # ```
+    # 
     # A string can also be passed in instead of a function.
     # 
     #
@@ -383,6 +437,10 @@ module Playwright
     # print(frame.evaluate(f"1 + {x}")) # prints "11"
     # ```
     # 
+    # ```csharp
+    # Console.WriteLine(await frame.EvaluateAsync<int>("1 + 2")); // prints "3"
+    # ```
+    # 
     # `ElementHandle` instances can be passed as an argument to the [`method: Frame.evaluate`]:
     # 
     #
@@ -409,6 +467,12 @@ module Playwright
     # html = frame.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
     # body_handle.dispose()
     # ```
+    # 
+    # ```csharp
+    # var bodyHandle = await frame.QuerySelectorAsync("body");
+    # var html = await frame.EvaluateAsync<string>("([body, suffix]) => body.innerHTML + suffix", new object [] { bodyHandle, "hello" });
+    # await bodyHandle.DisposeAsync();
+    # ```
     def evaluate(expression, arg: nil)
       wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
@@ -442,6 +506,11 @@ module Playwright
     # a_window_handle # handle for the window object.
     # ```
     # 
+    # ```csharp
+    # // Handle for the window object.
+    # var aWindowHandle = await frame.EvaluateHandleAsync("() => Promise.resolve(window)");
+    # ```
+    # 
     # A string can also be passed in instead of a function.
     # 
     #
@@ -461,6 +530,10 @@ module Playwright
     # a_handle = page.evaluate_handle("document") # handle for the "document"
     # ```
     # 
+    # ```csharp
+    # var docHandle = await frame.EvalueHandleAsync("document"); // Handle for the `document`
+    # ```
+    # 
     # `JSHandle` instances can be passed as an argument to the [`method: Frame.evaluateHandle`]:
     # 
     #
@@ -491,15 +564,25 @@ module Playwright
     # print(result_handle.json_value())
     # result_handle.dispose()
     # ```
+    # 
+    # ```csharp
+    # var handle = await frame.EvaluateHandleAsync("() => document.body");
+    # var resultHandle = await frame.EvaluateHandleAsync("([body, suffix]) => body.innerHTML + suffix", new object[] { handle, "hello" });
+    # Console.WriteLine(await resultHandle.JsonValueAsync<string>());
+    # await resultHandle.DisposeAsync();
+    # ```
     def evaluate_handle(expression, arg: nil)
       wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
     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: Frame.type`].
     def fill(selector, value, noWaitAfter: nil, timeout: nil)
@@ -543,6 +626,12 @@ module Playwright
     # content_frame = frame_element.content_frame()
     # assert frame == content_frame
     # ```
+    # 
+    # ```csharp
+    # var frameElement = await frame.FrameElementAsync();
+    # var contentFrame = await frameElement.ContentFrameAsync();
+    # Console.WriteLine(frame == contentFrame); // -> True
+    # ```
     def frame_element
       wrap_impl(@impl.frame_element)
     end
@@ -589,8 +678,9 @@ module Playwright
           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`.
@@ -700,12 +790,16 @@ module Playwright
       wrap_impl(@impl.query_selector_all(unwrap_impl(selector)))
     end
 
-    # Returns the array of option values that have been successfully selected.
+    # 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.
     # 
-    # 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.
+    # 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.
     # 
-    # Will wait until all specified options are present in the `<select>` element.
+    # 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.
     # 
     #
     # ```js
@@ -745,6 +839,15 @@ module Playwright
     # # multiple selection
     # frame.select_option("select#colors", value=["red", "green", "blue"])
     # ```
+    # 
+    # ```csharp
+    # // single selection matching the value
+    # await frame.SelectOptionAsync("select#colors", new[] { "blue" });
+    # // single selection matching both the value and the label
+    # await frame.SelectOptionAsync("select#colors", new[] { new SelectOptionValue() { Label = "blue" } });
+    # // multiple selection
+    # await frame.SelectOptionAsync("select#colors", new[] { "red", "green", "blue" });
+    # ```
     def select_option(
           selector,
           element: nil,
@@ -788,8 +891,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`.
@@ -829,6 +933,11 @@ module Playwright
     # frame.type("#mytextarea", "hello") # types instantly
     # frame.type("#mytextarea", "world", delay=100) # types slower, like a user
     # ```
+    # 
+    # ```csharp
+    # await frame.TypeAsync("#mytextarea", "hello"); // types instantly
+    # await frame.TypeAsync("#mytextarea", "world", delay: 100); // types slower, like a user
+    # ```
     def type(
           selector,
           text,
@@ -856,8 +965,9 @@ module Playwright
           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
 
     # Returns frame's url.
@@ -933,6 +1043,23 @@ module Playwright
     #     run(playwright)
     # ```
     # 
+    # ```csharp
+    # using Microsoft.Playwright;
+    # using System.Threading.Tasks;
+    # 
+    # class FrameExamples
+    # {
+    #     public static async Task Main()
+    #     {
+    #         using var playwright = await Playwright.CreateAsync();
+    #         await using var browser = await playwright.Firefox.LaunchAsync();
+    #         var page = await browser.NewPageAsync();
+    #         await page.SetViewportSizeAsync(50, 50);
+    #         await page.MainFrame.WaitForFunctionAsync("window.innerWidth < 100");
+    #     }
+    # }
+    # ```
+    # 
     # To pass an argument to the predicate of `frame.waitForFunction` function:
     # 
     #
@@ -955,6 +1082,11 @@ module Playwright
     # selector = ".foo"
     # frame.wait_for_function("selector => !!document.querySelector(selector)", selector)
     # ```
+    # 
+    # ```csharp
+    # var selector = ".foo";
+    # await page.MainFrame.WaitForFunctionAsync("selector => !!document.querySelector(selector)", selector);
+    # ```
     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
@@ -984,6 +1116,11 @@ module Playwright
     # frame.click("button") # click triggers navigation.
     # frame.wait_for_load_state() # the promise resolves after "load" event.
     # ```
+    # 
+    # ```csharp
+    # await frame.ClickAsync("button");
+    # await frame.WaitForLoadStateAsync(); // Defaults to LoadState.Load
+    # ```
     def wait_for_load_state(state: nil, timeout: nil)
       wrap_impl(@impl.wait_for_load_state(state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
     end
@@ -1023,6 +1160,14 @@ module Playwright
     # # Resolves after navigation has finished
     # ```
     # 
+    # ```csharp
+    # await Task.WhenAll(
+    #     frame.WaitForNavigationAsync(),
+    #     // clicking the link will indirectly cause a navigation
+    #     frame.ClickAsync("a.delayed-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.
     def expect_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
@@ -1110,6 +1255,29 @@ module Playwright
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
+    # 
+    # ```csharp
+    # using Microsoft.Playwright;
+    # using System;
+    # using System.Threading.Tasks;
+    # 
+    # class FrameExamples
+    # {
+    #   public static async Task Main()
+    #   {
+    #     using var playwright = await Playwright.CreateAsync();
+    #     await using var browser = await playwright.Chromium.LaunchAsync();
+    #     var page = await browser.NewPageAsync();
+    # 
+    #     foreach (var currentUrl in new[] { "https://www.google.com", "https://bbc.com" })
+    #     {
+    #       await page.GotoAsync(currentUrl);
+    #       element = await page.MainFrame.WaitForSelectorAsync("img");
+    #       Console.WriteLine($"Loaded image: {await element.GetAttributeAsync("src")}");
+    #     }
+    #   }
+    # }
+    # ```
     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)))
     end
@@ -1144,6 +1312,11 @@ module Playwright
     # frame.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
     # frame.wait_for_url("**/target.html")
     # ```
+    # 
+    # ```csharp
+    # await frame.ClickAsync("a.delayed-navigation"); // clicking the link will indirectly cause a navigation
+    # await frame.WaitForURLAsync("**/target.html");
+    # ```
     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