playwright-ruby-client 0.1.0 → 0.5.3

data/lib/playwright_api/js_handle.rb

@@ -8,6 +8,11 @@ module Playwright
   # // ...
   # ```
   # 
+  # ```java
+  # JSHandle windowHandle = page.evaluateHandle("() => window");
+  # // ...
+  # ```
+  # 
   # ```python async
   # window_handle = await page.evaluate_handle("window")
   # # ...
@@ -50,6 +55,11 @@ module Playwright
     # expect(await tweetHandle.evaluate(node => node.innerText)).toBe('10 retweets');
     # ```
     # 
+    # ```java
+    # ElementHandle tweetHandle = page.querySelector(".tweet .retweets");
+    # assertEquals("10 retweets", tweetHandle.evaluate("node => node.innerText"));
+    # ```
+    # 
     # ```python async
     # tweet_handle = await page.query_selector(".tweet .retweets")
     # assert await tweet_handle.evaluate("node => node.innerText") == "10 retweets"
@@ -89,6 +99,14 @@ module Playwright
     # await handle.dispose();
     # ```
     # 
+    # ```java
+    # JSHandle handle = page.evaluateHandle("() => ({window, document}"););
+    # Map<String, JSHandle> properties = handle.getProperties();
+    # JSHandle windowHandle = properties.get("window");
+    # JSHandle documentHandle = properties.get("document");
+    # handle.dispose();
+    # ```
+    # 
     # ```python async
     # handle = await page.evaluate_handle("{window, document}")
     # properties = await handle.get_properties()
@@ -123,8 +141,8 @@ module Playwright
     end
 
     # @nodoc
-    def after_initialize
-      wrap_impl(@impl.after_initialize)
+    def to_s
+      wrap_impl(@impl.to_s)
     end
 
     # -- inherited from EventEmitter --

data/lib/playwright_api/keyboard.rb

@@ -21,6 +21,17 @@ module Playwright
   # // Result text will end up saying 'Hello!'
   # ```
   # 
+  # ```java
+  # page.keyboard().type("Hello World!");
+  # page.keyboard().press("ArrowLeft");
+  # page.keyboard().down("Shift");
+  # for (int i = 0; i < " World".length(); i++)
+  #   page.keyboard().press("ArrowLeft");
+  # page.keyboard().up("Shift");
+  # page.keyboard().press("Backspace");
+  # // Result text will end up saying "Hello!"
+  # ```
+  # 
   # ```python async
   # await page.keyboard.type("Hello World!")
   # await page.keyboard.press("ArrowLeft")
@@ -52,6 +63,12 @@ module Playwright
   # await page.keyboard.press('Shift+A');
   # ```
   # 
+  # ```java
+  # page.keyboard().press("Shift+KeyA");
+  # // or
+  # page.keyboard().press("Shift+A");
+  # ```
+  # 
   # ```python async
   # await page.keyboard.press("Shift+KeyA")
   # # or
@@ -74,6 +91,13 @@ module Playwright
   # await page.keyboard.press('Meta+A');
   # ```
   # 
+  # ```java
+  # // on Windows and Linux
+  # page.keyboard().press("Control+A");
+  # // on macOS
+  # page.keyboard().press("Meta+A");
+  # ```
+  # 
   # ```python async
   # # on windows and linux
   # await page.keyboard.press("Control+A")
@@ -124,6 +148,10 @@ module Playwright
     # page.keyboard.insertText('嗨');
     # ```
     # 
+    # ```java
+    # page.keyboard().insertText("嗨");
+    # ```
+    # 
     # ```python async
     # await page.keyboard.insert_text("嗨")
     # ```
@@ -151,7 +179,7 @@ module Playwright
     # 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 speficied with the
+    # 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.
     # 
     #
@@ -167,6 +195,18 @@ module Playwright
     # await browser.close();
     # ```
     # 
+    # ```java
+    # Page page = browser.newPage();
+    # page.navigate("https://keycode.info");
+    # page.keyboard().press("A");
+    # page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("A.png"));
+    # page.keyboard().press("ArrowLeft");
+    # page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("ArrowLeft.png")));
+    # page.keyboard().press("Shift+O");
+    # page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("O.png")));
+    # browser.close();
+    # ```
+    # 
     # ```python async
     # page = await browser.new_page()
     # await page.goto("https://keycode.info")
@@ -206,6 +246,13 @@ module Playwright
     # await page.keyboard.type('World', {delay: 100}); // Types slower, like a user
     # ```
     # 
+    # ```java
+    # // Types instantly
+    # page.keyboard().type("Hello");
+    # // Types slower, like a user
+    # page.keyboard().type("World", new Keyboard.TypeOptions().setDelay(100));
+    # ```
+    # 
     # ```python async
     # await page.keyboard.type("Hello") # types instantly
     # await page.keyboard.type("World", delay=100) # types slower, like a user

data/lib/playwright_api/mouse.rb

@@ -15,6 +15,17 @@ module Playwright
   # await page.mouse.up();
   # ```
   # 
+  # ```java
+  # // Using ‘page.mouse’ to trace a 100x100 square.
+  # page.mouse().move(0, 0);
+  # page.mouse().down();
+  # page.mouse().move(0, 100);
+  # page.mouse().move(100, 100);
+  # page.mouse().move(100, 0);
+  # page.mouse().move(0, 0);
+  # page.mouse().up();
+  # ```
+  # 
   # ```python async
   # # using ‘page.mouse’ to trace a 100x100 square.
   # await page.mouse.move(0, 0)
@@ -36,6 +47,16 @@ module Playwright
   # page.mouse.move(0, 0)
   # page.mouse.up()
   # ```
