playwright-ruby-client 0.5.10 → 0.6.0

data/lib/playwright_api/js_handle.rb

@@ -23,6 +23,10 @@ module Playwright
   # # ...
   # ```
   # 
+  # ```csharp
+  # var windowHandle = await page.EvaluateHandleAsync("() => window");
+  # ```
+  # 
   # JSHandle prevents the referenced JavaScript object being garbage collected unless the handle is exposed with
   # [`method: JSHandle.dispose`]. JSHandles are auto-disposed when their origin frame gets navigated or the parent context
   # gets destroyed.
@@ -69,6 +73,11 @@ module Playwright
     # tweet_handle = page.query_selector(".tweet .retweets")
     # assert tweet_handle.evaluate("node => node.innerText") == "10 retweets"
     # ```
+    # 
+    # ```csharp
+    # var tweetHandle = await page.QuerySelectorAsync(".tweet .retweets");
+    # Assert.Equals("10 retweets", await tweetHandle.EvaluateAsync("node => node.innerText"));
+    # ```
     def evaluate(expression, arg: nil)
       wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
@@ -122,6 +131,14 @@ module Playwright
     # document_handle = properties.get("document")
     # handle.dispose()
     # ```
+    # 
+    # ```csharp
+    # var handle = await page.EvaluateHandleAsync("() => ({window, document}");
+    # var properties = await handle.GetPropertiesAsync();
+    # var windowHandle = properties["window"];
+    # var documentHandle = properties["document"];
+    # await handle.DisposeAsync();
+    # ```
     def get_properties
       wrap_impl(@impl.get_properties)
     end

data/lib/playwright_api/keyboard.rb

@@ -54,6 +54,20 @@ module Playwright
   # # result text will end up saying "Hello!"
   # ```
   # 
+  # ```csharp
+  # await page.Keyboard.TypeAsync("Hello World!");
+  # await page.Keyboard.PressAsync("ArrowLeft");
+  # 
+  # await page.Keyboard.DownAsync("Shift");
+  # for (int i = 0; i < " World".Length; i++)
+  #     await page.Keyboard.PressAsync("ArrowLeft");
+  # 
+  # await page.Keyboard.UpAsync("Shift");
+  # 
+  # await page.Keyboard.PressAsync("Backspace");
+  # // Result text will end up saying "Hello!"
+  # ```
+  # 
   # An example of pressing uppercase `A`
   # 
   #
@@ -81,6 +95,12 @@ module Playwright
   # page.keyboard.press("Shift+A")
   # ```
   # 
+  # ```csharp
+  # await page.Keyboard.PressAsync("Shift+KeyA");
+  # // or 
+  # await page.Keyboard.PressAsync("Shift+A");
+  # ```
+  # 
   # An example to trigger select-all with the keyboard
   # 
   #
@@ -111,6 +131,13 @@ module Playwright
   # # on mac_os
   # page.keyboard.press("Meta+A")
   # ```
+  # 
+  # ```csharp
+  # // on Windows and Linux
+  # await page.Keyboard.PressAsync("Control+A");
+  # // on macOS
+  # await page.Keyboard.PressAsync("Meta+A");
+  # ```
   class Keyboard < PlaywrightApi
 
     # Dispatches a `keydown` event.
@@ -160,6 +187,10 @@ module Playwright
     # page.keyboard.insert_text("嗨")
     # ```
     # 
+    # ```csharp
+    # await page.Keyboard.PressAsync("嗨");
+    # ```
+    # 
     # > NOTE: Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper case.
     def insert_text(text)
       wrap_impl(@impl.insert_text(unwrap_impl(text)))
@@ -231,6 +262,17 @@ module Playwright
     # browser.close()
     # ```
     # 
+    # ```csharp
+    # await page.GotoAsync("https://keycode.info");
+    # await page.Keyboard.PressAsync("A");
+    # await page.ScreenshotAsync("A.png");
+    # await page.Keyboard.PressAsync("ArrowLeft");
+    # await page.ScreenshotAsync("ArrowLeft.png");
+    # await page.Keyboard.PressAsync("Shift+O");
+    # await page.ScreenshotAsync("O.png");
+    # await browser.CloseAsync();
+    # ```
+    # 
     # Shortcut for [`method: Keyboard.down`] and [`method: Keyboard.up`].
     def press(key, delay: nil)
       wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay)))
