playwright-ruby-client 1.16.1 → 1.18.0

data/lib/playwright_api/cdp_session.rb

@@ -33,12 +33,6 @@ module Playwright
       wrap_impl(@impl.send_message(unwrap_impl(method), params: unwrap_impl(params)))
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -51,6 +45,12 @@ module Playwright
       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

data/lib/playwright_api/console_message.rb

@@ -23,12 +23,6 @@ module Playwright
       wrap_impl(@impl.type)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -41,6 +35,12 @@ module Playwright
       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

data/lib/playwright_api/dialog.rb

@@ -58,12 +58,6 @@ module Playwright
       wrap_impl(@impl.accept_async(promptText: unwrap_impl(promptText)))
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -76,6 +70,12 @@ module Playwright
       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

data/lib/playwright_api/download.rb

@@ -12,10 +12,6 @@ module Playwright
   # # wait for download to complete
   # path = download.path()
   # ```
-  #
-  # > NOTE: Browser context **must** be created with the `acceptDownloads` set to `true` when user needs access to the
-  # downloaded content. If `acceptDownloads` is not set, download events are emitted, but the actual download is not
-  # performed and user has no access to the downloaded files.
   class Download < PlaywrightApi
 
     # Cancels a download. Will not fail if the download is already finished or canceled. Upon successful cancellations,

data/lib/playwright_api/element_handle.rb

@@ -6,6 +6,8 @@ module Playwright
   # ElementHandle represents an in-page DOM element. ElementHandles can be created with the [`method: Page.querySelector`]
   # method.
   #
+  # > NOTE: The use of ElementHandle is discouraged, use `Locator` objects and web-first assertions instead.
+  #
   # ```python sync
   # href_element = page.query_selector("a")
   # href_element.click()
@@ -17,9 +19,6 @@ module Playwright
   # ElementHandle instances can be used as an argument in [`method: Page.evalOnSelector`] and [`method: Page.evaluate`]
   # methods.
   #
-  # > NOTE: In most cases, you would want to use the `Locator` object instead. You should only use `ElementHandle` if you
-  # want to retain a handle to a particular DOM Node that you intend to pass into [`method: Page.evaluate`] as an argument.
-  #
   # The difference between the `Locator` and ElementHandle is that the ElementHandle points to a particular element, while
   # `Locator` captures the logic of how to retrieve an element.
   #
@@ -552,12 +551,6 @@ module Playwright
       wrap_impl(@impl.wait_for_selector(unwrap_impl(selector), state: unwrap_impl(state), strict: unwrap_impl(strict), timeout: unwrap_impl(timeout)))
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -570,6 +563,12 @@ module Playwright
       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

data/lib/playwright_api/frame.rb

@@ -183,6 +183,9 @@ module Playwright
 
     # Returns the return value of `expression`.
     #
+    # > NOTE: This method does not wait for the element to pass actionability checks and therefore can lead to the flaky
+    # tests. Use [`method: Locator.evaluate`], other `Locator` helper methods or web-first assertions instead.
+    #
     # The method finds an element matching the specified selector within the frame and passes it as a first argument to
     # `expression`. See [Working with selectors](./selectors.md) for more details. If no elements match the selector, the
     # method throws an error.
@@ -203,6 +206,9 @@ module Playwright
 
     # Returns the return value of `expression`.
     #
+    # > NOTE: In most cases, [`method: Locator.evaluateAll`], other `Locator` helper methods and web-first assertions do a
+    # better job.
+    #
     # The method finds all elements matching the specified selector within the frame and passes an array of matched elements
     # as a first argument to `expression`. See [Working with selectors](./selectors.md) for more details.
     #
@@ -243,7 +249,7 @@ module Playwright
     # `ElementHandle` instances can be passed as an argument to the [`method: Frame.evaluate`]:
     #
     # ```python sync
-    # body_handle = frame.query_selector("body")
+    # body_handle = frame.evaluate("document.body")
     # html = frame.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
     # body_handle.dispose()
     # ```
@@ -324,6 +330,18 @@ module Playwright
       wrap_impl(@impl.frame_element)
     end
 
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe. Following snippet locates element with text "Submit" in the iframe with id `my-frame`, like `<iframe
+    # id="my-frame">`:
+    #
+    # ```python sync
+    # locator = frame.frame_locator("#my-iframe").locator("text=Submit")
+    # locator.click()
+    # ```
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
     # Returns element attribute value.
     def get_attribute(selector, name, strict: nil, timeout: nil)
       wrap_impl(@impl.get_attribute(unwrap_impl(selector), unwrap_impl(name), strict: unwrap_impl(strict), timeout: unwrap_impl(timeout)))