+  # 
+  # ```csharp
+  # await Page.Mouse.MoveAsync(0, 0);
+  # await Page.Mouse.DownAsync();
+  # await Page.Mouse.MoveAsync(0, 100);
+  # await Page.Mouse.MoveAsync(100, 100);
+  # await Page.Mouse.MoveAsync(100, 0);
+  # await Page.Mouse.MoveAsync(0, 0);
+  # await Page.Mouse.UpAsync();
+  # ```
   class Mouse < PlaywrightApi
 
     # Shortcut for [`method: Mouse.move`], [`method: Mouse.down`], [`method: Mouse.up`].
@@ -45,28 +66,28 @@ module Playwright
           button: nil,
           clickCount: nil,
           delay: nil)
-      raise NotImplementedError.new('click is not implemented yet.')
+      wrap_impl(@impl.click(unwrap_impl(x), unwrap_impl(y), button: unwrap_impl(button), clickCount: unwrap_impl(clickCount), delay: unwrap_impl(delay)))
     end
 
     # Shortcut for [`method: Mouse.move`], [`method: Mouse.down`], [`method: Mouse.up`], [`method: Mouse.down`] and
     # [`method: Mouse.up`].
     def dblclick(x, y, button: nil, delay: nil)
-      raise NotImplementedError.new('dblclick is not implemented yet.')
+      wrap_impl(@impl.dblclick(unwrap_impl(x), unwrap_impl(y), button: unwrap_impl(button), delay: unwrap_impl(delay)))
     end
 
     # Dispatches a `mousedown` event.
     def down(button: nil, clickCount: nil)
-      raise NotImplementedError.new('down is not implemented yet.')
+      wrap_impl(@impl.down(button: unwrap_impl(button), clickCount: unwrap_impl(clickCount)))
     end
 
     # Dispatches a `mousemove` event.
     def move(x, y, steps: nil)
-      raise NotImplementedError.new('move is not implemented yet.')
+      wrap_impl(@impl.move(unwrap_impl(x), unwrap_impl(y), steps: unwrap_impl(steps)))
     end
 
     # Dispatches a `mouseup` event.
     def up(button: nil, clickCount: nil)
-      raise NotImplementedError.new('up is not implemented yet.')
+      wrap_impl(@impl.up(button: unwrap_impl(button), clickCount: unwrap_impl(clickCount)))
     end
   end
 end

data/lib/playwright_api/page.rb

@@ -21,6 +21,24 @@ module Playwright
   # })();
   # ```
   # 
+  # ```java
+  # import com.microsoft.playwright.*;
+  # 
+  # public class Example {
+  #   public static void main(String[] args) {
+  #     try (Playwright playwright = Playwright.create()) {
+  #       BrowserType webkit = playwright.webkit();
+  #       Browser browser = webkit.launch();
+  #       BrowserContext context = browser.newContext();
+  #       Page page = context.newPage();
+  #       page.navigate("https://example.com");
+  #       page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("screenshot.png")));
+  #       browser.close();
+  #     }
+  #   }
+  # }
+  # ```
+  # 
   # ```python async
   # import asyncio
   # from playwright.async_api import async_playwright
@@ -67,6 +85,10 @@ module Playwright
   # page.once('load', () => console.log('Page loaded!'));
   # ```
   # 
+  # ```java
+  # page.onLoad(p -> System.out.println("Page loaded!"));
+  # ```
+  # 
   # ```py
   # page.once("load", lambda: print("page loaded!"))
   # ```
@@ -83,6 +105,15 @@ module Playwright
   # page.removeListener('request', logRequest);
   # ```
   # 
+  # ```java
+  # Consumer<Request> logRequest = interceptedRequest -> {
+  #   System.out.println("A request was made: " + interceptedRequest.url());
+  # };
+  # page.onRequest(logRequest);
+  # // Sometime later...
+  # page.offRequest(logRequest);
+  # ```
+  # 
   # ```py
   # def log_request(intercepted_request):
   #     print("a request was made:", intercepted_request.url)
@@ -96,12 +127,6 @@ module Playwright
       wrap_impl(@impl.accessibility)
     end
 
-    # Browser-specific Coverage implementation, only available for Chromium atm. See
-    # `ChromiumCoverage`(#class-chromiumcoverage) for more details.
-    def coverage # property
-      raise NotImplementedError.new('coverage is not implemented yet.')
-    end
-
     def keyboard # property
       wrap_impl(@impl.keyboard)
     end
@@ -136,6 +161,11 @@ module Playwright
     # await page.addInitScript({ path: './preload.js' });
     # ```
     # 
+    # ```java
+    # // In your playwright script, assuming the preload.js file is in same directory
+    # page.addInitScript(Paths.get("./preload.js"));
+    # ```
+    # 
     # ```python async
     # # in your playwright script, assuming the preload.js file is in same directory
     # await page.add_init_script(path="./preload.js")
@@ -148,8 +178,8 @@ module Playwright
     # 
     # > NOTE: The order of evaluation of multiple scripts installed via [`method: BrowserContext.addInitScript`] and
     # [`method: Page.addInitScript`] is not defined.
-    def add_init_script(script, arg: nil)
-      wrap_impl(@impl.add_init_script(unwrap_impl(script), arg: unwrap_impl(arg)))
+    def add_init_script(path: nil, script: nil)
+      wrap_impl(@impl.add_init_script(path: unwrap_impl(path), script: unwrap_impl(script)))
     end
 
     # Adds a `<script>` tag into the page with the desired url or content. Returns the added tag when the script's onload
@@ -174,34 +204,39 @@ module Playwright
     end
 
     # This method checks an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-    # 1. Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Ensure that matched element is a checkbox or a radio input. If not, this method throws. If the element is already
     #    checked, this method returns immediately.
     # 1. Wait for [actionability](./actionability.md) checks on the matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 1. Scroll the element into view if needed.
     # 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 rejects.