@@ -263,7 +305,13 @@ module Playwright
     # page.keyboard.type("World", delay=100) # types slower, like a user
     # ```
     # 
+    # ```csharp
+    # await page.Keyboard.TypeAsync("Hello"); // types instantly
+    # await page.Keyboard.TypeAsync("World"); // types slower, like a user
+    # ```
+    # 
     # > NOTE: Modifier keys DO NOT effect `keyboard.type`. Holding down `Shift` will not type the text in upper case.
+    # > NOTE: For characters that are not on a US keyboard, only an `input` event will be sent.
     def type(text, delay: nil)
       wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay)))
     end

data/lib/playwright_api/page.rb

@@ -74,6 +74,23 @@ module Playwright
   #     run(playwright)
   # ```
   # 
+  # ```csharp
+  # using Microsoft.Playwright;
+  # using System.Threading.Tasks;
+  # 
+  # class PageExamples
+  # {
+  #     public static async Task Run()
+  #     {
+  #         using var playwright = await Playwright.CreateAsync();
+  #         await using var browser = await playwright.Webkit.LaunchAsync();
+  #         var page = await browser.NewPageAsync();
+  #         await page.GotoAsync("https://www.theverge.com");
+  #         await page.ScreenshotAsync("theverge.png");
+  #     }
+  # }
+  # ```
+  # 
   # 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`.
@@ -93,6 +110,10 @@ module Playwright
   # page.once("load", lambda: print("page loaded!"))
   # ```
   # 
+  # ```csharp
+  # page.Load += (_, _) => Console.WriteLine("Page loaded!");
+  # ```
+  # 
   # To unsubscribe from events use the `removeListener` method:
   # 
   #
@@ -121,6 +142,16 @@ module Playwright
   # # sometime later...
   # page.remove_listener("request", log_request)
   # ```
+  # 
+  # ```csharp
+  # void PageLoadHandler(object _, IPage p) {
+  #     Console.WriteLine("Page loaded!");
+  # };
+  # 
+  # page.Load += PageLoadHandler;
+  # // Do some work...
+  # page.Load -= PageLoadHandler;
+  # ```
   class Page < PlaywrightApi
 
     def accessibility # property
@@ -176,6 +207,10 @@ module Playwright
     # page.add_init_script(path="./preload.js")
     # ```
     # 
+    # ```csharp
+    # await page.AddInitScriptAsync(scriptPath: "./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)
@@ -223,8 +258,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
 
     # This method clicks an element matching `selector` by performing the following steps:
@@ -248,8 +284,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
 
     # If `runBeforeUnload` is `false`, does not run any unload handlers and waits for the page to be closed. If
@@ -296,8 +333,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,
@@ -321,6 +359,10 @@ module Playwright
     # page.dispatch_event("button#submit", "click")
     # ```
     # 
+    # ```csharp
+    # await page.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.
     # 
@@ -361,10 +403,18 @@ module Playwright
     # data_transfer = page.evaluate_handle("new DataTransfer()")
     # page.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
     # ```
+    # 
+    # ```csharp
+    # var dataTransfer = await page.EvaluateHandleAsync("() => new DataTransfer()");
+    # await page.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
 
+    # 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);
@@ -442,6 +492,25 @@ module Playwright
     # # → False
     # ```
     # 
+    # ```csharp
+    # await page.EvaluateAsync("() => matchMedia('screen').matches");
+    # // → true
+    # await page.EvaluateAsync("() => matchMedia('print').matches");
+    # // → false
+    # 
+    # await page.EmulateMediaAsync(Media.Print);
+    # await page.EvaluateAsync("() => matchMedia('screen').matches");
+    # // → false
+    # await page.EvaluateAsync("() => matchMedia('print').matches");
+    # // → true
+    # 
+    # await page.EmulateMediaAsync(Media.Screen);
+    # await page.EvaluateAsync("() => matchMedia('screen').matches");
+    # // → true
+    # await page.EvaluateAsync("() => matchMedia('print').matches");
+    # // → false
+    # ```
+    # 
     #
     # ```js
     # await page.emulateMedia({ colorScheme: 'dark' });
@@ -481,6 +550,16 @@ module Playwright
     # # → False
     # page.evaluate("matchMedia('(prefers-color-scheme: no-preference)').matches")
     # ```