@@ -427,8 +445,8 @@ module Playwright
     # The method returns an element locator that can be used to perform actions in the frame. Locator is resolved to the
     # element immediately before performing an action, so a series of actions on the same locator can in fact be performed on
     # different DOM elements. That would happen if the DOM structure between those actions has changed.
-    def locator(selector)
-      wrap_impl(@impl.locator(unwrap_impl(selector)))
+    def locator(selector, hasText: nil)
+      wrap_impl(@impl.locator(unwrap_impl(selector), hasText: unwrap_impl(hasText)))
     end
 
     # Returns frame's name attribute as specified in the tag.
@@ -478,6 +496,8 @@ module Playwright
 
     # Returns the ElementHandle pointing to the frame element.
     #
+    # > NOTE: The use of `ElementHandle` is discouraged, use `Locator` objects and web-first assertions instead.
+    #
     # The method finds an element matching the specified selector within the frame. See
     # [Working with selectors](./selectors.md) for more details. If no elements match the selector, returns `null`.
     def query_selector(selector, strict: nil)
@@ -486,6 +506,8 @@ module Playwright
 
     # Returns the ElementHandles pointing to the frame elements.
     #
+    # > NOTE: The use of `ElementHandle` is discouraged, use `Locator` objects instead.
+    #
     # The method finds all elements matching the specified selector within the frame. See
     # [Working with selectors](./selectors.md) for more details. If no elements match the selector, returns empty array.
     def query_selector_all(selector)
@@ -714,6 +736,9 @@ module Playwright
     # Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
     # `detached`.
     #
+    # > NOTE: Playwright automatically waits for element to be ready before performing an action. Using `Locator` objects and
+    # web-first assertions make the code wait-for-selector-free.
+    #
     # Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
     # the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the
     # selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
@@ -763,12 +788,6 @@ module Playwright
       wrap_impl(@impl.detached=(unwrap_impl(req)))
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -781,6 +800,12 @@ module Playwright
       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

data/lib/playwright_api/frame_locator.rb

@@ -0,0 +1,60 @@
+module Playwright
+  # FrameLocator represents a view to the `iframe` on the page. It captures the logic sufficient to retrieve the `iframe`
+  # and locate elements in that iframe. FrameLocator can be created with either [`method: Page.frameLocator`] or
+  # [`method: Locator.frameLocator`] method.
+  #
+  # ```python sync
+  # locator = page.frame_locator("my-frame").locator("text=Submit")
+  # locator.click()
+  # ```
+  #
+  # **Strictness**
+  #
+  # Frame locators are strict. This means that all operations on frame locators will throw if more than one element matches
+  # given selector.
+  #
+  # ```python sync
+  # # Throws if there are several frames in DOM:
+  # page.frame_locator('.result-frame').locator('button').click()
+  #
+  # # Works because we explicitly tell locator to pick the first frame:
+  # page.frame_locator('.result-frame').first.locator('button').click()
+  # ```
+  #
+  # **Converting Locator to FrameLocator**
+  #
+  # If you have a `Locator` object pointing to an `iframe` it can be converted to `FrameLocator` using
+  # [`:scope`](https://developer.mozilla.org/en-US/docs/Web/CSS/:scope) CSS selector:
+  #
+  # ```python sync
+  # frameLocator = locator.frame_locator(":scope");
+  # ```
+  class FrameLocator < PlaywrightApi
+
+    # Returns locator to the first matching frame.
+    def first
+      wrap_impl(@impl.first)
+    end
+
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe.
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
+    # Returns locator to the last matching frame.
+    def last
+      wrap_impl(@impl.last)
+    end
+
+    # The method finds an element matching the specified selector in the FrameLocator's subtree.
+    def locator(selector, hasText: nil)
+      wrap_impl(@impl.locator(unwrap_impl(selector), hasText: unwrap_impl(hasText)))
+    end
+
+    # Returns locator to the n-th matching frame.
+    def nth(index)
+      wrap_impl(@impl.nth(unwrap_impl(index)))
+    end
+  end
+end

data/lib/playwright_api/js_handle.rb

@@ -88,12 +88,6 @@ module Playwright
       wrap_impl(@impl.to_s)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -106,6 +100,12 @@ module Playwright
       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

data/lib/playwright_api/local_utils.rb

@@ -0,0 +1,9 @@
+module Playwright
+  class LocalUtils < PlaywrightApi
+
+    # @nodoc
+    def zip(zip_file, name_value_array)
+      wrap_impl(@impl.zip(unwrap_impl(zip_file), unwrap_impl(name_value_array)))
+    end
+  end
+end

data/lib/playwright_api/locator.rb

@@ -1,49 +1,8 @@
 module Playwright