+    # 1. Ensure that the element is now checked. If not, this method throws.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
     # 
     # Shortcut for main frame's [`method: Frame.check`].
-    def check(selector, force: nil, noWaitAfter: nil, timeout: nil)
-      wrap_impl(@impl.check(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    def check(
+          selector,
+          force: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil)
+      wrap_impl(@impl.check(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # This method clicks an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
     # 1. Wait for [actionability](./actionability.md) checks on the matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.mouse`] to click in the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
     # 
     # Shortcut for main frame's [`method: Frame.click`].
     def click(
@@ -239,16 +274,16 @@ module Playwright
     end
 
     # This method double clicks an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
     # 1. Wait for [actionability](./actionability.md) checks on the matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 1. Scroll the element into view if needed.
     # 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 reject.
+    #    first click of the `dblclick()` triggers a navigation event, this method will throw.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
     # 
     # > NOTE: `page.dblclick()` dispatches two `click` events and a single `dblclick` event.
     # 
@@ -265,8 +300,8 @@ module Playwright
       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)))
     end
 
-    # The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click`
-    # is dispatched. This is equivalend to calling
+    # 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).
     # 
     #
@@ -274,6 +309,10 @@ module Playwright
     # await page.dispatchEvent('button#submit', 'click');
     # ```
     # 
+    # ```java
+    # page.dispatchEvent("button#submit", "click");
+    # ```
+    # 
     # ```python async
     # await page.dispatch_event("button#submit", "click")
     # ```
@@ -303,6 +342,14 @@ module Playwright
     # await page.dispatchEvent('#source', 'dragstart', { dataTransfer });
     # ```
     # 
+    # ```java
+    # // Note you can only create DataTransfer in Chromium and Firefox
+    # JSHandle dataTransfer = page.evaluateHandle("() => new DataTransfer()");
+    # Map<String, Object> arg = new HashMap<>();
+    # arg.put("dataTransfer", dataTransfer);
+    # page.dispatchEvent("#source", "dragstart", arg);
+    # ```
+    # 
     # ```python async
     # # note you can only create data_transfer in chromium and firefox
     # data_transfer = await page.evaluate_handle("new DataTransfer()")
@@ -318,7 +365,6 @@ module Playwright
       wrap_impl(@impl.dispatch_event(unwrap_impl(selector), unwrap_impl(type), eventInit: unwrap_impl(eventInit), timeout: unwrap_impl(timeout)))
     end
 
-    # 
     #
     # ```js
     # await page.evaluate(() => matchMedia('screen').matches);
@@ -339,6 +385,25 @@ module Playwright
     # // → false
     # ```
     # 
+    # ```java
+    # page.evaluate("() => matchMedia('screen').matches");
+    # // → true
+    # page.evaluate("() => matchMedia('print').matches");
+    # // → false
+    # 
+    # page.emulateMedia(new Page.EmulateMediaOptions().setMedia(Media.PRINT));
+    # page.evaluate("() => matchMedia('screen').matches");
+    # // → false
+    # page.evaluate("() => matchMedia('print').matches");
+    # // → true
+    # 
+    # page.emulateMedia(new Page.EmulateMediaOptions());
+    # page.evaluate("() => matchMedia('screen').matches");
+    # // → true
+    # page.evaluate("() => matchMedia('print').matches");
+    # // → false
+    # ```
+    # 
     # ```python async
     # await page.evaluate("matchMedia('screen').matches")
     # # → True
@@ -388,6 +453,16 @@ module Playwright
     # // → false
     # ```
     # 
+    # ```java
+    # page.emulateMedia(new Page.EmulateMediaOptions().setColorScheme(ColorScheme.DARK));
+    # page.evaluate("() => matchMedia('(prefers-color-scheme: dark)').matches");
+    # // → true
+    # page.evaluate("() => matchMedia('(prefers-color-scheme: light)').matches");
+    # // → false
+    # page.evaluate("() => matchMedia('(prefers-color-scheme: no-preference)').matches");
+    # // → false
+    # ```
+    # 
     # ```python async
     # await page.emulate_media(color_scheme="dark")
     # await page.evaluate("matchMedia('(prefers-color-scheme: dark)').matches")
@@ -425,6 +500,12 @@ module Playwright
     # const html = await page.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');
     # ```
     # 
+    # ```java
+    # String searchValue = (String) page.evalOnSelector("#search", "el => el.value");
+    # String preloadHref = (String) page.evalOnSelector("link[rel=preload]", "el => el.href");
+    # String html = (String) page.evalOnSelector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello");
+    # ```
+    # 
     # ```python async
     # search_value = await page.eval_on_selector("#search", "el => el.value")
     # preload_href = await page.eval_on_selector("link[rel=preload]", "el => el.href")
@@ -455,6 +536,10 @@ module Playwright
     # const divCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);
     # ```
     # 
+    # ```java
+    # boolean divCounts = (boolean) page.evalOnSelectorAll("div", "(divs, min) => divs.length >= min", 10);
+    # ```
+    # 
     # ```python async
     # div_counts = await page.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
     # ```
@@ -485,6 +570,13 @@ module Playwright
     # console.log(result); // prints "56"
     # ```
     # 
+    # ```java
+    # Object result = page.evaluate("([x, y]) => {\n" +
+    #   "  return Promise.resolve(x * y);\n" +
+    #   "}", Arrays.asList(7, 8));
+    # System.out.println(result); // prints "56"
+    # ```
+    # 
     # ```python async
     # result = await page.evaluate("([x, y]) => Promise.resolve(x * y)", [7, 8])
     # print(result) # prints "56"
@@ -504,6 +596,10 @@ module Playwright
     # console.log(await page.evaluate(`1 + ${x}`)); // prints "11"
     # ```
     # 
+    # ```java
+    # System.out.println(page.evaluate("1 + 2")); // prints "3"
+    # ```
+    # 
     # ```python async
     # print(await page.evaluate("1 + 2")) # prints "3"
     # x = 10
@@ -525,6 +621,12 @@ module Playwright
     # await bodyHandle.dispose();
     # ```
     # 
+    # ```java
+    # ElementHandle bodyHandle = page.querySelector("body");
+    # String html = (String) page.evaluate("([body, suffix]) => body.innerHTML + suffix", Arrays.asList(bodyHandle, "hello"));
+    # bodyHandle.dispose();
+    # ```
+    # 
     # ```python async
     # body_handle = await page.query_selector("body")
     # html = await page.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
@@ -556,6 +658,11 @@ module Playwright
     # aWindowHandle; // Handle for the window object.
     # ```
     # 
+    # ```java
+    # // Handle for the window object.
+    # JSHandle aWindowHandle = page.evaluateHandle("() => Promise.resolve(window)");
+    # ```
+    # 
     # ```python async
     # a_window_handle = await page.evaluate_handle("Promise.resolve(window)")
     # a_window_handle # handle for the window object.
@@ -573,6 +680,10 @@ module Playwright
     # const aHandle = await page.evaluateHandle('document'); // Handle for the 'document'
     # ```
     # 
+    # ```java
+    # JSHandle aHandle = page.evaluateHandle("document"); // Handle for the "document".
+    # ```
+    # 
     # ```python async
     # a_handle = await page.evaluate_handle("document") # handle for the "document"
     # ```
@@ -591,6 +702,13 @@ module Playwright
     # await resultHandle.dispose();
     # ```
     # 
+    # ```java
+    # JSHandle aHandle = page.evaluateHandle("() => document.body");
+    # JSHandle resultHandle = page.evaluateHandle("([body, suffix]) => body.innerHTML + suffix", Arrays.asList(aHandle, "hello"));
+    # System.out.println(resultHandle.jsonValue());
+    # resultHandle.dispose();
+    # ```
+    # 
     # ```python async
     # a_handle = await page.evaluate_handle("document.body")
     # result_handle = await page.evaluate_handle("body => body.innerHTML", a_handle)
@@ -643,6 +761,30 @@ module Playwright
     # })();
     # ```
     # 
+    # ```java
+    # import com.microsoft.playwright.*;
+    # 
+    # public class Example {
+    #   public static void main(String[] args) {
+    #     try (Playwright playwright = Playwright.create()) {
+    #       BrowserType webkit = playwright.webkit();
+    #       Browser browser = webkit.launch({ headless: false });
+    #       BrowserContext context = browser.newContext();
+    #       Page page = context.newPage();
+    #       page.exposeBinding("pageURL", (source, args) -> source.page().url());
+    #       page.setContent("<script>\n" +
+    #         "  async function onClick() {\n" +
+    #         "    document.querySelector('div').textContent = await window.pageURL();\n" +
+    #         "  }\n" +
+    #         "</script>\n" +
+    #         "<button onclick=\"onClick()\">Click me</button>\n" +
+    #         "<div></div>");
+    #       page.click("button");
+    #     }
+    #   }
+    # }
+    # ```
+    # 
     # ```python async
     # import asyncio
     # from playwright.async_api import async_playwright
@@ -710,6 +852,20 @@ module Playwright
     # `);
     # ```
     # 
+    # ```java
+    # page.exposeBinding("clicked", (source, args) -> {
+    #   ElementHandle element = (ElementHandle) args[0];
+    #   System.out.println(element.textContent());
+    #   return null;
+    # }, new Page.ExposeBindingOptions().setHandle(true));
+    # page.setContent("" +
+    #   "<script>\n" +
+    #   "  document.addEventListener('click', event => window.clicked(event.target));\n" +
+    #   "</script>\n" +
+    #   "<div>Click me</div>\n" +
+    #   "<div>Or click me</div>\n");
+    # ```
+    # 
     # ```python async
     # async def print(source, element):
     #     print(await element.text_content())
@@ -774,6 +930,44 @@ module Playwright
     # })();
     # ```
     # 
+    # ```java
+    # import com.microsoft.playwright.*;
+    # 
+    # import java.nio.charset.StandardCharsets;
+    # import java.security.MessageDigest;
+    # import java.security.NoSuchAlgorithmException;
+    # import java.util.Base64;
+    # 
+    # public class Example {
+    #   public static void main(String[] args) {
+    #     try (Playwright playwright = Playwright.create()) {
+    #       BrowserType webkit = playwright.webkit();
+    #       Browser browser = webkit.launch({ headless: false });
+    #       Page page = browser.newPage();
+    #       page.exposeFunction("sha1", args -> {
+    #         String text = (String) args[0];
+    #         MessageDigest crypto;
+    #         try {
+    #           crypto = MessageDigest.getInstance("SHA-1");
+    #         } catch (NoSuchAlgorithmException e) {
+    #           return null;
+    #         }
+    #         byte[] token = crypto.digest(text.getBytes(StandardCharsets.UTF_8));
+    #         return Base64.getEncoder().encodeToString(token);
+    #       });
+    #       page.setContent("<script>\n" +
+    #         "  async function onClick() {\n" +
+    #         "    document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');\n" +
+    #         "  }\n" +
+    #         "</script>\n" +
+    #         "<button onclick=\"onClick()\">Click me</button>\n" +
+    #         "<div></div>\n");
+    #       page.click("button");
+    #     }
+    #   }
+    # }
+    # ```
+    # 
     # ```python async
     # import asyncio
     # import hashlib
@@ -868,6 +1062,10 @@ module Playwright
     # const frame = page.frame('frame-name');
     # ```
     # 
+    # ```java
+    # Frame frame = page.frame("frame-name");
+    # ```
+    # 
     # ```py
     # frame = page.frame(name="frame-name")
     # ```
@@ -877,11 +1075,15 @@ module Playwright
     # const frame = page.frame({ url: /.*domain.*/ });
     # ```
     # 
+    # ```java
+    # Frame frame = page.frameByUrl(Pattern.compile(".*domain.*");
+    # ```
+    # 
     # ```py
     # frame = page.frame(url=r".*domain.*")
     # ```
-    def frame(frameSelector)
-      wrap_impl(@impl.frame(unwrap_impl(frameSelector)))
+    def frame(name: nil, url: nil)
+      wrap_impl(@impl.frame(name: unwrap_impl(name), url: unwrap_impl(url)))
     end
 
     # An array of all frames attached to the page.
@@ -935,15 +1137,15 @@ module Playwright
     end
 
     # This method hovers over an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
     # 1. Wait for [actionability](./actionability.md) checks on the matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.mouse`] to hover over the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
     # 
     # Shortcut for main frame's [`method: Frame.hover`].
     def hover(
@@ -990,12 +1192,14 @@ module Playwright
       wrap_impl(@impl.enabled?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
-    # Returns whether the element is hidden, the opposite of [visible](./actionability.md#visible).
+    # Returns whether the element is hidden, the opposite of [visible](./actionability.md#visible).  `selector` that does not
+    # match any elements is considered hidden.
     def hidden?(selector, timeout: nil)
       wrap_impl(@impl.hidden?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
-    # Returns whether the element is [visible](./actionability.md#visible).
+    # Returns whether the element is [visible](./actionability.md#visible). `selector` that does not match any elements is
+    # considered not visible.
     def visible?(selector, timeout: nil)
       wrap_impl(@impl.visible?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
@@ -1016,7 +1220,7 @@ module Playwright
     # User can inspect selectors or perform manual steps while paused. Resume will continue running the original script from
     # the place it was paused.
     # 
-    # > NOTE: This method requires Playwright to be started in a headed mode, with a falsy [`options: headless`] value in the
+    # > NOTE: This method requires Playwright to be started in a headed mode, with a falsy `headless` value in the
     # [`method: BrowserType.launch`].
     def pause
       raise NotImplementedError.new('pause is not implemented yet.')
@@ -1040,6 +1244,12 @@ module Playwright
     # await page.pdf({path: 'page.pdf'});
     # ```
     # 
+    # ```java
+    # // Generates a PDF with "screen" media type.
+    # page.emulateMedia(new Page.EmulateMediaOptions().setMedia(Media.SCREEN));
+    # page.pdf(new Page.PdfOptions().setPath(Paths.get("page.pdf")));
+    # ```
+    # 
     # ```python async
     # # generates a pdf with "screen" media type.
     # await page.emulate_media(media="screen")
@@ -1113,7 +1323,7 @@ module Playwright
     # 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 speficied with the
+    # 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.
     # 
     #
@@ -1129,6 +1339,17 @@ module Playwright
     # await browser.close();
     # ```
     # 
+    # ```java
+    # Page page = browser.newPage();
+    # page.navigate("https://keycode.info");
+    # page.press("body", "A");
+    # page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("A.png")));
+    # page.press("body", "ArrowLeft");
+    # page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("ArrowLeft.png" )));
+    # page.press("body", "Shift+O");
+    # page.screenshot(new Page.ScreenshotOptions().setPath(Paths.get("O.png" )));
+    # ```
+    # 
     # ```python async
     # page = await browser.new_page()
     # await page.goto("https://keycode.info")
@@ -1189,7 +1410,7 @@ module Playwright
     # 
     # > NOTE: The handler will only be called for the first url if the response is a redirect.
     # 
-    # An example of a naïve handler that aborts all image requests:
+    # An example of a naive handler that aborts all image requests:
     # 
     #
     # ```js
@@ -1199,6 +1420,13 @@ module Playwright
     # await browser.close();
     # ```
     # 
+    # ```java
+    # Page page = browser.newPage();
+    # page.route("**/*.{png,jpg,jpeg}", route -> route.abort());
+    # page.navigate("https://example.com");
+    # browser.close();
+    # ```
+    # 
     # ```python async
     # page = await browser.new_page()
     # await page.route("**/*.{png,jpg,jpeg}", lambda route: route.abort())
@@ -1223,6 +1451,13 @@ module Playwright
     # await browser.close();
     # ```
     # 
+    # ```java
+    # Page page = browser.newPage();
+    # page.route(Pattern.compile("(\\.png$)|(\\.jpg$)"),route -> route.abort());
+    # page.navigate("https://example.com");
+    # browser.close();
+    # ```
+    # 
     # ```python async
     # page = await browser.new_page()
     # await page.route(re.compile(r"(\.png$)|(\.jpg$)"), lambda route: route.abort())
@@ -1240,15 +1475,14 @@ module Playwright
     # Page routes take precedence over browser context routes (set up with [`method: BrowserContext.route`]) when request
     # matches both handlers.
     # 
+    # To remove a route with its handler you can use [`method: Page.unroute`].
+    # 
     # > NOTE: Enabling routing disables http cache.
     def route(url, handler)
-      raise NotImplementedError.new('route is not implemented yet.')
+      wrap_impl(@impl.route(unwrap_impl(url), unwrap_impl(handler)))
     end
 
     # Returns the buffer with the captured screenshot.
-    # 
-    # > NOTE: Screenshots take at least 1/6 second on Chromium OS X and Chromium Windows. See https://crbug.com/741689 for
-    # discussion.
     def screenshot(
           clip: nil,
           fullPage: nil,
@@ -1280,6 +1514,15 @@ module Playwright
     # 
     # ```
     # 
+    # ```java
+    # // single selection matching the value
+    # page.selectOption("select#colors", "blue");
+    # // single selection matching both the value and the label
+    # page.selectOption("select#colors", new SelectOption().setLabel("Blue"));
+    # // multiple selection
+    # page.selectOption("select#colors", new String[] {"red", "green", "blue"});
+    # ```
+    # 
     # ```python async
     # # single selection matching the value
     # await page.select_option("select#colors", "blue")
@@ -1299,8 +1542,15 @@ module Playwright
     # ```
     # 
     # Shortcut for main frame's [`method: Frame.selectOption`]
-    def select_option(selector, values, noWaitAfter: nil, timeout: nil)
-      wrap_impl(@impl.select_option(unwrap_impl(selector), unwrap_impl(values), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    def select_option(
+          selector,
+          element: nil,
+          index: nil,
+          value: nil,
+          label: nil,
+          noWaitAfter: nil,
+          timeout: nil)
+      wrap_impl(@impl.select_option(unwrap_impl(selector), element: unwrap_impl(element), index: unwrap_impl(index), value: unwrap_impl(value), label: unwrap_impl(label), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     def set_content(html, timeout: nil, waitUntil: nil)
@@ -1315,6 +1565,7 @@ module Playwright
     # - [`method: Page.reload`]
     # - [`method: Page.setContent`]
     # - [`method: Page.waitForNavigation`]
+    # - [`method: Page.waitForURL`]
     # 
     # > NOTE: [`method: Page.setDefaultNavigationTimeout`] takes priority over [`method: Page.setDefaultTimeout`],
     # [`method: BrowserContext.setDefaultTimeout`] and [`method: BrowserContext.setDefaultNavigationTimeout`].
@@ -1364,6 +1615,12 @@ module Playwright
     # await page.goto('https://example.com');
     # ```
     # 
+    # ```java
+    # Page page = browser.newPage();
+    # page.setViewportSize(640, 480);
+    # page.navigate("https://example.com");
+    # ```
+    # 
     # ```python async
     # page = await browser.new_page()
     # await page.set_viewport_size({"width": 640, "height": 480})
@@ -1381,15 +1638,15 @@ module Playwright
     alias_method :viewport_size=, :set_viewport_size
 
     # This method taps an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
     # 1. Wait for [actionability](./actionability.md) checks on the matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.touchscreen`] to tap the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
     # 
     # > NOTE: [`method: Page.tap`] requires that the `hasTouch` option of the browser context be set to true.
     # 
@@ -1425,6 +1682,13 @@ module Playwright
     # await page.type('#mytextarea', 'World', {delay: 100}); // Types slower, like a user
     # ```
     # 
+    # ```java
+    # // Types instantly
+    # page.type("#mytextarea", "Hello");
+    # // Types slower, like a user
+    # page.type("#mytextarea", "World", new Page.TypeOptions().setDelay(100));
+    # ```
+    # 
     # ```python async
     # await page.type("#mytextarea", "hello") # types instantly
     # await page.type("#mytextarea", "world", delay=100) # types slower, like a user
@@ -1446,27 +1710,32 @@ module Playwright
     end
 
     # This method unchecks an element matching `selector` by performing the following steps:
-    # 1. Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-    # 1. Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already
+    # 1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+    # 1. Ensure that matched element is a checkbox or a radio input. If not, this method throws. If the element is already
     #    unchecked, this method returns immediately.
     # 1. Wait for [actionability](./actionability.md) checks on the matched element, unless `force` option is set. If the
     #    element is detached during the checks, the whole action is retried.
     # 1. Scroll the element into view if needed.
     # 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 rejects.
+    # 1. Ensure that the element is now unchecked. If not, this method throws.
     # 
-    # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
-    # Passing zero timeout disables this.
+    # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+    # zero timeout disables this.
     # 
     # Shortcut for main frame's [`method: Frame.uncheck`].
-    def uncheck(selector, force: nil, noWaitAfter: nil, timeout: nil)
-      wrap_impl(@impl.uncheck(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    def uncheck(
+          selector,
+          force: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil)
+      wrap_impl(@impl.uncheck(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # Removes a route created with [`method: Page.route`]. When `handler` is not specified, removes all routes for the `url`.
     def unroute(url, handler: nil)
-      raise NotImplementedError.new('unroute is not implemented yet.')
+      wrap_impl(@impl.unroute(unwrap_impl(url), handler: unwrap_impl(handler)))
     end
 
     # Shortcut for main frame's [`method: Frame.url`].
@@ -1476,13 +1745,60 @@ module Playwright
 
     # Video object associated with this page.
     def video
-      raise NotImplementedError.new('video is not implemented yet.')
+      wrap_impl(@impl.video)
     end
 
     def viewport_size
       wrap_impl(@impl.viewport_size)
     end
 
+    # Performs action and waits for a `ConsoleMessage` to be logged by in the page. If predicate is provided, it passes
+    # `ConsoleMessage` value into the `predicate` function and waits for `predicate(message)` to return a truthy value. Will
+    # throw an error if the page is closed before the console event is fired.
+    def expect_console_message(predicate: nil, timeout: nil, &block)
+      wrap_impl(@impl.expect_console_message(predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+    end
+
+    # Performs action and waits for a new `Download`. If predicate is provided, it passes `Download` value into the
+    # `predicate` function and waits for `predicate(download)` to return a truthy value. Will throw an error if the page is
+    # closed before the download event is fired.
+    def expect_download(predicate: nil, timeout: nil, &block)
+      wrap_impl(@impl.expect_download(predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+    end
+
+    # Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+    # value. Will throw an error if the page is closed before the event is fired. Returns the event data value.
+    # 
+    #
+    # ```js
+    # const [frame, _] = await Promise.all([
+    #   page.waitForEvent('framenavigated'),
+    #   page.click('button')
+    # ]);
+    # ```
+    # 
+    # ```python async
+    # async with page.expect_event("framenavigated") as event_info:
+    #     await page.click("button")
+    # frame = await event_info.value
+    # ```
+    # 
+    # ```python sync
+    # with page.expect_event("framenavigated") as event_info:
+    #     page.click("button")
+    # frame = event_info.value
+    # ```
+    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
+
+    # Performs action and waits for a new `FileChooser` to be created. If predicate is provided, it passes `FileChooser` value
+    # into the `predicate` function and waits for `predicate(fileChooser)` to return a truthy value. Will throw an error if
+    # the page is closed before the file chooser is opened.
+    def expect_file_chooser(predicate: nil, timeout: nil, &block)
+      wrap_impl(@impl.expect_file_chooser(predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+    end
+
     # Returns when the `expression` returns a truthy value. It resolves to a JSHandle of the truthy value.
     # 
     # The [`method: Page.waitForFunction`] can be used to observe viewport size change:
@@ -1501,6 +1817,23 @@ module Playwright
     # })();
     # ```
     # 
+    # ```java
+    # import com.microsoft.playwright.*;
+    # 
+    # public class Example {
+    #   public static void main(String[] args) {
+    #     try (Playwright playwright = Playwright.create()) {
+    #       BrowserType webkit = playwright.webkit();
+    #       Browser browser = webkit.launch();
+    #       Page page = browser.newPage();
+    #       page.setViewportSize(50,  50);
+    #       page.waitForFunction("() => window.innerWidth < 100");
+    #       browser.close();
+    #     }
+    #   }
+    # }
+    # ```
+    # 
     # ```python async
     # import asyncio
     # from playwright.async_api import async_playwright
@@ -1542,6 +1875,11 @@ module Playwright
     # await page.waitForFunction(selector => !!document.querySelector(selector), selector);
     # ```
     # 
+    # ```java
+    # String selector = ".foo";
+    # page.waitForFunction("selector => !!document.querySelector(selector)", selector);
+    # ```
+    # 
     # ```python async
     # selector = ".foo"
     # await page.wait_for_function("selector => !!document.querySelector(selector)", selector)
@@ -1568,6 +1906,11 @@ module Playwright
     # await page.waitForLoadState(); // The promise resolves after 'load' event.
     # ```
     # 
+    # ```java
+    # page.click("button"); // Click triggers navigation.
+    # page.waitForLoadState(); // The promise resolves after "load" event.
+    # ```
+    # 
     # ```python async
     # await page.click("button") # click triggers navigation.
     # await page.wait_for_load_state() # the promise resolves after "load" event.
@@ -1588,6 +1931,14 @@ module Playwright
     # console.log(await popup.title()); // Popup is ready to use.
     # ```
     # 
+    # ```java
+    # Page popup = page.waitForPopup(() -> {
+    #   page.click("button"); // Click triggers a popup.
+    # });
+    # popup.waitForLoadState(LoadState.DOMCONTENTLOADED);
+    # System.out.println(popup.title()); // Popup is ready to use.
+    # ```
+    # 
     # ```python async
     # async with page.expect_popup() as page_info:
     #     await page.click("button") # click triggers a popup.
@@ -1627,6 +1978,13 @@ module Playwright
     # ]);
     # ```
     # 
+    # ```java
+    # // The method returns after navigation has finished
+    # Response response = page.waitForNavigation(() -> {
+    #   page.click("a.delayed-navigation"); // Clicking the link will indirectly cause a navigation
+    # });
+    # ```
+    # 
     # ```python async
     # async with page.expect_navigation():
     #     await page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
@@ -1647,6 +2005,13 @@ module Playwright
       wrap_impl(@impl.expect_navigation(timeout: unwrap_impl(timeout), url: unwrap_impl(url), waitUntil: unwrap_impl(waitUntil), &wrap_block_call(block)))
     end
 
+    # Performs action and waits for a popup `Page`. If predicate is provided, it passes [Popup] value into the `predicate`
+    # function and waits for `predicate(page)` to return a truthy value. Will throw an error if the page is closed before the
+    # popup event is fired.
+    def expect_popup(predicate: nil, timeout: nil, &block)
+      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.
     # 
     #
@@ -1656,6 +2021,13 @@ module Playwright
     # return firstRequest.url();
     # ```
     # 
+    # ```java
+    # Request firstRequest = page.waitForRequest("http://example.com/resource");
+    # Object finalRequest = page.waitForRequest(
+    #   request -> "http://example.com".equals(request.url()) && "GET".equals(request.method()), () -> {});
+    # return firstRequest.url();
+    # ```
+    # 
     # ```python async
     # async with page.expect_request("http://example.com/resource") as first:
     #     await page.click('button')
@@ -1693,16 +2065,36 @@ module Playwright
     # return finalResponse.ok();
     # ```
     # 
+    # ```java
+    # Response firstResponse = page.waitForResponse("https://example.com/resource", () -> {});
+    # Response finalResponse = page.waitForResponse(response -> "https://example.com".equals(response.url()) && response.status() == 200, () -> {});
+    # return finalResponse.ok();
+    # ```
+    # 
     # ```python async
-    # first_response = await page.wait_for_response("https://example.com/resource")
-    # final_response = await page.wait_for_response(lambda response: response.url == "https://example.com" and response.status === 200)
-    # return final_response.ok
+    # async with page.expect_response("https://example.com/resource") as response_info:
+    #     await page.click("input")
+    # response = response_info.value
+    # return response.ok
+    # 
+    # # or with a lambda
+    # async with page.expect_response(lambda response: response.url == "https://example.com" and response.status === 200) as response_info:
+    #     await page.click("input")
+    # response = response_info.value
+    # return response.ok
     # ```
     # 
     # ```python sync
-    # first_response = page.wait_for_response("https://example.com/resource")
-    # final_response = page.wait_for_response(lambda response: response.url == "https://example.com" and response.status === 200)
-    # return final_response.ok
+    # with page.expect_response("https://example.com/resource") as response_info:
+    #     page.click("input")
+    # response = response_info.value
+    # return response.ok
+    # 
+    # # or with a lambda
+    # with page.expect_response(lambda response: response.url == "https://example.com" and response.status === 200) as response_info:
+    #     page.click("input")
+    # response = response_info.value
+    # return response.ok
     # ```
     def expect_response(urlOrPredicate, timeout: nil)
       wrap_impl(@impl.expect_response(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout)))
@@ -1733,6 +2125,26 @@ module Playwright
     # })();
     # ```
     # 
+    # ```java
+    # import com.microsoft.playwright.*;
+    # 
+    # public class Example {
+    #   public static void main(String[] args) {
+    #     try (Playwright playwright = Playwright.create()) {
+    #       BrowserType chromium = playwright.chromium();
+    #       Browser browser = chromium.launch();
+    #       Page page = browser.newPage();
+    #       for (String currentURL : Arrays.asList("https://google.com", "https://bbc.com")) {
+    #         page.navigate(currentURL);
+    #         ElementHandle element = page.waitForSelector("img");
+    #         System.out.println("Loaded image: " + element.getAttribute("src"));
+    #       }
+    #       browser.close();
+    #     }
+    #   }
+    # }
+    # ```
+    # 
     # ```python async
     # import asyncio
     # from playwright.async_api import async_playwright
@@ -1784,6 +2196,11 @@ module Playwright
     # await page.waitForTimeout(1000);
     # ```
     # 
+    # ```java
+    # // wait for 1 second
+    # page.waitForTimeout(1000);
+    # ```
+    # 
     # ```python async
     # # wait for 1 second
     # await page.wait_for_timeout(1000)
@@ -1799,6 +2216,41 @@ module Playwright
       raise NotImplementedError.new('wait_for_timeout is not implemented yet.')
     end
 
+    # Waits for the main frame to navigate to the given URL.
+    # 
+    #
+    # ```js
+    # await page.click('a.delayed-navigation'); // Clicking the link will indirectly cause a navigation
+    # await page.waitForURL('**/target.html');
+    # ```
+    # 
+    # ```java
+    # page.click("a.delayed-navigation"); // Clicking the link will indirectly cause a navigation
+    # page.waitForURL("**/target.html");
+    # ```
+    # 
+    # ```python async
+    # await page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
+    # await page.wait_for_url("**/target.html")
+    # ```
+    # 
+    # ```python sync
+    # page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
+    # page.wait_for_url("**/target.html")
+    # ```
+    # 
+    # Shortcut for main frame's [`method: Frame.waitForURL`].
+    def wait_for_url(url, timeout: nil, waitUntil: nil)
+      wrap_impl(@impl.wait_for_url(unwrap_impl(url), timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
+    end
+
+    # Performs action and waits for a new `Worker`. If predicate is provided, it passes `Worker` value into the `predicate`
+    # function and waits for `predicate(worker)` to return a truthy value. Will throw an error if the page is closed before
+    # the worker event is fired.
+    def expect_worker(predicate: nil, timeout: nil)
+      raise NotImplementedError.new('expect_worker is not implemented yet.')
+    end
+
     # This method returns all of the dedicated [WebWorkers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API)
     # associated with the page.
     # 
@@ -1807,14 +2259,33 @@ module Playwright
       raise NotImplementedError.new('workers is not implemented yet.')
     end
 
+    # > NOTE: In most cases, you should use [`method: Page.waitForEvent`].
+    # 
+    # Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function and
+    # waits for `predicate(event)` to return a truthy value. Will throw an error if the socket is closed before the `event` is
+    # fired.
+    def wait_for_event(event, predicate: nil, timeout: nil)
+      raise NotImplementedError.new('wait_for_event is not implemented yet.')
+    end
+
+    # @nodoc
+    def start_js_coverage(resetOnNavigation: nil, reportAnonymousScripts: nil)
+      wrap_impl(@impl.start_js_coverage(resetOnNavigation: unwrap_impl(resetOnNavigation), reportAnonymousScripts: unwrap_impl(reportAnonymousScripts)))
+    end
+
+    # @nodoc
+    def stop_js_coverage
+      wrap_impl(@impl.stop_js_coverage)
+    end
+
     # @nodoc
-    def after_initialize
-      wrap_impl(@impl.after_initialize)
+    def start_css_coverage(resetOnNavigation: nil, reportAnonymousScripts: nil)
+      wrap_impl(@impl.start_css_coverage(resetOnNavigation: unwrap_impl(resetOnNavigation), reportAnonymousScripts: unwrap_impl(reportAnonymousScripts)))
     end
 
     # @nodoc
-    def expect_event(event, optionsOrPredicate: nil, &block)
-      wrap_impl(@impl.expect_event(unwrap_impl(event), optionsOrPredicate: unwrap_impl(optionsOrPredicate), &wrap_block_call(block)))
+    def stop_css_coverage
+      wrap_impl(@impl.stop_css_coverage)
     end
 
     # @nodoc