+    # 
+    # ```csharp
+    # await page.EmulateMediaAsync(colorScheme: ColorScheme.Dark);
+    # await page.EvaluateAsync("matchMedia('(prefers-color-scheme: dark)').matches");
+    # // → true
+    # await page.EvaluateAsync("matchMedia('(prefers-color-scheme: light)').matches");
+    # // → false
+    # await page.EvaluateAsync("matchMedia('(prefers-color-scheme: no-preference)').matches");
+    # // → false
+    # ```
     def emulate_media(colorScheme: nil, media: nil)
       wrap_impl(@impl.emulate_media(colorScheme: unwrap_impl(colorScheme), media: unwrap_impl(media)))
     end
@@ -518,6 +597,12 @@ module Playwright
     # html = page.eval_on_selector(".main-container", "(e, suffix) => e.outer_html + suffix", "hello")
     # ```
     # 
+    # ```csharp
+    # var searchValue = await page.EvalOnSelectorAsync<string>("#search", "el => el.value");
+    # var preloadHref = await page.EvalOnSelectorAsync<string>("link[rel=preload]", "el => el.href");
+    # var html = await page.EvalOnSelectorAsync(".main-container", "(e, suffix) => e.outerHTML + 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)))
@@ -547,6 +632,10 @@ module Playwright
     # ```python sync
     # div_counts = page.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
     # ```
+    # 
+    # ```csharp
+    # var divsCount = await page.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
@@ -587,6 +676,11 @@ module Playwright
     # print(result) # prints "56"
     # ```
     # 
+    # ```csharp
+    # var result = await page.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:
     # 
     #
@@ -612,6 +706,10 @@ module Playwright
     # print(page.evaluate(f"1 + {x}")) # prints "11"
     # ```
     # 
+    # ```csharp
+    # Console.WriteLine(await page.EvaluateAsync<int>("1 + 2")); // prints "3"
+    # ```
+    # 
     # `ElementHandle` instances can be passed as an argument to the [`method: Page.evaluate`]:
     # 
     #
@@ -639,6 +737,12 @@ module Playwright
     # body_handle.dispose()
     # ```
     # 
+    # ```csharp
+    # var bodyHandle = await page.QuerySelectorAsync("body");
+    # var html = await page.EvaluateAsync<string>("([body, suffix]) => body.innerHTML + suffix", new object [] { bodyHandle, "hello" });
+    # await bodyHandle.DisposeAsync();
+    # ```
+    # 
     # Shortcut for main frame's [`method: Frame.evaluate`].
     def evaluate(expression, arg: nil)
       wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
@@ -673,6 +777,11 @@ module Playwright
     # a_window_handle # handle for the window object.
     # ```
     # 
+    # ```csharp
+    # // Handle for the window object.
+    # var aWindowHandle = await page.EvaluateHandleAsync("() => Promise.resolve(window)");
+    # ```
+    # 
     # A string can also be passed in instead of a function:
     # 
     #
@@ -692,6 +801,10 @@ module Playwright
     # a_handle = page.evaluate_handle("document") # handle for the "document"
     # ```
     # 
+    # ```csharp
+    # var docHandle = await page.EvalueHandleAsync("document"); // Handle for the `document`
+    # ```
+    # 
     # `JSHandle` instances can be passed as an argument to the [`method: Page.evaluateHandle`]:
     # 
     #
@@ -722,6 +835,13 @@ module Playwright
     # print(result_handle.json_value())
     # result_handle.dispose()
     # ```
+    # 
+    # ```csharp
+    # var handle = await page.EvaluateHandleAsync("() => document.body");
+    # var resultHandle = await page.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
@@ -836,6 +956,32 @@ module Playwright
     #     run(playwright)
     # ```
     # 
+    # ```csharp
+    # using Microsoft.Playwright;
+    # using System.Threading.Tasks;
+    # 
+    # class PageExamples
+    # {
+    #   public static async Task Main()
+    #   {
+    #       using var playwright = await Playwright.CreateAsync();
+    #       await using var browser = await playwright.Webkit.LaunchAsync(headless: false);
+    #       var page = await browser.NewPageAsync();
+    # 
+    #       await page.ExposeBindingAsync("pageUrl", (source) => source.Page.Url);
+    #       await page.SetContentAsync("<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>");
+    # 
+    #       await page.ClickAsync("button");
+    #   }
+    # }
+    # ```
+    # 
     # An example of passing an element handle:
     # 
     #
