playwright-ruby-client 0.0.5 → 0.1.0

data/lib/playwright_api/js_handle.rb

@@ -8,55 +8,74 @@ module Playwright
   # // ...
   # ```
   # 
+  # ```python async
+  # window_handle = await page.evaluate_handle("window")
+  # # ...
+  # ```
+  # 
+  # ```python sync
+  # window_handle = page.evaluate_handle("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.
   # 
-  # JSHandle instances can be used as an argument in [`method: Page.$eval`], [`method: Page.evaluate`] and
+  # JSHandle instances can be used as an argument in [`method: Page.evalOnSelector`], [`method: Page.evaluate`] and
   # [`method: Page.evaluateHandle`] methods.
   class JSHandle < PlaywrightApi
 
     # Returns either `null` or the object handle itself, if the object handle is an instance of `ElementHandle`.
     def as_element
-      raise NotImplementedError.new('as_element is not implemented yet.')
+      wrap_impl(@impl.as_element)
     end
 
     # The `jsHandle.dispose` method stops referencing the element handle.
     def dispose
-      wrap_channel_owner(@channel_owner.dispose)
+      wrap_impl(@impl.dispose)
     end
 
-    # Returns the return value of `pageFunction`
+    # Returns the return value of `expression`.
     # 
-    # This method passes this handle as the first argument to `pageFunction`.
+    # This method passes this handle as the first argument to `expression`.
     # 
-    # If `pageFunction` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its
-    # value.
+    # If `expression` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its value.
     # 
     # Examples:
     # 
     #
     # ```js
     # const tweetHandle = await page.$('.tweet .retweets');
-    # expect(await tweetHandle.evaluate((node, suffix) => node.innerText, ' retweets')).toBe('10 retweets');
+    # expect(await tweetHandle.evaluate(node => node.innerText)).toBe('10 retweets');
+    # ```
+    # 
+    # ```python async
+    # tweet_handle = await page.query_selector(".tweet .retweets")
+    # assert await tweet_handle.evaluate("node => node.innerText") == "10 retweets"
     # ```
-    def evaluate(pageFunction, arg: nil)
-      raise NotImplementedError.new('evaluate is not implemented yet.')
+    # 
+    # ```python sync
+    # tweet_handle = page.query_selector(".tweet .retweets")
+    # assert tweet_handle.evaluate("node => node.innerText") == "10 retweets"
+    # ```
+    def evaluate(expression, arg: nil)
+      wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
-    # Returns the return value of `pageFunction` as in-page object (JSHandle).
+    # Returns the return value of `expression` as a `JSHandle`.
     # 
-    # This method passes this handle as the first argument to `pageFunction`.
+    # This method passes this handle as the first argument to `expression`.
     # 
     # The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle` returns
-    # in-page object (JSHandle).
+    # `JSHandle`.
     # 
     # If the function passed to the `jsHandle.evaluateHandle` returns a [Promise], then `jsHandle.evaluateHandle` would wait
     # for the promise to resolve and return its value.
     # 
     # See [`method: Page.evaluateHandle`] for more details.
-    def evaluate_handle(pageFunction, arg: nil)
-      raise NotImplementedError.new('evaluate_handle is not implemented yet.')
+    def evaluate_handle(expression, arg: nil)
+      wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
     # The method returns a map with **own property names** as keys and JSHandle instances for the property values.
@@ -69,39 +88,65 @@ module Playwright
     # const documentHandle = properties.get('document');
     # await handle.dispose();
     # ```
+    # 
+    # ```python async
+    # handle = await page.evaluate_handle("{window, document}")
+    # properties = await handle.get_properties()
+    # window_handle = properties.get("window")
+    # document_handle = properties.get("document")
+    # await handle.dispose()
+    # ```
+    # 
+    # ```python sync
+    # handle = page.evaluate_handle("{window, document}")
+    # properties = handle.get_properties()
+    # window_handle = properties.get("window")
+    # document_handle = properties.get("document")
+    # handle.dispose()
+    # ```
     def get_properties
-      raise NotImplementedError.new('get_properties is not implemented yet.')
+      wrap_impl(@impl.get_properties)
     end
+    alias_method :properties, :get_properties
 
     # Fetches a single property from the referenced object.
     def get_property(propertyName)
-      raise NotImplementedError.new('get_property is not implemented yet.')
+      wrap_impl(@impl.get_property(unwrap_impl(propertyName)))
     end
 
     # Returns a JSON representation of the object. If the object has a `toJSON` function, it **will not be called**.
     # 
-    # > **NOTE** The method will return an empty JSON object if the referenced object is not stringifiable. It will throw an
+    # > NOTE: The method will return an empty JSON object if the referenced object is not stringifiable. It will throw an
     # error if the object has circular references.
     def json_value
-      raise NotImplementedError.new('json_value is not implemented yet.')
+      wrap_impl(@impl.json_value)
     end
 
-    # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_channel_owner(@channel_owner.off(event, callback))
+    def after_initialize
+      wrap_impl(@impl.after_initialize)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
-      wrap_channel_owner(@channel_owner.once(event, callback))
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)
-      wrap_channel_owner(@channel_owner.on(event, callback))
+      event_emitter_proxy.on(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end

data/lib/playwright_api/keyboard.rb

@@ -21,6 +21,28 @@ module Playwright
   # // Result text will end up saying 'Hello!'
   # ```
   # 
+  # ```python async
+  # await page.keyboard.type("Hello World!")
+  # await page.keyboard.press("ArrowLeft")
+  # await page.keyboard.down("Shift")
+  # for i in range(6):
+  #     await page.keyboard.press("ArrowLeft")
+  # await page.keyboard.up("Shift")
+  # await page.keyboard.press("Backspace")
+  # # result text will end up saying "Hello!"
+  # ```
+  # 
+  # ```python sync
+  # page.keyboard.type("Hello World!")
+  # page.keyboard.press("ArrowLeft")
+  # page.keyboard.down("Shift")
+  # for i in range(6):
+  #     page.keyboard.press("ArrowLeft")
+  # page.keyboard.up("Shift")
+  # page.keyboard.press("Backspace")
+  # # result text will end up saying "Hello!"
+  # ```
+  # 
   # An example of pressing uppercase `A`
   # 
   #
@@ -30,6 +52,18 @@ module Playwright
   # await page.keyboard.press('Shift+A');
   # ```
   # 
+  # ```python async
+  # await page.keyboard.press("Shift+KeyA")
+  # # or
+  # await page.keyboard.press("Shift+A")
+  # ```
+  # 
+  # ```python sync
+  # page.keyboard.press("Shift+KeyA")
+  # # or
+  # page.keyboard.press("Shift+A")
+  # ```
+  # 
   # An example to trigger select-all with the keyboard
   # 
   #
@@ -39,6 +73,20 @@ module Playwright
   # // on macOS
   # await page.keyboard.press('Meta+A');
   # ```
+  # 
+  # ```python async
+  # # on windows and linux
+  # await page.keyboard.press("Control+A")
+  # # on mac_os
+  # await page.keyboard.press("Meta+A")
+  # ```
+  # 
+  # ```python sync
+  # # on windows and linux
+  # page.keyboard.press("Control+A")
+  # # on mac_os
+  # page.keyboard.press("Meta+A")
+  # ```
   class Keyboard < PlaywrightApi
 
     # Dispatches a `keydown` event.
@@ -64,9 +112,9 @@ module Playwright
     # [repeat](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat) set to true. To release the key, use
     # [`method: Keyboard.up`].
     # 
-    # > **NOTE** Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.
+    # > NOTE: Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.
     def down(key)
-      raise NotImplementedError.new('down is not implemented yet.')
+      wrap_impl(@impl.down(unwrap_impl(key)))
     end
 
     # Dispatches only `input` event, does not emit the `keydown`, `keyup` or `keypress` events.
@@ -76,9 +124,17 @@ module Playwright
     # page.keyboard.insertText('嗨');
     # ```
     # 
-    # > **NOTE** Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper case.
+    # ```python async
+    # await page.keyboard.insert_text("嗨")
+    # ```
+    # 
+    # ```python sync
+    # page.keyboard.insert_text("嗨")
+    # ```
+    # 
+    # > NOTE: Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper case.
     def insert_text(text)
-      raise NotImplementedError.new('insert_text is not implemented yet.')
+      wrap_impl(@impl.insert_text(unwrap_impl(text)))
     end
 
     # `key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
@@ -111,9 +167,33 @@ module Playwright
     # await browser.close();
     # ```
     # 
+    # ```python async
+    # page = await browser.new_page()
+    # await page.goto("https://keycode.info")
+    # await page.keyboard.press("a")
+    # await page.screenshot(path="a.png")
+    # await page.keyboard.press("ArrowLeft")
+    # await page.screenshot(path="arrow_left.png")
+    # await page.keyboard.press("Shift+O")
+    # await page.screenshot(path="o.png")
+    # await browser.close()
+    # ```
+    # 
+    # ```python sync
+    # page = browser.new_page()
+    # page.goto("https://keycode.info")
+    # page.keyboard.press("a")
+    # page.screenshot(path="a.png")
+    # page.keyboard.press("ArrowLeft")
+    # page.screenshot(path="arrow_left.png")
+    # page.keyboard.press("Shift+O")
+    # page.screenshot(path="o.png")
+    # browser.close()
+    # ```
+    # 
     # Shortcut for [`method: Keyboard.down`] and [`method: Keyboard.up`].
     def press(key, delay: nil)
-      raise NotImplementedError.new('press is not implemented yet.')
+      wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay)))
     end
 
     # Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