-  # Locator represents a view to the element(s) on the page. It captures the logic sufficient to retrieve the element at any
-  # given moment. Locator can be created with the [`method: Page.locator`] method.
+  # Locators are the central piece of Playwright's auto-waiting and retry-ability. In a nutshell, locators represent a way
+  # to find element(s) on the page at any moment. Locator can be created with the [`method: Page.locator`] method.
   #
-  # ```python sync
-  # locator = page.locator("text=Submit")
-  # locator.click()
-  # ```
-  #
-  # The difference between the Locator and `ElementHandle` is that the latter points to a particular element, while Locator
-  # captures the logic of how to retrieve that element.
-  #
-  # In the example below, handle points to a particular DOM element on page. If that element changes text or is used by
-  # React to render an entirely different component, handle is still pointing to that very DOM element. This can lead to
-  # unexpected behaviors.
-  #
-  # ```python sync
-  # handle = page.query_selector("text=Submit")
-  # handle.hover()
-  # handle.click()
-  # ```
-  #
-  # With the locator, every time the `element` is used, up-to-date DOM element is located in the page using the selector. So
-  # in the snippet below, underlying DOM element is going to be located twice.
-  #
-  # ```python sync
-  # locator = page.locator("text=Submit")
-  # locator.hover()
-  # locator.click()
-  # ```
-  #
-  # **Strictness**
-  #
-  # Locators are strict. This means that all operations on locators that imply some target DOM element will throw if more
-  # than one element matches given selector.
-  #
-  # ```python sync
-  # # Throws if there are several buttons in DOM:
-  # page.locator('button').click()
-  #
-  # # Works because we explicitly tell locator to pick the first element:
-  # page.locator('button').first.click()
-  #
-  # # Works because count knows what to do with multiple matches:
-  # page.locator('button').count()
-  # ```
+  # [Learn more about locators](./locators.md).
   class Locator < PlaywrightApi
 
     # Returns an array of `node.innerText` values for all matching nodes.
@@ -183,6 +142,17 @@ module Playwright
       wrap_impl(@impl.dispatch_event(unwrap_impl(type), eventInit: unwrap_impl(eventInit), timeout: unwrap_impl(timeout)))
     end
 
+    def drag_to(
+          target,
+          force: nil,
+          noWaitAfter: nil,
+          sourcePosition: nil,
+          targetPosition: nil,
+          timeout: nil,
+          trial: nil)
+      wrap_impl(@impl.drag_to(unwrap_impl(target), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), sourcePosition: unwrap_impl(sourcePosition), targetPosition: unwrap_impl(targetPosition), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
+    end
+
     # Resolves given locator to the first matching DOM element. If no elements matching the query are visible, waits for them
     # up to a given timeout. If multiple elements match the selector, throws.
     def element_handle(timeout: nil)
@@ -264,6 +234,17 @@ module Playwright
       wrap_impl(@impl.focus(timeout: unwrap_impl(timeout)))
     end
 
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe:
+    #
+    # ```python sync
+    # locator = page.frame_locator("text=Submit").locator("text=Submit")
+    # locator.click()
+    # ```
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
     # Returns element attribute value.
     def get_attribute(name, timeout: nil)
       wrap_impl(@impl.get_attribute(unwrap_impl(name), timeout: unwrap_impl(timeout)))
@@ -338,10 +319,9 @@ module Playwright
       wrap_impl(@impl.last)
     end
 
-    # The method finds an element matching the specified selector in the `Locator`'s subtree. See
-    # [Working with selectors](./selectors.md) for more details.
-    def locator(selector)
-      wrap_impl(@impl.locator(unwrap_impl(selector)))
+    # The method finds an element matching the specified selector in the `Locator`'s subtree.
+    def locator(selector, hasText: nil)
+      wrap_impl(@impl.locator(unwrap_impl(selector), hasText: unwrap_impl(hasText)))
     end
 
     # Returns locator to the n-th matching element.

data/lib/playwright_api/page.rb

@@ -56,6 +56,11 @@ module Playwright
       wrap_impl(@impl.mouse)
     end
 
+    # API testing helper associated with this page. Requests made with this API will use page cookies.
+    def request # property
+      raise NotImplementedError.new('request is not implemented yet.')
+    end
+
     def touchscreen # property
       wrap_impl(@impl.touchscreen)
     end
@@ -288,6 +293,9 @@ module Playwright
       wrap_impl(@impl.emulate_media(colorScheme: unwrap_impl(colorScheme), forcedColors: unwrap_impl(forcedColors), media: unwrap_impl(media), reducedMotion: unwrap_impl(reducedMotion)))
     end
 
+    # > NOTE: This method does not wait for the element to pass actionability checks and therefore can lead to the flaky
+    # tests. Use [`method: Locator.evaluate`], other `Locator` helper methods or web-first assertions instead.
+    #
     # 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`.
     #
@@ -307,6 +315,9 @@ module Playwright
       wrap_impl(@impl.eval_on_selector(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg), strict: unwrap_impl(strict)))
     end
 