@@ -893,6 +1039,23 @@ module Playwright
     #   <div>Or click me</div>
     # """)
     # ```
+    # 
+    # ```csharp
+    # var result = new TaskCompletionSource<string>();
+    # await page.ExposeBindingAsync("clicked", async (BindingSource _, IJSHandle t) =>
+    # {
+    #     return result.TrySetResult(await t.AsElement.TextContentAsync());
+    # });
+    # 
+    # await page.SetContentAsync("<script>\n" +
+    #   "  document.addEventListener('click', event => window.clicked(event.target));\n" +
+    #   "</script>\n" +
+    #   "<div>Click me</div>\n" +
+    #   "<div>Or click me</div>\n");
+    # 
+    # await page.ClickAsync("div");
+    # Console.WriteLine(await result.Task);
+    # ```
     def expose_binding(name, callback, handle: nil)
       wrap_impl(@impl.expose_binding(unwrap_impl(name), unwrap_impl(callback), handle: unwrap_impl(handle)))
     end
@@ -1030,19 +1193,58 @@ module Playwright
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
+    # 
+    # ```csharp
+    # using Microsoft.Playwright;
+    # using System;
+    # using System.Security.Cryptography;
+    # using System.Threading.Tasks;
+    # 
+    # class PageExamples
+    # {
+    #   public static async Task Main()
+    #   {
+    #       using var playwright = await Playwright.CreateAsync();
+    #       await using var browser = await playwright.Webkit.LaunchAsync(headless: false); 
+    #       var page = await browser.NewPageAsync();
+    # 
+    #       // NOTE: md5 is inherently insecure, and we strongly discourage using
+    #       // this in production in any shape or form
+    #       await page.ExposeFunctionAsync("sha1", (string input) =>
+    #       {
+    #           return Convert.ToBase64String(
+    #               MD5.Create().ComputeHash(System.Text.Encoding.UTF8.GetBytes(input)));
+    #       });
+    # 
+    #       await page.SetContentAsync("<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>");
+    # 
+    #       await page.ClickAsync("button");
+    #       Console.WriteLine(await page.TextContentAsync("div"));
+    #   }
+    # }
+    # ```
     def expose_function(name, callback)
       wrap_impl(@impl.expose_function(unwrap_impl(name), unwrap_impl(callback)))
     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
@@ -1070,6 +1272,10 @@ module Playwright
     # frame = page.frame(name="frame-name")
     # ```
     # 
+    # ```csharp
+    # var frame = page.Frame("frame-name");
+    # ```
+    # 
     #
     # ```js
     # const frame = page.frame({ url: /.*domain.*/ });
@@ -1082,6 +1288,10 @@ module Playwright
     # ```py
     # frame = page.frame(url=r".*domain.*")
     # ```
+    # 
+    # ```csharp
+    # var frame = page.FrameByUrl(".*domain.*");
+    # ```
     def frame(name: nil, url: nil)
       wrap_impl(@impl.frame(name: unwrap_impl(name), url: unwrap_impl(url)))
     end
@@ -1153,8 +1363,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`.
@@ -1262,6 +1473,12 @@ module Playwright
     # page.pdf(path="page.pdf")
     # ```
     # 
+    # ```csharp
+    # // Generates a PDF with 'screen' media type
+    # await page.EmulateMediaAsync(Media.Screen);
+    # await page.PdfAsync("page.pdf");
+    # ```
+    # 
     # The `width`, `height`, and `margin` options accept values labeled with units. Unlabeled values are treated as pixels.
     # 
     # A few examples:
@@ -1373,6 +1590,18 @@ module Playwright
     # page.screenshot(path="o.png")
     # browser.close()
     # ```