@@ -126,14 +206,24 @@ module Playwright
     # await page.keyboard.type('World', {delay: 100}); // Types slower, like a user
     # ```
     # 
-    # > **NOTE** Modifier keys DO NOT effect `keyboard.type`. Holding down `Shift` will not type the text in upper case.
-    def type_text(text, delay: nil)
-      raise NotImplementedError.new('type_text is not implemented yet.')
+    # ```python async
+    # await page.keyboard.type("Hello") # types instantly
+    # await page.keyboard.type("World", delay=100) # types slower, like a user
+    # ```
+    # 
+    # ```python sync
+    # page.keyboard.type("Hello") # types instantly
+    # page.keyboard.type("World", delay=100) # types slower, like a user
+    # ```
+    # 
+    # > NOTE: Modifier keys DO NOT effect `keyboard.type`. Holding down `Shift` will not type the text in upper case.
+    def type(text, delay: nil)
+      wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay)))
     end
 
     # Dispatches a `keyup` event.
     def up(key)
-      raise NotImplementedError.new('up is not implemented yet.')
+      wrap_impl(@impl.up(unwrap_impl(key)))
     end
   end
 end

data/lib/playwright_api/mouse.rb

@@ -14,6 +14,28 @@ module Playwright
   # await page.mouse.move(0, 0);
   # await page.mouse.up();
   # ```
+  # 
+  # ```python async
+  # # using ‘page.mouse’ to trace a 100x100 square.
+  # await page.mouse.move(0, 0)
+  # await page.mouse.down()
+  # await page.mouse.move(0, 100)
+  # await page.mouse.move(100, 100)
+  # await page.mouse.move(100, 0)
+  # await page.mouse.move(0, 0)
+  # await page.mouse.up()
+  # ```
+  # 
+  # ```python sync
+  # # 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()
+  # ```
   class Mouse < PlaywrightApi
 
     # Shortcut for [`method: Mouse.move`], [`method: Mouse.down`], [`method: Mouse.up`].

data/lib/playwright_api/page.rb

@@ -1,9 +1,9 @@
 module Playwright
-  # - extends: [EventEmitter](https://nodejs.org/api/events.html#events_class_eventemitter)
+  # - extends: [EventEmitter]
   # 
   # Page provides methods to interact with a single tab in a `Browser`, or an
-  # [extension background page](https://developer.chrome.com/extensions/background_pages) in Chromium. One [Browser]
-  # instance might have multiple [Page] instances.
+  # [extension background page](https://developer.chrome.com/extensions/background_pages) in Chromium. One `Browser`
+  # instance might have multiple `Page` instances.
   # 
   # This example creates a page, navigates it to a URL, and then saves a screenshot:
   # 
@@ -21,6 +21,41 @@ module Playwright
   # })();
   # ```
   # 
+  # ```python async
+  # import asyncio
+  # from playwright.async_api import async_playwright
+  # 
+  # async def run(playwright):
+  #     webkit = playwright.webkit
+  #     browser = await webkit.launch()
+  #     context = await browser.new_context()
+  #     page = await context.new_page()
+  #     await page.goto("https://example.com")
+  #     await page.screenshot(path="screenshot.png")
+  #     await browser.close()
+  # 
+  # async def main():
+  #     async with async_playwright() as playwright:
+  #         await run(playwright)
+  # asyncio.run(main())
+  # ```
+  # 
+  # ```python sync
+  # from playwright.sync_api import sync_playwright
+  # 
+  # def run(playwright):
+  #     webkit = playwright.webkit
+  #     browser = webkit.launch()
+  #     context = browser.new_context()
+  #     page = context.new_page()
+  #     page.goto("https://example.com")
+  #     page.screenshot(path="screenshot.png")
+  #     browser.close()
+  # 
+  # with sync_playwright() as playwright:
+  #     run(playwright)
+  # ```
+  # 
   # The Page class emits various events (described below) which can be handled using any of Node's native
   # [`EventEmitter`](https://nodejs.org/api/events.html#events_class_eventemitter) methods, such as `on`, `once` or
   # `removeListener`.
@@ -32,6 +67,10 @@ module Playwright
   # page.once('load', () => console.log('Page loaded!'));
   # ```
   # 
+  # ```py
+  # page.once("load", lambda: print("page loaded!"))
+  # ```
+  # 
   # To unsubscribe from events use the `removeListener` method:
   # 
   #
@@ -43,10 +82,18 @@ module Playwright
   # // Sometime later...
   # page.removeListener('request', logRequest);
   # ```
+  # 
+  # ```py
+  # def log_request(intercepted_request):
+  #     print("a request was made:", intercepted_request.url)
+  # page.on("request", log_request)
+  # # sometime later...
+  # page.remove_listener("request", log_request)
+  # ```
   class Page < PlaywrightApi
 
     def accessibility # property
-      wrap_channel_owner(@channel_owner.accessibility)
+      wrap_impl(@impl.accessibility)
     end
 
     # Browser-specific Coverage implementation, only available for Chromium atm. See
@@ -56,67 +103,15 @@ module Playwright
     end
 
     def keyboard # property
-      wrap_channel_owner(@channel_owner.keyboard)
+      wrap_impl(@impl.keyboard)
     end
 
     def mouse # property
-      wrap_channel_owner(@channel_owner.mouse)
+      wrap_impl(@impl.mouse)
     end
 
     def touchscreen # property
-      wrap_channel_owner(@channel_owner.touchscreen)
-    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`.
-    # 
-    # Shortcut for main frame's [`method: Frame.$`].
-    def query_selector(selector)
-      raise NotImplementedError.new('query_selector is not implemented yet.')
-    end
-
-    # The method finds all elements matching the specified selector within the page. If no elements match the selector, the
-    # return value resolves to `[]`.
-    # 
-    # Shortcut for main frame's [`method: Frame.$$`].
-    def query_selector_all(selector)
-      raise NotImplementedError.new('query_selector_all is not implemented yet.')
-    end
-
-    # The method finds an element matching the specified selector within the page and passes it as a first argument to
-    # `pageFunction`. If no elements match the selector, the method throws an error. Returns the value of `pageFunction`.
-    # 
-    # If `pageFunction` returns a [Promise], then [`method: Page.$eval`] would wait for the promise to resolve and return its
-    # value.
-    # 
-    # Examples:
-    # 
-    #
-    # ```js
-    # const searchValue = await page.$eval('#search', el => el.value);
-    # const preloadHref = await page.$eval('link[rel=preload]', el => el.href);
-    # const html = await page.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');
-    # ```
-    # 
-    # Shortcut for main frame's [`method: Frame.$eval`].
-    def eval_on_selector(selector, pageFunction, arg: nil)
-      raise NotImplementedError.new('eval_on_selector is not implemented yet.')
-    end
-
-    # The method finds all elements matching the specified selector within the page and passes an array of matched elements as
-    # a first argument to `pageFunction`. Returns the result of `pageFunction` invocation.
-    # 
-    # If `pageFunction` returns a [Promise], then [`method: Page.$$eval`] would wait for the promise to resolve and return its
-    # value.
-    # 
-    # Examples:
-    # 
-    #
-    # ```js
-    # const divsCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);
-    # ```
-    def eval_on_selector_all(selector, pageFunction, arg: nil)
-      raise NotImplementedError.new('eval_on_selector_all is not implemented yet.')
+      wrap_impl(@impl.touchscreen)
     end
 
     # Adds a script which would be evaluated in one of the following scenarios:
@@ -130,19 +125,31 @@ module Playwright
     # An example of overriding `Math.random` before the page loads:
     # 
     #
-    # ```js
+    # ```js browser
     # // preload.js
     # Math.random = () => 42;
+    # ```
     # 
+    #
+    # ```js
     # // In your playwright script, assuming the preload.js file is in same directory
-    # const preloadFile = fs.readFileSync('./preload.js', 'utf8');
-    # await page.addInitScript(preloadFile);
+    # await page.addInitScript({ path: './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")
     # ```
     # 
-    # > **NOTE** The order of evaluation of multiple scripts installed via [`method: BrowserContext.addInitScript`] and
+    # ```python sync
+    # # in your playwright script, assuming the preload.js file is in same directory
+    # page.add_init_script(path="./preload.js")
+    # ```
+    # 
+    # > NOTE: The order of evaluation of multiple scripts installed via [`method: BrowserContext.addInitScript`] and
     # [`method: Page.addInitScript`] is not defined.
     def add_init_script(script, arg: nil)
-      raise NotImplementedError.new('add_init_script is not implemented yet.')
+      wrap_impl(@impl.add_init_script(unwrap_impl(script), arg: unwrap_impl(arg)))
     end
 
     # Adds a `<script>` tag into the page with the desired url or content. Returns the added tag when the script's onload
@@ -150,7 +157,7 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.addScriptTag`].
     def add_script_tag(content: nil, path: nil, type: nil, url: nil)
-      raise NotImplementedError.new('add_script_tag is not implemented yet.')
+      wrap_impl(@impl.add_script_tag(content: unwrap_impl(content), path: unwrap_impl(path), type: unwrap_impl(type), url: unwrap_impl(url)))
     end
 
     # Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the
@@ -158,12 +165,12 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.addStyleTag`].
     def add_style_tag(content: nil, path: nil, url: nil)