+    # > NOTE: In most cases, [`method: Locator.evaluateAll`], other `Locator` helper methods and web-first assertions do a
+    # better job.
+    #
     # 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.
     #
@@ -349,7 +360,7 @@ module Playwright
     # `ElementHandle` instances can be passed as an argument to the [`method: Page.evaluate`]:
     #
     # ```python sync
-    # body_handle = page.query_selector("body")
+    # body_handle = page.evaluate("document.body")
     # html = page.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
     # body_handle.dispose()
     # ```
@@ -533,6 +544,18 @@ module Playwright
       wrap_impl(@impl.frame(name: unwrap_impl(name), url: unwrap_impl(url)))
     end
 
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe. Following snippet locates element with text "Submit" in the iframe with id `my-frame`, like `<iframe
+    # id="my-frame">`:
+    #
+    # ```python sync
+    # locator = page.frame_locator("#my-iframe").locator("text=Submit")
+    # locator.click()
+    # ```
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
     # An array of all frames attached to the page.
     def frames
       wrap_impl(@impl.frames)
@@ -663,8 +686,8 @@ module Playwright
     # different DOM elements. That would happen if the DOM structure between those actions has changed.
     #
     # Shortcut for main frame's [`method: Frame.locator`].
-    def locator(selector)
-      wrap_impl(@impl.locator(unwrap_impl(selector)))
+    def locator(selector, hasText: nil)
+      wrap_impl(@impl.locator(unwrap_impl(selector), hasText: unwrap_impl(hasText)))
     end
 
     # The page's main frame. Page is guaranteed to have a main frame which persists during navigations.
@@ -791,14 +814,18 @@ module Playwright
       wrap_impl(@impl.press(unwrap_impl(selector), unwrap_impl(key), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), strict: unwrap_impl(strict), timeout: unwrap_impl(timeout)))
     end
 
+    # > NOTE: The use of `ElementHandle` is discouraged, use `Locator` objects and web-first assertions instead.
+    #
     # The method finds an element matching the specified selector within the page. If no elements match the selector, the
-    # return value resolves to `null`. To wait for an element on the page, use [`method: Page.waitForSelector`].
+    # return value resolves to `null`. To wait for an element on the page, use [`method: Locator.waitFor`].
     #
     # Shortcut for main frame's [`method: Frame.querySelector`].
     def query_selector(selector, strict: nil)
       wrap_impl(@impl.query_selector(unwrap_impl(selector), strict: unwrap_impl(strict)))
     end
 
+    # > NOTE: The use of `ElementHandle` is discouraged, use `Locator` objects and web-first assertions instead.
+    #
     # The method finds all elements matching the specified selector within the page. If no elements match the selector, the
     # return value resolves to `[]`.
     #
@@ -807,8 +834,8 @@ module Playwright
       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.
+    # This method reloads the current page, in the same way as if the user had triggered a browser refresh. 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)
       wrap_impl(@impl.reload(timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
@@ -1267,6 +1294,9 @@ module Playwright
     # Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
     # `detached`.
     #
+    # > NOTE: Playwright automatically waits for element to be ready before performing an action. Using `Locator` objects and
+    # web-first assertions make the code wait-for-selector-free.
+    #
     # Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
     # the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the
     # selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
@@ -1381,12 +1411,6 @@ module Playwright
       wrap_impl(@impl.guid)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -1399,6 +1423,12 @@ module Playwright
       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

data/lib/playwright_api/playwright.rb

@@ -50,6 +50,11 @@ module Playwright
       wrap_impl(@impl.firefox)
     end
 
+    # Exposes API that can be used for the Web API testing.
+    def request # property
+      raise NotImplementedError.new('request is not implemented yet.')
+    end
+
     # Selectors can be used to install custom selector engines. See [Working with selectors](./selectors.md) for more
     # information.
     def selectors # property
@@ -91,12 +96,6 @@ module Playwright
       wrap_impl(@impl.electron)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -109,6 +108,12 @@ module Playwright
       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

data/lib/playwright_api/request.rb

@@ -154,12 +154,6 @@ module Playwright
       wrap_impl(@impl.header_values(unwrap_impl(name)))
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -172,6 +166,12 @@ module Playwright
       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

data/lib/playwright_api/response.rb

@@ -97,12 +97,6 @@ module Playwright
       wrap_impl(@impl.ok?)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -115,6 +109,12 @@ module Playwright
       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