+    # 
+    # ```csharp
+    # await using var browser = await playwright.Webkit.LaunchAsync(headless: false);
+    # var page = await browser.NewPageAsync();
+    # await page.GotoAsync("https://keycode.info");
+    # await page.PressAsync("body", "A");
+    # await page.ScreenshotAsync("A.png");
+    # await page.PressAsync("body", "ArrowLeft");
+    # await page.ScreenshotAsync("ArrowLeft.png");
+    # await page.PressAsync("body", "Shift+O");
+    # await page.ScreenshotAsync("O.png");
+    # ```
     def press(
           selector,
           key,
@@ -1383,7 +1612,7 @@ 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)
@@ -1441,6 +1670,13 @@ module Playwright
     # browser.close()
     # ```
     # 
+    # ```csharp
+    # await using var browser = await playwright.Webkit.LaunchAsync();
+    # var page = await browser.NewPageAsync();
+    # await page.RouteAsync("**/*.{png,jpg,jpeg}", async r => await r.AbortAsync());
+    # await page.GotoAsync("https://www.microsoft.com");
+    # ```
+    # 
     # or the same snippet using a regex pattern instead:
     # 
     #
@@ -1472,6 +1708,63 @@ module Playwright
     # browser.close()
     # ```
     # 
+    # ```csharp
+    # await using var browser = await playwright.Webkit.LaunchAsync();
+    # var page = await browser.NewPageAsync();
+    # await page.RouteAsync(new Regex("(\\.png$)|(\\.jpg$)"), async r => await r.AbortAsync());
+    # await page.GotoAsync("https://www.microsoft.com");
+    # ```
+    # 
+    # 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:
+    # 
+    #
+    # ```js
+    # await page.route('/api/**', route => {
+    #   if (route.request().postData().includes('my-string'))
+    #     route.fulfill({ body: 'mocked-data' });
+    #   else
+    #     route.continue();
+    # });
+    # ```
+    # 
+    # ```java
+    # page.route("/api/**", route -> {
+    #   if (route.request().postData().contains("my-string"))
+    #     route.fulfill(new Route.FulfillOptions().setBody("mocked-data"));
+    #   else
+    #     route.resume();
+    # });
+    # ```
+    # 
+    # ```python async
+    # def handle_route(route):
+    #   if ("my-string" in route.request.post_data)
+    #     route.fulfill(body="mocked-data")
+    #   else
+    #     route.continue_()
+    # await page.route("/api/**", handle_route)
+    # ```
+    # 
+    # ```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)
+    # ```
+    # 
+    # ```csharp
+    # await page.RouteAsync("/api/**", async r =>
+    # {
+    #   if (r.Request.PostData.Contains("my-string"))
+    #       await r.FulfillAsync(body: "mocked-data");
+    #   else
+    #       await r.ContinueAsync();
+    # });
+    # ```
+    # 
     # Page routes take precedence over browser context routes (set up with [`method: BrowserContext.route`]) when request
     # matches both handlers.
     # 
@@ -1494,12 +1787,16 @@ 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
 
-    # 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.
+    # 
+    # 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 there's no `<select>` element
-    # matching `selector`, 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
@@ -1541,7 +1838,16 @@ module Playwright
     # page.select_option("select#colors", value=["red", "green", "blue"])
     # ```
     # 