-      raise NotImplementedError.new('add_style_tag is not implemented yet.')
+      wrap_impl(@impl.add_style_tag(content: unwrap_impl(content), path: unwrap_impl(path), url: unwrap_impl(url)))
     end
 
     # Brings page to front (activates tab).
     def bring_to_front
-      raise NotImplementedError.new('bring_to_front is not implemented yet.')
+      wrap_impl(@impl.bring_to_front)
     end
 
     # This method checks an element matching `selector` by performing the following steps:
@@ -182,7 +189,7 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.check`].
     def check(selector, force: nil, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('check is not implemented yet.')
+      wrap_impl(@impl.check(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # This method clicks an element matching `selector` by performing the following steps:
@@ -207,7 +214,7 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('click is not implemented yet.')
+      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)))
     end
 
     # If `runBeforeUnload` is `false`, does not run any unload handlers and waits for the page to be closed. If
@@ -215,20 +222,20 @@ module Playwright
     # 
     # By default, `page.close()` **does not** run `beforeunload` handlers.
     # 
-    # > **NOTE** if `runBeforeUnload` is passed as true, a `beforeunload` dialog might be summoned
-    # > and should be handled manually via [`event: Page.dialog`] event.
+    # > NOTE: if `runBeforeUnload` is passed as true, a `beforeunload` dialog might be summoned and should be handled manually
+    # via [`event: Page.dialog`] event.
     def close(runBeforeUnload: nil)
-      wrap_channel_owner(@channel_owner.close(runBeforeUnload: runBeforeUnload))
+      wrap_impl(@impl.close(runBeforeUnload: unwrap_impl(runBeforeUnload)))
     end
 
     # Gets the full HTML contents of the page, including the doctype.
     def content
-      wrap_channel_owner(@channel_owner.content)
+      wrap_impl(@impl.content)
     end
 
     # Get the browser context that the page belongs to.
     def context
-      wrap_channel_owner(@channel_owner.context)
+      wrap_impl(@impl.context)
     end
 
     # This method double clicks an element matching `selector` by performing the following steps:
@@ -243,7 +250,7 @@ module Playwright
     # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
     # Passing zero timeout disables this.
     # 
-    # > **NOTE** `page.dblclick()` dispatches two `click` events and a single `dblclick` event.
+    # > NOTE: `page.dblclick()` dispatches two `click` events and a single `dblclick` event.
     # 
     # Shortcut for main frame's [`method: Frame.dblclick`].
     def dblclick(
@@ -255,7 +262,7 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('dblclick is not implemented yet.')
+      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`
@@ -267,6 +274,14 @@ module Playwright
     # await page.dispatchEvent('button#submit', 'click');
     # ```
     # 
+    # ```python async
+    # await page.dispatch_event("button#submit", "click")
+    # ```
+    # 
+    # ```python sync
+    # page.dispatch_event("button#submit", "click")
+    # ```
+    # 
     # Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
     # and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
     # 
@@ -287,8 +302,20 @@ module Playwright
     # const dataTransfer = await page.evaluateHandle(() => new DataTransfer());
     # await page.dispatchEvent('#source', 'dragstart', { dataTransfer });
     # ```
+    # 
+    # ```python async
+    # # note you can only create data_transfer in chromium and firefox
+    # data_transfer = await page.evaluate_handle("new DataTransfer()")
+    # await page.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
+    # ```
+    # 
+    # ```python sync
+    # # note you can only create data_transfer in chromium and firefox
+    # data_transfer = page.evaluate_handle("new DataTransfer()")
+    # page.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
+    # ```
     def dispatch_event(selector, type, eventInit: nil, timeout: nil)
-      raise NotImplementedError.new('dispatch_event is not implemented yet.')
+      wrap_impl(@impl.dispatch_event(unwrap_impl(selector), unwrap_impl(type), eventInit: unwrap_impl(eventInit), timeout: unwrap_impl(timeout)))
     end
 
     # 
@@ -312,6 +339,44 @@ module Playwright
     # // → false
     # ```
     # 
+    # ```python async
+    # await page.evaluate("matchMedia('screen').matches")
+    # # → True
+    # await page.evaluate("matchMedia('print').matches")
+    # # → False
+    # 
+    # await page.emulate_media(media="print")
+    # await page.evaluate("matchMedia('screen').matches")
+    # # → False
+    # await page.evaluate("matchMedia('print').matches")
+    # # → True
+    # 
+    # await page.emulate_media()
+    # await page.evaluate("matchMedia('screen').matches")
+    # # → True
+    # await page.evaluate("matchMedia('print').matches")
+    # # → False
+    # ```
+    # 
+    # ```python sync
+    # page.evaluate("matchMedia('screen').matches")
+    # # → True
+    # page.evaluate("matchMedia('print').matches")
+    # # → False
+    # 
+    # page.emulate_media(media="print")
+    # page.evaluate("matchMedia('screen').matches")
+    # # → False
+    # page.evaluate("matchMedia('print').matches")
+    # # → True
+    # 
+    # page.emulate_media()
+    # page.evaluate("matchMedia('screen').matches")
+    # # → True
+    # page.evaluate("matchMedia('print').matches")
+    # # → False
+    # ```
+    # 
     #
     # ```js
     # await page.emulateMedia({ colorScheme: 'dark' });
@@ -322,20 +387,95 @@ module Playwright
     # await page.evaluate(() => matchMedia('(prefers-color-scheme: no-preference)').matches);
     # // → false
     # ```
-    def emulate_media(params)
-      raise NotImplementedError.new('emulate_media is not implemented yet.')
+    # 
+    # ```python async
+    # await page.emulate_media(color_scheme="dark")
+    # await page.evaluate("matchMedia('(prefers-color-scheme: dark)').matches")
+    # # → True
+    # await page.evaluate("matchMedia('(prefers-color-scheme: light)').matches")
+    # # → False
+    # await page.evaluate("matchMedia('(prefers-color-scheme: no-preference)').matches")
+    # # → False
+    # ```
+    # 
+    # ```python sync
+    # page.emulate_media(color_scheme="dark")
+    # page.evaluate("matchMedia('(prefers-color-scheme: dark)').matches")
+    # # → True
+    # page.evaluate("matchMedia('(prefers-color-scheme: light)').matches")
+    # # → False
+    # page.evaluate("matchMedia('(prefers-color-scheme: no-preference)').matches")
+    # ```
+    def emulate_media(colorScheme: nil, media: nil)
+      wrap_impl(@impl.emulate_media(colorScheme: unwrap_impl(colorScheme), media: unwrap_impl(media)))
     end
 
-    # Returns the value of the `pageFunction` invocation.
+    # The method finds an element matching the specified selector within the page and passes it as a first argument to
+    # `expression`. If no elements match the selector, the method throws an error. Returns the value of `expression`.
+    # 
+    # If `expression` returns a [Promise], then [`method: Page.evalOnSelector`] would wait for the promise to resolve and
+    # return its value.
+    # 
+    # Examples:
+    # 
+    #
+    # ```js
+    # const searchValue = await page.$eval('#search', el => el.value);
+    # const preloadHref = await page.$eval('link[rel=preload]', el => el.href);
+    # const html = await page.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');
+    # ```
+    # 
+    # ```python async
+    # search_value = await page.eval_on_selector("#search", "el => el.value")
+    # preload_href = await page.eval_on_selector("link[rel=preload]", "el => el.href")
+    # html = await page.eval_on_selector(".main-container", "(e, suffix) => e.outer_html + suffix", "hello")
+    # ```
+    # 
+    # ```python sync
+    # search_value = page.eval_on_selector("#search", "el => el.value")
+    # preload_href = page.eval_on_selector("link[rel=preload]", "el => el.href")
+    # html = page.eval_on_selector(".main-container", "(e, suffix) => e.outer_html + suffix", "hello")
+    # ```
+    # 
+    # Shortcut for main frame's [`method: Frame.evalOnSelector`].
+    def eval_on_selector(selector, expression, arg: nil)
+      wrap_impl(@impl.eval_on_selector(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
+    end
+
+    # The method finds all elements matching the specified selector within the page and passes an array of matched elements as
+    # a first argument to `expression`. Returns the result of `expression` invocation.
+    # 
+    # If `expression` returns a [Promise], then [`method: Page.evalOnSelectorAll`] would wait for the promise to resolve and
+    # return its value.
+    # 
+    # Examples:
+    # 
+    #
+    # ```js
+    # const divCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);
+    # ```
+    # 
+    # ```python async
+    # div_counts = await page.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
+    # ```
+    # 
+    # ```python sync
+    # div_counts = page.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
+    # ```
+    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
+
+    # Returns the value of the `expression` invocation.
     # 
-    # If the function passed to the `page.evaluate` returns a [Promise], then `page.evaluate` would wait for the promise to
-    # resolve and return its value.
+    # If the function passed to the [`method: Page.evaluate`] returns a [Promise], then [`method: Page.evaluate`] would wait
+    # for the promise to resolve and return its value.
     # 
-    # If the function passed to the `page.evaluate` returns a non-[Serializable] value, then `page.evaluate` resolves to
-    # `undefined`. DevTools Protocol also supports transferring some additional values that are not serializable by `JSON`:
-    # `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
+    # If the function passed to the [`method: Page.evaluate`] returns a non-[Serializable] value, then
+    # [`method: Page.evaluate`] resolves to `undefined`. Playwright also supports transferring some additional values that are
+    # not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
     # 
-    # Passing argument to `pageFunction`:
+    # Passing argument to `expression`:
     # 
     #
     # ```js
@@ -345,6 +485,16 @@ module Playwright
     # console.log(result); // prints "56"
     # ```
     # 
+    # ```python async
+    # result = await page.evaluate("([x, y]) => Promise.resolve(x * y)", [7, 8])
+    # print(result) # prints "56"
+    # ```
+    # 
+    # ```python sync
+    # result = page.evaluate("([x, y]) => Promise.resolve(x * y)", [7, 8])
+    # print(result) # prints "56"
+    # ```
+    # 
     # A string can also be passed in instead of a function:
     # 
     #
@@ -354,7 +504,19 @@ module Playwright
     # console.log(await page.evaluate(`1 + ${x}`)); // prints "11"
     # ```
     # 
-    # `ElementHandle` instances can be passed as an argument to the `page.evaluate`:
+    # ```python async
+    # print(await page.evaluate("1 + 2")) # prints "3"
+    # x = 10
+    # print(await page.evaluate(f"1 + {x}")) # prints "11"
+    # ```
+    # 
+    # ```python sync
+    # print(page.evaluate("1 + 2")) # prints "3"
+    # x = 10
+    # print(page.evaluate(f"1 + {x}")) # prints "11"
+    # ```
+    # 
+    # `ElementHandle` instances can be passed as an argument to the [`method: Page.evaluate`]:
     # 
     #
     # ```js
@@ -363,18 +525,46 @@ module Playwright
     # await bodyHandle.dispose();
     # ```
     # 
+    # ```python async
+    # body_handle = await page.query_selector("body")
+    # html = await page.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
+    # await body_handle.dispose()
+    # ```
+    # 
+    # ```python sync
+    # body_handle = page.query_selector("body")
+    # html = page.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
+    # body_handle.dispose()
+    # ```
+    # 
     # Shortcut for main frame's [`method: Frame.evaluate`].
-    def evaluate(pageFunction, arg: nil)
-      wrap_channel_owner(@channel_owner.evaluate(pageFunction, arg: arg))
+    def evaluate(expression, arg: nil)
+      wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
-    # Returns the value of the `pageFunction` invocation as in-page object (JSHandle).
+    # Returns the value of the `expression` invocation as a `JSHandle`.
+    # 
+    # The only difference between [`method: Page.evaluate`] and [`method: Page.evaluateHandle`] is that
+    # [`method: Page.evaluateHandle`] returns `JSHandle`.
     # 
-    # The only difference between `page.evaluate` and `page.evaluateHandle` is that `page.evaluateHandle` returns in-page
-    # object (JSHandle).
+    # If the function passed to the [`method: Page.evaluateHandle`] returns a [Promise], then [`method: Page.evaluateHandle`]
+    # would wait for the promise to resolve and return its value.
     # 
-    # If the function passed to the `page.evaluateHandle` returns a [Promise], then `page.evaluateHandle` would wait for the
-    # promise to resolve and return its value.
+    #
+    # ```js
+    # const aWindowHandle = await page.evaluateHandle(() => Promise.resolve(window));
+    # aWindowHandle; // Handle for the window object.
+    # ```
+    # 
+    # ```python async
+    # a_window_handle = await page.evaluate_handle("Promise.resolve(window)")
+    # a_window_handle # handle for the window object.
+    # ```
+    # 
+    # ```python sync
+    # a_window_handle = page.evaluate_handle("Promise.resolve(window)")
+    # a_window_handle # handle for the window object.
+    # ```
     # 
     # A string can also be passed in instead of a function:
     # 
@@ -383,7 +573,15 @@ module Playwright
     # const aHandle = await page.evaluateHandle('document'); // Handle for the 'document'
     # ```
     # 
-    # `JSHandle` instances can be passed as an argument to the `page.evaluateHandle`:
+    # ```python async
+    # a_handle = await page.evaluate_handle("document") # handle for the "document"
+    # ```
+    # 
+    # ```python sync
+    # a_handle = page.evaluate_handle("document") # handle for the "document"
+    # ```
+    # 
+    # `JSHandle` instances can be passed as an argument to the [`method: Page.evaluateHandle`]:
     # 
     #
     # ```js
@@ -392,8 +590,22 @@ module Playwright
     # console.log(await resultHandle.jsonValue());
     # await resultHandle.dispose();
     # ```
-    def evaluate_handle(pageFunction, arg: nil)
-      wrap_channel_owner(@channel_owner.evaluate_handle(pageFunction, arg: arg))
+    # 
+    # ```python async
+    # a_handle = await page.evaluate_handle("document.body")
+    # result_handle = await page.evaluate_handle("body => body.innerHTML", a_handle)
+    # print(await result_handle.json_value())
+    # await result_handle.dispose()
+    # ```
+    # 
+    # ```python sync
+    # a_handle = page.evaluate_handle("document.body")
+    # result_handle = page.evaluate_handle("body => body.innerHTML", a_handle)
+    # print(result_handle.json_value())
+    # result_handle.dispose()
+    # ```
+    def evaluate_handle(expression, arg: nil)
+      wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
     # The method adds a function called `name` on the `window` object of every frame in this page. When called, the function
@@ -405,7 +617,7 @@ module Playwright
     # 
     # See [`method: BrowserContext.exposeBinding`] for the context-wide version.
     # 
-    # > **NOTE** Functions installed via `page.exposeBinding` survive navigations.
+    # > NOTE: Functions installed via [`method: Page.exposeBinding`] survive navigations.
     # 
     # An example of exposing page URL to all frames in a page:
     # 
@@ -431,6 +643,57 @@ module Playwright
     # })();
     # ```
     # 
+    # ```python async
+    # import asyncio
+    # from playwright.async_api import async_playwright
+    # 
+    # async def run(playwright):
+    #     webkit = playwright.webkit
+    #     browser = await webkit.launch(headless=false)
+    #     context = await browser.new_context()
+    #     page = await context.new_page()
+    #     await page.expose_binding("pageURL", lambda source: source["page"].url)
+    #     await page.set_content("""
+    #     <script>
+    #       async function onClick() {
+    #         document.querySelector('div').textContent = await window.pageURL();
+    #       }
+    #     </script>
+    #     <button onclick="onClick()">Click me</button>
+    #     <div></div>
+    #     """)
+    #     await page.click("button")
+    # 
+    # async def main():
+    #     async with async_playwright() as playwright:
+    #         await run(playwright)
+    # asyncio.run(main())
+    # ```
+    # 
+    # ```python sync
+    # from playwright.sync_api import sync_playwright
+    # 
+    # def run(playwright):
+    #     webkit = playwright.webkit
+    #     browser = webkit.launch(headless=false)
+    #     context = browser.new_context()
+    #     page = context.new_page()
+    #     page.expose_binding("pageURL", lambda source: source["page"].url)
+    #     page.set_content("""
+    #     <script>
+    #       async function onClick() {
+    #         document.querySelector('div').textContent = await window.pageURL();
+    #       }
+    #     </script>
+    #     <button onclick="onClick()">Click me</button>
+    #     <div></div>
+    #     """)
+    #     page.click("button")
+    # 
+    # with sync_playwright() as playwright:
+    #     run(playwright)
+    # ```
+    # 
     # An example of passing an element handle:
     # 
     #
@@ -446,8 +709,36 @@ module Playwright
     #   <div>Or click me</div>
     # `);
     # ```
+    # 
+    # ```python async
+    # async def print(source, element):
+    #     print(await element.text_content())
+    # 
+    # await page.expose_binding("clicked", print, handle=true)
+    # await page.set_content("""
+    #   <script>
+    #     document.addEventListener('click', event => window.clicked(event.target));
+    #   </script>
+    #   <div>Click me</div>
+    #   <div>Or click me</div>
+    # """)
+    # ```
+    # 
+    # ```python sync
+    # def print(source, element):
+    #     print(element.text_content())
+    # 
+    # page.expose_binding("clicked", print, handle=true)
+    # page.set_content("""
+    #   <script>
+    #     document.addEventListener('click', event => window.clicked(event.target));
+    #   </script>
+    #   <div>Click me</div>
+    #   <div>Or click me</div>
+    # """)
+    # ```
     def expose_binding(name, callback, handle: nil)
-      raise NotImplementedError.new('expose_binding is not implemented yet.')
+      wrap_impl(@impl.expose_binding(unwrap_impl(name), unwrap_impl(callback), handle: unwrap_impl(handle)))
     end
 
     # The method adds a function called `name` on the `window` object of every frame in the page. When called, the function
@@ -457,9 +748,9 @@ module Playwright
     # 
     # See [`method: BrowserContext.exposeFunction`] for context-wide exposed function.
     # 
-    # > **NOTE** Functions installed via `page.exposeFunction` survive navigations.
+    # > NOTE: Functions installed via [`method: Page.exposeFunction`] survive navigations.
     # 
-    # An example of adding an `md5` function to the page:
+    # An example of adding an `sha1` function to the page:
     # 
     #
     # ```js
@@ -469,11 +760,11 @@ module Playwright
     # (async () => {
     #   const browser = await webkit.launch({ headless: false });
     #   const page = await browser.newPage();
-    #   await page.exposeFunction('md5', text => crypto.createHash('md5').update(text).digest('hex'));
+    #   await page.exposeFunction('sha1', text => crypto.createHash('sha1').update(text).digest('hex'));
     #   await page.setContent(`
     #     <script>
     #       async function onClick() {
-    #         document.querySelector('div').textContent = await window.md5('PLAYWRIGHT');
+    #         document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');
     #       }
     #     </script>
     #     <button onclick="onClick()">Click me</button>
@@ -483,49 +774,83 @@ module Playwright
     # })();
     # ```
     # 
-    # An example of adding a `window.readfile` function to the page:
-    # 
-    #
-    # ```js
-    # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
-    # const fs = require('fs');
+    # ```python async
+    # import asyncio
+    # import hashlib
+    # from playwright.async_api import async_playwright
+    # 
+    # async def sha1(text):
+    #     m = hashlib.sha1()
+    #     m.update(bytes(text, "utf8"))
+    #     return m.hexdigest()
+    # 
+    # 
+    # async def run(playwright):
+    #     webkit = playwright.webkit
+    #     browser = await webkit.launch(headless=False)
+    #     page = await browser.new_page()
+    #     await page.expose_function("sha1", sha1)
+    #     await page.set_content("""
+    #         <script>
+    #           async function onClick() {
+    #             document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');
+    #           }
+    #         </script>
+    #         <button onclick="onClick()">Click me</button>
+    #         <div></div>
+    #     """)
+    #     await page.click("button")
+    # 
+    # async def main():
+    #     async with async_playwright() as playwright:
+    #         await run(playwright)
+    # asyncio.run(main())
+    # ```
     # 
-    # (async () => {
-    #   const browser = await chromium.launch();
-    #   const page = await browser.newPage();
-    #   page.on('console', msg => console.log(msg.text()));
-    #   await page.exposeFunction('readfile', async filePath => {
-    #     return new Promise((resolve, reject) => {
-    #       fs.readFile(filePath, 'utf8', (err, text) => {
-    #         if (err)
-    #           reject(err);
-    #         else
-    #           resolve(text);
-    #       });
-    #     });
-    #   });
-    #   await page.evaluate(async () => {
-    #     // use window.readfile to read contents of a file
-    #     const content = await window.readfile('/etc/hosts');
-    #     console.log(content);
-    #   });
-    #   await browser.close();
-    # })();
+    # ```python sync
+    # import hashlib
+    # from playwright.sync_api import sync_playwright
+    # 
+    # def sha1(text):
+    #     m = hashlib.sha1()
+    #     m.update(bytes(text, "utf8"))
+    #     return m.hexdigest()
+    # 
+    # 
+    # def run(playwright):
+    #     webkit = playwright.webkit
+    #     browser = webkit.launch(headless=False)
+    #     page = browser.new_page()
+    #     page.expose_function("sha1", sha1)
+    #     page.set_content("""
+    #         <script>
+    #           async function onClick() {
+    #             document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');
+    #           }
+    #         </script>
+    #         <button onclick="onClick()">Click me</button>
+    #         <div></div>
+    #     """)
+    #     page.click("button")
+    # 
+    # with sync_playwright() as playwright:
+    #     run(playwright)
     # ```
     def expose_function(name, callback)
-      raise NotImplementedError.new('expose_function is not implemented yet.')
+      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 matching `selector` 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. 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.
     # 
     # To send fine-grained keyboard events, use [`method: Page.type`].
     # 
     # Shortcut for main frame's [`method: Frame.fill`]
     def fill(selector, value, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('fill is not implemented yet.')
+      wrap_impl(@impl.fill(unwrap_impl(selector), unwrap_impl(value), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the method
@@ -533,7 +858,7 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.focus`].
     def focus(selector, timeout: nil)
-      wrap_channel_owner(@channel_owner.focus(selector, timeout: timeout))
+      wrap_impl(@impl.focus(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns frame matching the specified criteria. Either `name` or `url` must be specified.
@@ -543,22 +868,30 @@ module Playwright
     # const frame = page.frame('frame-name');
     # ```
     # 
+    # ```py
+    # frame = page.frame(name="frame-name")
+    # ```
+    # 
     #
     # ```js
     # const frame = page.frame({ url: /.*domain.*/ });
     # ```
+    # 
+    # ```py
+    # frame = page.frame(url=r".*domain.*")
+    # ```
     def frame(frameSelector)
-      wrap_channel_owner(@channel_owner.frame(frameSelector))
+      wrap_impl(@impl.frame(unwrap_impl(frameSelector)))
     end
 
     # An array of all frames attached to the page.
     def frames
-      wrap_channel_owner(@channel_owner.frames)
+      wrap_impl(@impl.frames)
     end
 
     # Returns element attribute value.
     def get_attribute(selector, name, timeout: nil)
-      raise NotImplementedError.new('get_attribute is not implemented yet.')
+      wrap_impl(@impl.get_attribute(unwrap_impl(selector), unwrap_impl(name), timeout: unwrap_impl(timeout)))
     end
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
@@ -566,7 +899,7 @@ module Playwright
     # 
     # Navigate to the previous page in history.
     def go_back(timeout: nil, waitUntil: nil)
-      raise NotImplementedError.new('go_back is not implemented yet.')
+      wrap_impl(@impl.go_back(timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
@@ -574,7 +907,7 @@ module Playwright
     # 
     # Navigate to the next page in history.
     def go_forward(timeout: nil, waitUntil: nil)
-      raise NotImplementedError.new('go_forward is not implemented yet.')
+      wrap_impl(@impl.go_forward(timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
@@ -591,14 +924,14 @@ module Playwright
     # Found" and 500 "Internal Server Error".  The status code for such responses can be retrieved by calling
     # [`method: Response.status`].
     # 
-    # > **NOTE** `page.goto` either throws an error or returns a main resource response. The only exceptions are navigation to
+    # > NOTE: `page.goto` either throws an error or returns a main resource response. The only exceptions are navigation to
     # `about:blank` or navigation to the same URL with a different hash, which would succeed and return `null`.
-    # > **NOTE** Headless mode doesn't support navigation to a PDF document. See the
+    # > NOTE: Headless mode doesn't support navigation to a PDF document. See the
     # [upstream issue](https://bugs.chromium.org/p/chromium/issues/detail?id=761295).
     # 
     # Shortcut for main frame's [`method: Frame.goto`]
     def goto(url, referer: nil, timeout: nil, waitUntil: nil)
-      wrap_channel_owner(@channel_owner.goto(url, referer: referer, timeout: timeout, waitUntil: waitUntil))
+      wrap_impl(@impl.goto(unwrap_impl(url), referer: unwrap_impl(referer), timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
 
     # This method hovers over an element matching `selector` by performing the following steps:
@@ -619,72 +952,84 @@ module Playwright
           modifiers: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('hover is not implemented yet.')
+      wrap_impl(@impl.hover(unwrap_impl(selector), force: unwrap_impl(force), modifiers: unwrap_impl(modifiers), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
     end
 
     # Returns `element.innerHTML`.
     def inner_html(selector, timeout: nil)
-      raise NotImplementedError.new('inner_html is not implemented yet.')
+      wrap_impl(@impl.inner_html(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns `element.innerText`.
     def inner_text(selector, timeout: nil)
-      raise NotImplementedError.new('inner_text is not implemented yet.')
+      wrap_impl(@impl.inner_text(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
     def checked?(selector, timeout: nil)
-      raise NotImplementedError.new('checked? is not implemented yet.')
+      wrap_impl(@impl.checked?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Indicates that the page has been closed.
     def closed?
-      wrap_channel_owner(@channel_owner.closed?)
+      wrap_impl(@impl.closed?)
     end
 
     # Returns whether the element is disabled, the opposite of [enabled](./actionability.md#enabled).
     def disabled?(selector, timeout: nil)
-      raise NotImplementedError.new('disabled? is not implemented yet.')
+      wrap_impl(@impl.disabled?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns whether the element is [editable](./actionability.md#editable).
     def editable?(selector, timeout: nil)
-      raise NotImplementedError.new('editable? is not implemented yet.')
+      wrap_impl(@impl.editable?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns whether the element is [enabled](./actionability.md#enabled).
     def enabled?(selector, timeout: nil)
-      raise NotImplementedError.new('enabled? is not implemented yet.')
+      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).
     def hidden?(selector, timeout: nil)
-      raise NotImplementedError.new('hidden? is not implemented yet.')
+      wrap_impl(@impl.hidden?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns whether the element is [visible](./actionability.md#visible).
     def visible?(selector, timeout: nil)
-      raise NotImplementedError.new('visible? is not implemented yet.')
+      wrap_impl(@impl.visible?(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # The page's main frame. Page is guaranteed to have a main frame which persists during navigations.
     def main_frame
-      wrap_channel_owner(@channel_owner.main_frame)
+      wrap_impl(@impl.main_frame)
     end
 
     # Returns the opener for popup pages and `null` for others. If the opener has been closed already the returns `null`.
     def opener
-      wrap_channel_owner(@channel_owner.opener)
+      wrap_impl(@impl.opener)
+    end
+
+    # Pauses script execution. Playwright will stop executing the script and wait for the user to either press 'Resume' button
+    # in the page overlay or to call `playwright.resume()` in the DevTools console.
+    # 
+    # User can inspect selectors or perform manual steps while paused. Resume will continue running the original script from
+    # the place it was paused.
+    # 
+    # > NOTE: This method requires Playwright to be started in a headed mode, with a falsy [`options: headless`] value in the
+    # [`method: BrowserType.launch`].
+    def pause
+      raise NotImplementedError.new('pause is not implemented yet.')
     end
 
     # Returns the PDF buffer.
     # 
-    # > **NOTE** Generating a pdf is currently only supported in Chromium headless.
+    # > NOTE: Generating a pdf is currently only supported in Chromium headless.
     # 
     # `page.pdf()` generates a pdf of the page with `print` css media. To generate a pdf with `screen` media, call
     # [`method: Page.emulateMedia`] before calling `page.pdf()`:
     # 
-    # > **NOTE** By default, `page.pdf()` generates a pdf with modified colors for printing. Use the
+    # > NOTE: By default, `page.pdf()` generates a pdf with modified colors for printing. Use the
     # [`-webkit-print-color-adjust`](https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-print-color-adjust) property to
     # force rendering of exact colors.
     # 
@@ -695,6 +1040,18 @@ module Playwright
     # await page.pdf({path: 'page.pdf'});
     # ```
     # 
+    # ```python async
+    # # generates a pdf with "screen" media type.
+    # await page.emulate_media(media="screen")
+    # await page.pdf(path="page.pdf")
+    # ```
+    # 
+    # ```python sync
+    # # generates a pdf with "screen" media type.
+    # page.emulate_media(media="screen")
+    # page.pdf(path="page.pdf")
+    # ```
+    # 
     # The `width`, `height`, and `margin` options accept values labeled with units. Unlabeled values are treated as pixels.
     # 
     # A few examples:
@@ -721,9 +1078,8 @@ module Playwright
     # - `A5`: 5.83in x 8.27in
     # - `A6`: 4.13in x 5.83in
     # 
-    # > **NOTE** `headerTemplate` and `footerTemplate` markup have the following limitations:
-    # > 1. Script tags inside templates are not evaluated.
-    # > 2. Page styles are not visible inside templates.
+    # > NOTE: `headerTemplate` and `footerTemplate` markup have the following limitations: > 1. Script tags inside templates
+    # are not evaluated. > 2. Page styles are not visible inside templates.
     def pdf(
           displayHeaderFooter: nil,
           footerTemplate: nil,
@@ -738,7 +1094,7 @@ module Playwright
           printBackground: nil,
           scale: nil,
           width: nil)
-      raise NotImplementedError.new('pdf is not implemented yet.')
+      wrap_impl(@impl.pdf(displayHeaderFooter: unwrap_impl(displayHeaderFooter), footerTemplate: unwrap_impl(footerTemplate), format: unwrap_impl(format), headerTemplate: unwrap_impl(headerTemplate), height: unwrap_impl(height), landscape: unwrap_impl(landscape), margin: unwrap_impl(margin), pageRanges: unwrap_impl(pageRanges), path: unwrap_impl(path), preferCSSPageSize: unwrap_impl(preferCSSPageSize), printBackground: unwrap_impl(printBackground), scale: unwrap_impl(scale), width: unwrap_impl(width)))
     end
 
     # Focuses the element, and then uses [`method: Keyboard.down`] and [`method: Keyboard.up`].
@@ -772,26 +1128,66 @@ module Playwright
     # await page.screenshot({ path: 'O.png' });
     # await browser.close();
     # ```
+    # 
+    # ```python async
+    # page = await browser.new_page()
+    # await page.goto("https://keycode.info")
+    # await page.press("body", "A")
+    # await page.screenshot(path="a.png")
+    # await page.press("body", "ArrowLeft")
+    # await page.screenshot(path="arrow_left.png")
+    # await page.press("body", "Shift+O")
+    # await page.screenshot(path="o.png")
+    # await browser.close()
+    # ```
+    # 
+    # ```python sync
+    # page = browser.new_page()
+    # page.goto("https://keycode.info")
+    # page.press("body", "A")
+    # page.screenshot(path="a.png")
+    # page.press("body", "ArrowLeft")
+    # page.screenshot(path="arrow_left.png")
+    # page.press("body", "Shift+O")
+    # page.screenshot(path="o.png")
+    # browser.close()
+    # ```
     def press(
           selector,
           key,
           delay: nil,
           noWaitAfter: nil,
           timeout: nil)
-      wrap_channel_owner(@channel_owner.press(selector, key, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
+      wrap_impl(@impl.press(unwrap_impl(selector), unwrap_impl(key), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    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`.
+    # 
+    # Shortcut for main frame's [`method: Frame.querySelector`].
+    def query_selector(selector)
+      wrap_impl(@impl.query_selector(unwrap_impl(selector)))
+    end
+
+    # The method finds all elements matching the specified selector within the page. If no elements match the selector, the
+    # return value resolves to `[]`.
+    # 
+    # Shortcut for main frame's [`method: Frame.querySelectorAll`].
+    def query_selector_all(selector)
+      wrap_impl(@impl.query_selector_all(unwrap_impl(selector)))
     end
 
     # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
     # last redirect.
     def reload(timeout: nil, waitUntil: nil)
-      raise NotImplementedError.new('reload is not implemented yet.')
+      wrap_impl(@impl.reload(timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
 
     # Routing provides the capability to modify network requests that are made by a page.
     # 
     # Once routing is enabled, every request matching the url pattern will stall unless it's continued, fulfilled or aborted.
     # 
-    # > **NOTE** The handler will only be called for the first url if the response is a redirect.
+    # > 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:
     # 
@@ -803,6 +1199,20 @@ module Playwright
     # await browser.close();
     # ```
     # 
+    # ```python async
+    # page = await browser.new_page()
+    # await page.route("**/*.{png,jpg,jpeg}", lambda route: route.abort())
+    # await page.goto("https://example.com")
+    # await browser.close()
+    # ```
+    # 
+    # ```python sync
+    # page = browser.new_page()
+    # page.route("**/*.{png,jpg,jpeg}", lambda route: route.abort())
+    # page.goto("https://example.com")
+    # browser.close()
+    # ```
+    # 
     # or the same snippet using a regex pattern instead:
     # 
     #
@@ -813,17 +1223,31 @@ module Playwright
     # await browser.close();
     # ```
     # 
+    # ```python async
+    # page = await browser.new_page()
+    # await page.route(re.compile(r"(\.png$)|(\.jpg$)"), lambda route: route.abort())
+    # await page.goto("https://example.com")
+    # await browser.close()
+    # ```
+    # 
+    # ```python sync
+    # page = browser.new_page()
+    # page.route(re.compile(r"(\.png$)|(\.jpg$)"), lambda route: route.abort())
+    # page.goto("https://example.com")
+    # browser.close()
+    # ```
+    # 
     # Page routes take precedence over browser context routes (set up with [`method: BrowserContext.route`]) when request
     # matches both handlers.
     # 
-    # > **NOTE** Enabling routing disables http cache.
+    # > NOTE: Enabling routing disables http cache.
     def route(url, handler)
       raise NotImplementedError.new('route is not implemented yet.')
     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
+    # > 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,
@@ -833,7 +1257,7 @@ module Playwright
           quality: nil,
           timeout: nil,
           type: nil)
-      wrap_channel_owner(@channel_owner.screenshot(clip: clip, fullPage: fullPage, omitBackground: omitBackground, path: path, quality: quality, timeout: timeout, type: type))
+      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.
@@ -841,12 +1265,14 @@ module Playwright
     # Triggers a `change` and `input` event once all the provided options have been selected. If there's no `<select>` element
     # matching `selector`, the method throws an error.
     # 
+    # Will wait until all specified options are present in the `<select>` element.
+    # 
     #
     # ```js
     # // single selection matching the value
     # page.selectOption('select#colors', 'blue');
     # 
-    # // single selection matching both the value and the label
+    # // single selection matching the label
     # page.selectOption('select#colors', { label: 'Blue' });
     # 
     # // multiple selection
@@ -854,13 +1280,31 @@ module Playwright
     # 
     # ```
     # 
+    # ```python async
+    # # single selection matching the value
+    # await page.select_option("select#colors", "blue")
+    # # single selection matching the label
+    # await page.select_option("select#colors", label="blue")
+    # # multiple selection
+    # await page.select_option("select#colors", value=["red", "green", "blue"])
+    # ```
+    # 
+    # ```python sync
+    # # single selection matching the value
+    # page.select_option("select#colors", "blue")
+    # # single selection matching both the label
+    # page.select_option("select#colors", label="blue")
+    # # multiple selection
+    # page.select_option("select#colors", value=["red", "green", "blue"])
+    # ```
+    # 
     # Shortcut for main frame's [`method: Frame.selectOption`]
     def select_option(selector, values, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('select_option is not implemented yet.')
+      wrap_impl(@impl.select_option(unwrap_impl(selector), unwrap_impl(values), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     def set_content(html, timeout: nil, waitUntil: nil)
-      wrap_channel_owner(@channel_owner.set_content(html, timeout: timeout, waitUntil: waitUntil))
+      wrap_impl(@impl.set_content(unwrap_impl(html), timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
     alias_method :content=, :set_content
 
@@ -872,26 +1316,26 @@ module Playwright
     # - [`method: Page.setContent`]
     # - [`method: Page.waitForNavigation`]
     # 
-    # > **NOTE** [`method: Page.setDefaultNavigationTimeout`] takes priority over [`method: Page.setDefaultTimeout`],
+    # > NOTE: [`method: Page.setDefaultNavigationTimeout`] takes priority over [`method: Page.setDefaultTimeout`],
     # [`method: BrowserContext.setDefaultTimeout`] and [`method: BrowserContext.setDefaultNavigationTimeout`].
     def set_default_navigation_timeout(timeout)
-      raise NotImplementedError.new('set_default_navigation_timeout is not implemented yet.')
+      wrap_impl(@impl.set_default_navigation_timeout(unwrap_impl(timeout)))
     end
     alias_method :default_navigation_timeout=, :set_default_navigation_timeout
 
     # This setting will change the default maximum time for all the methods accepting `timeout` option.
     # 
-    # > **NOTE** [`method: Page.setDefaultNavigationTimeout`] takes priority over [`method: Page.setDefaultTimeout`].
+    # > NOTE: [`method: Page.setDefaultNavigationTimeout`] takes priority over [`method: Page.setDefaultTimeout`].
     def set_default_timeout(timeout)
-      raise NotImplementedError.new('set_default_timeout is not implemented yet.')
+      wrap_impl(@impl.set_default_timeout(unwrap_impl(timeout)))
     end
     alias_method :default_timeout=, :set_default_timeout
 
     # The extra HTTP headers will be sent with every request the page initiates.
     # 
-    # > **NOTE** page.setExtraHTTPHeaders does not guarantee the order of headers in the outgoing requests.
+    # > NOTE: [`method: Page.setExtraHTTPHeaders`] does not guarantee the order of headers in the outgoing requests.
     def set_extra_http_headers(headers)
-      raise NotImplementedError.new('set_extra_http_headers is not implemented yet.')
+      wrap_impl(@impl.set_extra_http_headers(unwrap_impl(headers)))
     end
     alias_method :extra_http_headers=, :set_extra_http_headers
 
@@ -901,7 +1345,7 @@ module Playwright
     # Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then they
     # are resolved relative to the the current working directory. For empty array, clears the selected files.
     def set_input_files(selector, files, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('set_input_files is not implemented yet.')
+      wrap_impl(@impl.set_input_files(unwrap_impl(selector), unwrap_impl(files), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # In the case of multiple pages in a single browser, each page can have its own viewport size. However,
@@ -919,8 +1363,20 @@ module Playwright
     # });
     # await page.goto('https://example.com');
     # ```
+    # 
+    # ```python async
+    # page = await browser.new_page()
+    # await page.set_viewport_size({"width": 640, "height": 480})
+    # await page.goto("https://example.com")
+    # ```
+    # 
+    # ```python sync
+    # page = browser.new_page()
+    # page.set_viewport_size({"width": 640, "height": 480})
+    # page.goto("https://example.com")
+    # ```
     def set_viewport_size(viewportSize)
-      wrap_channel_owner(@channel_owner.set_viewport_size(viewportSize))
+      wrap_impl(@impl.set_viewport_size(unwrap_impl(viewportSize)))
     end
     alias_method :viewport_size=, :set_viewport_size
 
@@ -935,7 +1391,7 @@ module Playwright
     # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
     # Passing zero timeout disables this.
     # 
-    # > **NOTE** `page.tap()` requires that the `hasTouch` option of the browser context be set to true.
+    # > NOTE: [`method: Page.tap`] requires that the `hasTouch` option of the browser context be set to true.
     # 
     # Shortcut for main frame's [`method: Frame.tap`].
     def tap_point(
@@ -945,17 +1401,17 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('tap_point is not implemented yet.')
+      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)))
     end
 
     # Returns `element.textContent`.
     def text_content(selector, timeout: nil)
-      raise NotImplementedError.new('text_content is not implemented yet.')
+      wrap_impl(@impl.text_content(unwrap_impl(selector), timeout: unwrap_impl(timeout)))
     end
 
     # Returns the page's title. Shortcut for main frame's [`method: Frame.title`].
     def title
-      wrap_channel_owner(@channel_owner.title)
+      wrap_impl(@impl.title)
     end
 
     # Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text. `page.type` can be used to send
@@ -969,14 +1425,24 @@ module Playwright
     # await page.type('#mytextarea', 'World', {delay: 100}); // Types slower, like a user
     # ```
     # 
+    # ```python async
+    # await page.type("#mytextarea", "hello") # types instantly
+    # await page.type("#mytextarea", "world", delay=100) # types slower, like a user
+    # ```
+    # 
+    # ```python sync
+    # page.type("#mytextarea", "hello") # types instantly
+    # page.type("#mytextarea", "world", delay=100) # types slower, like a user
+    # ```
+    # 
     # Shortcut for main frame's [`method: Frame.type`].
-    def type_text(
+    def type(
           selector,
           text,
           delay: nil,
           noWaitAfter: nil,
           timeout: nil)
-      wrap_channel_owner(@channel_owner.type_text(selector, text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
+      wrap_impl(@impl.type(unwrap_impl(selector), unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # This method unchecks an element matching `selector` by performing the following steps:
@@ -995,7 +1461,7 @@ module Playwright
     # 
     # Shortcut for main frame's [`method: Frame.uncheck`].
     def uncheck(selector, force: nil, noWaitAfter: nil, timeout: nil)
-      raise NotImplementedError.new('uncheck is not implemented yet.')
+      wrap_impl(@impl.uncheck(unwrap_impl(selector), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
     # Removes a route created with [`method: Page.route`]. When `handler` is not specified, removes all routes for the `url`.
@@ -1005,7 +1471,7 @@ module Playwright
 
     # Shortcut for main frame's [`method: Frame.url`].
     def url
-      wrap_channel_owner(@channel_owner.url)
+      wrap_impl(@impl.url)
     end
 
     # Video object associated with this page.
@@ -1014,20 +1480,12 @@ module Playwright
     end
 
     def viewport_size
-      wrap_channel_owner(@channel_owner.viewport_size)
+      wrap_impl(@impl.viewport_size)
     end
 
-    # Returns the event data value.
+    # Returns when the `expression` returns a truthy value. It resolves to a JSHandle of the truthy value.
     # 
-    # 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.
-    def wait_for_event(event, optionsOrPredicate: nil, &block)
-      wrap_channel_owner(@channel_owner.wait_for_event(event, optionsOrPredicate: optionsOrPredicate, &wrap_block_call(block)))
-    end
-
-    # Returns when the `pageFunction` returns a truthy value. It resolves to a JSHandle of the truthy value.
-    # 
-    # The `waitForFunction` can be used to observe viewport size change:
+    # The [`method: Page.waitForFunction`] can be used to observe viewport size change:
     # 
     #
     # ```js
@@ -1036,14 +1494,47 @@ module Playwright
     # (async () => {
     #   const browser = await webkit.launch();
     #   const page = await browser.newPage();
-    #   const watchDog = page.waitForFunction('window.innerWidth < 100');
+    #   const watchDog = page.waitForFunction(() => window.innerWidth < 100);
     #   await page.setViewportSize({width: 50, height: 50});
     #   await watchDog;
     #   await browser.close();
     # })();
     # ```
     # 
-    # To pass an argument to the predicate of `page.waitForFunction` function:
+    # ```python async
+    # import asyncio
+    # from playwright.async_api import async_playwright
+    # 
+    # async def run(playwright):
+    #     webkit = playwright.webkit
+    #     browser = await webkit.launch()
+    #     page = await browser.new_page()
+    #     await page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
+    #     await page.wait_for_function("() => window.x > 0")
+    #     await browser.close()
+    # 
+    # async def main():
+    #     async with async_playwright() as playwright:
+    #         await run(playwright)
+    # asyncio.run(main())
+    # ```
+    # 
+    # ```python sync
+    # from playwright.sync_api import sync_playwright
+    # 
+    # def run(playwright):
+    #     webkit = playwright.webkit
+    #     browser = webkit.launch()
+    #     page = browser.new_page()
+    #     page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
+    #     page.wait_for_function("() => window.x > 0")
+    #     browser.close()
+    # 
+    # with sync_playwright() as playwright:
+    #     run(playwright)
+    # ```
+    # 
+    # To pass an argument to the predicate of [`method: Page.waitForFunction`] function:
     # 
     #
     # ```js
@@ -1051,9 +1542,19 @@ module Playwright
     # await page.waitForFunction(selector => !!document.querySelector(selector), selector);
     # ```
     # 
+    # ```python async
+    # selector = ".foo"
+    # await page.wait_for_function("selector => !!document.querySelector(selector)", selector)
+    # ```
+    # 
+    # ```python sync
+    # selector = ".foo"
+    # page.wait_for_function("selector => !!document.querySelector(selector)", selector)
+    # ```
+    # 
     # Shortcut for main frame's [`method: Frame.waitForFunction`].
-    def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)
-      raise NotImplementedError.new('wait_for_function is not implemented yet.')
+    def wait_for_function(expression, arg: nil, polling: nil, timeout: nil)
+      wrap_impl(@impl.wait_for_function(unwrap_impl(expression), arg: unwrap_impl(arg), polling: unwrap_impl(polling), timeout: unwrap_impl(timeout)))
     end
 
     # Returns when the required load state has been reached.
@@ -1067,6 +1568,16 @@ module Playwright
     # await page.waitForLoadState(); // The promise resolves after 'load' event.
     # ```
     # 
+    # ```python async
+    # await page.click("button") # click triggers navigation.
+    # await page.wait_for_load_state() # the promise resolves after "load" event.
+    # ```
+    # 
+    # ```python sync
+    # page.click("button") # click triggers navigation.
+    # page.wait_for_load_state() # the promise resolves after "load" event.
+    # ```
+    # 
     #
     # ```js
     # const [popup] = await Promise.all([
@@ -1077,14 +1588,32 @@ module Playwright
     # console.log(await popup.title()); // Popup is ready to use.
     # ```
     # 
+    # ```python async
+    # async with page.expect_popup() as page_info:
+    #     await page.click("button") # click triggers a popup.
+    # popup = await page_info.value
+    #  # Following resolves after "domcontentloaded" event.
+    # await popup.wait_for_load_state("domcontentloaded")
+    # print(await popup.title()) # popup is ready to use.
+    # ```
+    # 
+    # ```python sync
+    # with page.expect_popup() as page_info:
+    #     page.click("button") # click triggers a popup.
+    # popup = page_info.value
+    #  # Following resolves after "domcontentloaded" event.
+    # popup.wait_for_load_state("domcontentloaded")
+    # print(popup.title()) # popup is ready to use.
+    # ```
+    # 
     # Shortcut for main frame's [`method: Frame.waitForLoadState`].
     def wait_for_load_state(state: nil, timeout: nil)
-      raise NotImplementedError.new('wait_for_load_state is not implemented yet.')
+      wrap_impl(@impl.wait_for_load_state(state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
     end
 
-    # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-    # last redirect. In case of navigation to a different anchor or navigation due to History API usage, the navigation will
-    # resolve with `null`.
+    # Waits for the main frame navigation and returns the main resource response. In case of multiple redirects, the
+    # navigation will resolve with the response of the last redirect. In case of navigation to a different anchor or
+    # navigation due to History API usage, the navigation will resolve with `null`.
     # 
     # This resolves when the page navigates to a new URL or reloads. It is useful for when you run code which will indirectly
     # cause the page to navigate. e.g. The click target has an `onclick` handler that triggers navigation from a `setTimeout`.
@@ -1098,12 +1627,24 @@ module Playwright
     # ]);
     # ```
     # 
-    # **NOTE** Usage of the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API) to change the URL is
+    # ```python async
+    # async with page.expect_navigation():
+    #     await page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
+    # # Resolves after navigation has finished
+    # ```
+    # 
+    # ```python sync
+    # with page.expect_navigation():
+    #     page.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
+    # # Resolves after navigation has finished
+    # ```
+    # 
+    # > NOTE: Usage of the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API) to change the URL is
     # considered a navigation.
     # 
     # Shortcut for main frame's [`method: Frame.waitForNavigation`].
-    def wait_for_navigation(timeout: nil, url: nil, waitUntil: nil)
-      raise NotImplementedError.new('wait_for_navigation is not implemented yet.')
+    def expect_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
+      wrap_impl(@impl.expect_navigation(timeout: unwrap_impl(timeout), url: unwrap_impl(url), waitUntil: unwrap_impl(waitUntil), &wrap_block_call(block)))
     end
 
     # Waits for the matching request and returns it.
@@ -1115,12 +1656,32 @@ module Playwright
     # return firstRequest.url();
     # ```
     # 
+    # ```python async
+    # async with page.expect_request("http://example.com/resource") as first:
+    #     await page.click('button')
+    # first_request = await first.value
+    # 
+    # async with page.expect_request(lambda request: request.url == "http://example.com" and request.method == "get") as second:
+    #     await page.click('img')
+    # second_request = await second.value
+    # ```
+    # 
+    # ```python sync
+    # with page.expect_request("http://example.com/resource") as first:
+    #     page.click('button')
+    # first_request = first.value
+    # 
+    # with page.expect_request(lambda request: request.url == "http://example.com" and request.method == "get") as second:
+    #     page.click('img')
+    # second_request = second.value
+    # ```
+    # 
     #
     # ```js
     # await page.waitForRequest(request => request.url().searchParams.get('foo') === 'bar' && request.url().searchParams.get('foo2') === 'bar2');
     # ```
-    def wait_for_request(urlOrPredicate, timeout: nil)
-      wrap_channel_owner(@channel_owner.wait_for_request(urlOrPredicate, timeout: timeout))
+    def expect_request(urlOrPredicate, timeout: nil)
+      wrap_impl(@impl.expect_request(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout)))
     end
 
     # Returns the matched response.
@@ -1131,8 +1692,20 @@ module Playwright
     # const finalResponse = await page.waitForResponse(response => response.url() === 'https://example.com' && response.status() === 200);
     # return finalResponse.ok();
     # ```
-    def wait_for_response(urlOrPredicate, timeout: nil)
-      wrap_channel_owner(@channel_owner.wait_for_response(urlOrPredicate, timeout: timeout))
+    # 
+    # ```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
+    # ```
+    # 
+    # ```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
+    # ```
+    def expect_response(urlOrPredicate, timeout: nil)
+      wrap_impl(@impl.expect_response(unwrap_impl(urlOrPredicate), timeout: unwrap_impl(timeout)))
     end
 
     # Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
@@ -1151,18 +1724,53 @@ module Playwright
     # (async () => {
     #   const browser = await chromium.launch();
     #   const page = await browser.newPage();
-    #   let currentURL;
-    #   page
-    #     .waitForSelector('img')
-    #     .then(() => console.log('First URL with image: ' + currentURL));
-    #   for (currentURL of ['https://example.com', 'https://google.com', 'https://bbc.com']) {
+    #   for (let currentURL of ['https://google.com', 'https://bbc.com']) {
     #     await page.goto(currentURL);
+    #     const element = await page.waitForSelector('img');
+    #     console.log('Loaded image: ' + await element.getAttribute('src'));
     #   }
     #   await browser.close();
     # })();
     # ```
+    # 
+    # ```python async
+    # import asyncio
+    # from playwright.async_api import async_playwright
+    # 
+    # async def run(playwright):
+    #     chromium = playwright.chromium
+    #     browser = await chromium.launch()
+    #     page = await browser.new_page()
+    #     for current_url in ["https://google.com", "https://bbc.com"]:
+    #         await page.goto(current_url, wait_until="domcontentloaded")
+    #         element = await page.wait_for_selector("img")
+    #         print("Loaded image: " + str(await element.get_attribute("src")))
+    #     await browser.close()
+    # 
+    # async def main():
+    #     async with async_playwright() as playwright:
+    #         await run(playwright)
+    # asyncio.run(main())
+    # ```
+    # 
+    # ```python sync
+    # from playwright.sync_api import sync_playwright
+    # 
+    # def run(playwright):
+    #     chromium = playwright.chromium
+    #     browser = chromium.launch()
+    #     page = browser.new_page()
+    #     for current_url in ["https://google.com", "https://bbc.com"]:
+    #         page.goto(current_url, wait_until="domcontentloaded")
+    #         element = page.wait_for_selector("img")
+    #         print("Loaded image: " + str(element.get_attribute("src")))
+    #     browser.close()
+    # 
+    # with sync_playwright() as playwright:
+    #     run(playwright)
+    # ```
     def wait_for_selector(selector, state: nil, timeout: nil)
-      raise NotImplementedError.new('wait_for_selector is not implemented yet.')
+      wrap_impl(@impl.wait_for_selector(unwrap_impl(selector), state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
     end
 
     # Waits for the given `timeout` in milliseconds.
@@ -1176,6 +1784,16 @@ module Playwright
     # await page.waitForTimeout(1000);
     # ```
     # 
+    # ```python async
+    # # wait for 1 second
+    # await page.wait_for_timeout(1000)
+    # ```
+    # 
+    # ```python sync
+    # # wait for 1 second
+    # page.wait_for_timeout(1000)
+    # ```
+    # 
     # Shortcut for main frame's [`method: Frame.waitForTimeout`].
     def wait_for_timeout(timeout)
       raise NotImplementedError.new('wait_for_timeout is not implemented yet.')
@@ -1184,37 +1802,46 @@ module Playwright
     # This method returns all of the dedicated [WebWorkers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API)
     # associated with the page.
     # 
-    # > **NOTE** This does not contain ServiceWorkers
+    # > NOTE: This does not contain ServiceWorkers
     def workers
       raise NotImplementedError.new('workers is not implemented yet.')
     end
 
     # @nodoc
-    def owned_context=(req)
-      wrap_channel_owner(@channel_owner.owned_context=(req))
+    def after_initialize
+      wrap_impl(@impl.after_initialize)
     end
 
     # @nodoc
-    def after_initialize
-      wrap_channel_owner(@channel_owner.after_initialize)
+    def expect_event(event, optionsOrPredicate: nil, &block)
+      wrap_impl(@impl.expect_event(unwrap_impl(event), optionsOrPredicate: unwrap_impl(optionsOrPredicate), &wrap_block_call(block)))
     end
 
-    # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_channel_owner(@channel_owner.off(event, callback))
+    def owned_context=(req)
+      wrap_impl(@impl.owned_context=(unwrap_impl(req)))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
-      wrap_channel_owner(@channel_owner.once(event, callback))
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)
-      wrap_channel_owner(@channel_owner.on(event, callback))
+      event_emitter_proxy.on(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end