-    # Shortcut for main frame's [`method: Frame.selectOption`]
+    # ```csharp
+    # // single selection matching the value
+    # await page.SelectOptionAsync("select#colors", new[] { "blue" });
+    # // single selection matching both the value and the label
+    # await page.SelectOptionAsync("select#colors", new[] { new SelectOptionValue() { Label = "blue" } });
+    # // multiple 
+    # await page.SelectOptionAsync("select#colors", new[] { "red", "green", "blue" });
+    # ```
+    # 
+    # Shortcut for main frame's [`method: Frame.selectOption`].
     def select_option(
           selector,
           element: nil,
@@ -1632,6 +1938,12 @@ module Playwright
     # page.set_viewport_size({"width": 640, "height": 480})
     # page.goto("https://example.com")
     # ```
+    # 
+    # ```csharp
+    # var page = await browser.NewPageAsync();
+    # await page.SetViewportSizeAsync(640, 480);
+    # await page.GotoAsync("https://www.microsoft.com");
+    # ```
     def set_viewport_size(viewportSize)
       wrap_impl(@impl.set_viewport_size(unwrap_impl(viewportSize)))
     end
@@ -1657,8 +1969,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`.
@@ -1699,6 +2012,11 @@ module Playwright
     # page.type("#mytextarea", "world", delay=100) # types slower, like a user
     # ```
     # 
+    # ```csharp
+    # await page.TypeAsync("#mytextarea", "hello"); // types instantly
+    # await page.TypeAsync("#mytextarea", "world"); // types slower, like a user
+    # ```
+    # 
     # Shortcut for main frame's [`method: Frame.type`].
     def type(
           selector,
@@ -1729,8 +2047,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
 
     # Removes a route created with [`method: Page.route`]. When `handler` is not specified, removes all routes for the `url`.
@@ -1788,6 +2107,12 @@ module Playwright
     #     page.click("button")
     # frame = event_info.value
     # ```
+    # 
+    # ```csharp
+    # var waitTask = page.WaitForEventAsync(PageEvent.FrameNavigated);
+    # await page.ClickAsync("button");
+    # var frame = await waitTask;
+    # ```
     def expect_event(event, predicate: nil, timeout: nil, &block)
       wrap_impl(@impl.expect_event(unwrap_impl(event), predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end
@@ -1867,6 +2192,23 @@ module Playwright
     #     run(playwright)
     # ```
     # 
+    # ```csharp
+    # using Microsoft.Playwright;
+    # using System.Threading.Tasks;
+    # 
+    # class FrameExamples
+    # {
+    #   public static async Task WaitForFunction()
+    #   {
+    #     using var playwright = await Playwright.CreateAsync();
+    #     await using var browser = await playwright.Webkit.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 [`method: Page.waitForFunction`] function:
     # 
     #
@@ -1890,6 +2232,11 @@ module Playwright
     # page.wait_for_function("selector => !!document.querySelector(selector)", selector)
     # ```
     # 
+    # ```csharp
+    # var selector = ".foo";
+    # await page.WaitForFunctionAsync("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)))
@@ -1921,6 +2268,11 @@ module Playwright
     # page.wait_for_load_state() # the promise resolves after "load" event.
     # ```
     # 
+    # ```csharp
+    # await page.ClickAsync("button"); // Click triggers navigation.
+    # await page.WaitForLoadStateAsync(); // The promise resolves after 'load' event.
+    # ```
+    # 
     #
     # ```js
     # const [popup] = await Promise.all([
@@ -1957,6 +2309,14 @@ module Playwright
     # print(popup.title()) # popup is ready to use.
     # ```
     # 
+    # ```csharp
+    # var popupTask = page.WaitForPopupAsync();
+    # await page.ClickAsync("button"); // click triggers the popup/
+    # var popup = await popupTask;
+    # await popup.WaitForLoadStateAsync(LoadState.DOMContentLoaded);
+    # Console.WriteLine(await popup.TitleAsync()); // 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)))
@@ -1997,6 +2357,12 @@ module Playwright
     # # Resolves after navigation has finished
     # ```
     # 
+    # ```csharp
+    # await Task.WhenAll(page.WaitForNavigationAsync(),
+    #     frame.ClickAsync("a.delayed-navigation")); // clicking the link will indirectly cause a navigation
+    # // The method continues 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.
     # 
@@ -2012,20 +2378,41 @@ 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();
+    # // Note that Promise.all prevents a race condition
+    # // between clicking and waiting for the request.
+    # const [request] = await Promise.all([
+    #   // Waits for the next request with the specified url
+    #   page.waitForRequest('https://example.com/resource'),
+    #   // Triggers the request
+    #   page.click('button.triggers-request'),
+    # ]);
+    # 
+    # // Alternative way with a predicate.
+    # const [request] = await Promise.all([
+    #   // Waits for the next request matching some conditions
+    #   page.waitForRequest(request => request.url() === 'https://example.com' && request.method() === 'GET'),
+    #   // Triggers the request
+    #   page.click('button.triggers-request'),
+    # ]);
     # ```
     # 
     # ```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();
+    # // Waits for the next response with the specified url
+    # Request request = page.waitForRequest("https://example.com/resource", () -> {
+    #   // Triggers the request
+    #   page.click("button.triggers-request");
+    # });
+    # 
+    # // Waits for the next request matching some conditions
+    # Request request = page.waitForRequest(request -> "https://example.com".equals(request.url()) && "GET".equals(request.method()), () -> {
+    #   // Triggers the request
+    #   page.click("button.triggers-request");
+    # });
     # ```
     # 
     # ```python async
@@ -2033,6 +2420,7 @@ module Playwright
     #     await page.click('button')
     # first_request = await first.value
     # 
+    # # or with a lambda
     # async with page.expect_request(lambda request: request.url == "http://example.com" and request.method == "get") as second:
     #     await page.click('img')
     # second_request = await second.value
@@ -2043,11 +2431,22 @@ module Playwright
     #     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
     # ```
     # 
+    # ```csharp
+    # // Waits for the next response with the specified url
+    # await Task.WhenAll(page.WaitForRequestAsync("https://example.com/resource"),
+    #     page.ClickAsync("button.triggers-request"));
+    # 
+    # // Waits for the next request matching some conditions
+    # await Task.WhenAll(page.WaitForRequestAsync(r => "https://example.com".Equals(r.Url) && "GET" == r.Method),
+    #     page.ClickAsync("button.triggers-request"));
+    # ```
+    # 
     #
     # ```js
     # await page.waitForRequest(request => request.url().searchParams.get('foo') === 'bar' && request.url().searchParams.get('foo2') === 'bar2');
@@ -2056,19 +2455,40 @@ module Playwright
       wrap_impl(@impl.expect_request(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout)))
     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();
+    # // Note that Promise.all prevents a race condition
+    # // between clicking and waiting for the response.
+    # const [response] = await Promise.all([
+    #   // Waits for the next response with the specified url
+    #   page.waitForResponse('https://example.com/resource'),
+    #   // Triggers the response
+    #   page.click('button.triggers-response'),
+    # ]);
+    # 
+    # // Alternative way with a predicate.
+    # const [response] = await Promise.all([
+    #   // Waits for the next response matching some conditions
+    #   page.waitForResponse(response => response.url() === 'https://example.com' && response.status() === 200),
+    #   // Triggers the response
+    #   page.click('button.triggers-response'),
+    # ]);
     # ```
     # 
     # ```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();
+    # // Waits for the next response with the specified url
+    # Response response = page.waitForResponse("https://example.com/resource", () -> {
+    #   // Triggers the response
+    #   page.click("button.triggers-response");
+    # });
+    # 
+    # // Waits for the next response matching some conditions
+    # Response response = page.waitForResponse(response -> "https://example.com".equals(response.url()) && response.status() == 200, () -> {
+    #   // Triggers the response
+    #   page.click("button.triggers-response");
+    # });
     # ```
     # 
     # ```python async
@@ -2096,6 +2516,16 @@ module Playwright
     # response = response_info.value
     # return response.ok
     # ```
+    # 
+    # ```csharp
+    # // Waits for the next response with the specified url
+    # await Task.WhenAll(page.WaitForResponseAsync("https://example.com/resource"),
+    #     page.ClickAsync("button.triggers-response"));
+    # 
+    # // Waits for the next response matching some conditions
+    # await Task.WhenAll(page.WaitForResponseAsync(r => "https://example.com".Equals(r.Url) && r.Status == 200),
+    #     page.ClickAsync("button.triggers-response"));
+    # ```
     def expect_response(urlOrPredicate, timeout: nil)
       wrap_impl(@impl.expect_response(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout)))
     end
@@ -2181,6 +2611,31 @@ 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 Images()
+    #   {
+    #       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);
+    #           var element = await page.WaitForSelectorAsync("img");
+    #           Console.WriteLine($"Loaded image: {await element.GetAttributeAsync("src")}");
+    #       }
+    # 
+    #       await browser.CloseAsync();
+    #   }
+    # }
+    # ```
     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
@@ -2211,6 +2666,11 @@ module Playwright
     # page.wait_for_timeout(1000)
     # ```
     # 
+    # ```csharp
+    # // Wait for 1 second
+    # await page.WaitForTimeoutAsync(1000);
+    # ```
+    # 
     # Shortcut for main frame's [`method: Frame.waitForTimeout`].
     def wait_for_timeout(timeout)
       raise NotImplementedError.new('wait_for_timeout is not implemented yet.')
@@ -2239,6 +2699,11 @@ module Playwright
     # page.wait_for_url("**/target.html")
     # ```
     # 
+    # ```csharp
+    # await page.ClickAsync("a.delayed-navigation"); // clicking the link will indirectly cause a navigation
+    # await page.WaitForURLAsync("**/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)))