@itmetsam/samurai-framework 0.22.9 → 0.22.11

package/dist/locator/locator-element-methods.d.ts

@@ -0,0 +1,169 @@
+import type { ElementRectangle } from "../types/bidi-modules/browsing-context.js";
+import type { PageFunction } from "../script/call-function.js";
+import type { ElementScreenshotOptions } from "../browser/screenshot.js";
+import type { FileInput } from "../browser/generated-files.js";
+import { type ActionabilityContext, type ActionOptions } from "./actionability.js";
+import { type CheckOptions } from "./check-actions.js";
+import type { ElementAccess } from "./element-access.js";
+import { type ClickOptions, type PointerOptions } from "./pointer-element-actions.js";
+import { type BoundingBox } from "./element-reads.js";
+import type { WaitForState } from "./element-state.js";
+import { type SelectOptionValue } from "./select-actions.js";
+/**
+ * The actions and reads of a `Locator` that work on the element its `access` resolves. `Locator` extends this
+ * and adds the chain, the fallbacks and the steps that build new locators.
+ */
+export declare abstract class LocatorElementMethods {
+    /** What the reads and actions use of this locator */
+    protected abstract access: ElementAccess;
+    /** What the actionability waits use of this locator */
+    protected abstract actionability: ActionabilityContext;
+    /**
+     * Waits until the element is attached, visible, stable, enabled and not covered, then clicks it with real pointer
+     * input: its centre, or `position` (pixels from its top left corner). `button`, `clickCount`, `delay` (ms between press
+     * and release) and `modifiers` (keys held down) are as in Playwright
+     */
+    click(options?: ClickOptions): Promise<void>;
+    /** `click` with `clickCount: 2` */
+    dblclick(options?: ClickOptions): Promise<void>;
+    /** Waits until the element is attached, visible, stable and not covered, then moves the mouse onto it (`:hover`, `mouseover`, tooltips) */
+    hover(options?: PointerOptions): Promise<void>;
+    /** Waits like `click`, then touches the element with a touch pointer: `touchstart`, `touchend`, then the mouse events a tap ends in */
+    tap(options?: PointerOptions): Promise<void>;
+    /** Waits until the element is attached, then fires a synthetic event (`click`, `keydown`, ...; the class follows the type) at it, bubbling and composed */
+    dispatchEvent(type: string, eventInit?: Record<string, unknown>, options?: ActionOptions): Promise<void>;
+    /** Waits until the element is attached, then removes focus from it */
+    blur(options?: ActionOptions): Promise<void>;
+    /** Empties an input, textarea or editable element, as `fill("")` does */
+    clear(options?: ActionOptions): Promise<void>;
+    /** Focuses the element and types `text` into it one key press at a time, `delay` ms apart */
+    pressSequentially(text: string, options?: ActionOptions & {
+        delay?: number;
+    }): Promise<void>;
+    /**
+     * Checks a checkbox, radio or `role=checkbox|radio|switch` element; does nothing when it is already checked.
+     * Waits like `click`, but a hidden input counts as reachable through its `<label>`, which is what gets clicked.
+     * `trial` waits without clicking. Throws when the click did not change the state.
+     * @example
+     *  await page.getByLabel("I accept the terms").check();
+     */
+    check(options?: CheckOptions): Promise<void>;
+    /** Unchecks a checkbox or `role=checkbox|switch` element; does nothing when it is already unchecked. A radio button cannot be unchecked: throws */
+    uncheck(options?: CheckOptions): Promise<void>;
+    /** `check()` or `uncheck()`, whichever brings the element to `checked` */
+    setChecked(checked: boolean, options?: CheckOptions): Promise<void>;
+    /**
+     * Selects options of a `<select>` or `<select multiple>` (which replaces its selection) and fires `input` and
+     * `change`. A string matches an option's value or its label; `{ value, label, index }` must match every field
+     * given. Waits until the select is visible and enabled and every option exists. Returns the values now selected.
+     * @example
+     *  await page.getByLabel("Country").selectOption("Netherlands");
+     *  await page.locator("select").selectOption([{ index: 0 }, { value: "b" }]);
+     */
+    selectOption(values: SelectOptionValue | SelectOptionValue[], options?: ActionOptions): Promise<string[]>;
+    /**
+     * Sets the files of an `<input type=file>`; `[]` clears it. Paths are relative to the project folder (absolute
+     * ones are used as they are); `generatedFile(…)` writes a file of a given size when the step runs.
+     * Waits for the input to be attached and enabled; it need not be visible, file inputs are often hidden behind a label.
+     * @example
+     *  await page.getByLabel("Avatar").setInputFiles("files/avatar.png");
+     *  await page.getByLabel("Upload").setInputFiles(generatedFile({ name: "huge.pdf", size: "60 MB" }));
+     */
+    setInputFiles(files: FileInput | FileInput[], options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /**
+     * Drops files on the element, as dragging them from the desktop does: `dragenter`, `dragover` and `drop`
+     * with a `DataTransfer` holding the files. Takes what `setInputFiles` takes. The events are synthetic
+     * (`isTrusted` is false); a page that only accepts trusted drops ignores them.
+     * Waits for the element to be attached and visible.
+     * @example
+     *  await page.getByTestId("dropzone").dropFiles(["files/a.png", "files/b.png"]);
+     */
+    dropFiles(files: FileInput | FileInput[], options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /**
+     * Takes a screenshot of just this element, after scrolling it into view and waiting until it is attached and
+     * visible. Returns the image (also written to `options.path`).
+     * @example
+     *  await page.locator("div[@id='chart']").screenshot({ path: "out/chart.png" });
+     */
+    screenshot(options?: ElementScreenshotOptions & {
+        timeout?: number;
+    }): Promise<Buffer>;
+    /** Waits until the element is attached, then focuses it */
+    focus(options?: ActionOptions): Promise<void>;
+    /** Waits until the element reaches `state` (default "visible"); does not scroll */
+    waitFor(options?: {
+        state?: WaitForState;
+        timeout?: number;
+    }): Promise<void>;
+    /** Returns the browser's getBoundingClientRect result for the given element */
+    getBoundingClientRect(): Promise<ElementRectangle>;
+    /** Whether the element exists, has a non-empty box and is not hidden by CSS */
+    isVisible(): Promise<boolean>;
+    /** The opposite of `isVisible`: true for a hidden element and for one that is not there */
+    isHidden(): Promise<boolean>;
+    /** Trimmed text content, or null when the element is missing */
+    textContent(): Promise<string | null>;
+    /** Rendered text of the element (as a person would copy it, hidden text left out), untrimmed, or null when the element is missing */
+    innerText(): Promise<string | null>;
+    /** The markup inside the element, or null when the element is missing */
+    innerHTML(): Promise<string | null>;
+    /** `textContent` of every match, as the page has it (untrimmed, unlike `textContent()`); `[]` when none match. Does not wait */
+    allTextContents(): Promise<string[]>;
+    /** `innerText` of every match; `[]` when none match. Does not wait */
+    allInnerTexts(): Promise<string[]>;
+    /** The element's box in CSS pixels from the viewport's top left, or null when it is missing or not rendered (`display: none`). Does not wait or scroll */
+    boundingBox(): Promise<BoundingBox | null>;
+    /**
+     * Waits until the element is attached (hidden is fine), then calls `fn(element, arg)` in the page and returns the result
+     * (see `page.evaluate` for what comes back). `fn` is a function or the source of one; a strict locator throws when several match.
+     * @example
+     *  const id = await page.getByTestId("row").evaluate((el) => el.dataset.id);
+     */
+    evaluate<R = unknown, A = unknown>(fn: PageFunction<[any, A], R>, arg?: A, options?: {
+        timeout?: number;
+    }): Promise<R>;
+    /** Calls `fn(elements, arg)` in the page with an array of every match (empty when none; does not wait) and returns the result */
+    evaluateAll<R = unknown, A = unknown>(fn: PageFunction<[any[], A], R>, arg?: A): Promise<R>;
+    /** Value of an input/textarea/select, or null when missing */
+    inputValue(): Promise<string | null>;
+    /** Attribute value, or null when the element or attribute is missing */
+    getAttribute(name: string): Promise<string | null>;
+    /** Whether the element exists and is not disabled; does not wait */
+    isEnabled(): Promise<boolean>;
+    /** The opposite of `isEnabled`: true for a disabled element and for one that is not there; does not wait */
+    isDisabled(): Promise<boolean>;
+    /** Like `isEnabled`, but null when the element is missing, so callers can tell "disabled" from "not there"; does not wait */
+    enabledState(): Promise<boolean | null>;
+    /** Whether a checkbox or radio input is checked or the element has `aria-checked="true"`; null when the element is missing */
+    isChecked(): Promise<boolean | null>;
+    /** The accessible name (what `getByRole`'s `name` is matched against), "" when there is none, or null when the element is missing */
+    accessibleName(): Promise<string | null>;
+    /** The accessible description (`aria-describedby`, `aria-description`, else `title` when it is not the name), or null when the element is missing */
+    accessibleDescription(): Promise<string | null>;
+    /** The class attribute as written ("" when the element has none), or null when the element is missing */
+    classAttribute(): Promise<string | null>;
+    /** Computed value of a CSS property (camelCase names become kebab-case, `--custom` is kept), or null when the element is missing */
+    cssValue(name: string): Promise<string | null>;
+    /** Whether the element exists and accepts typing (enabled, not readonly, a text field); does not wait */
+    isEditable(): Promise<boolean>;
+    /**
+     * Waits until the element is attached, visible and enabled, focuses it and presses `key` with real keyboard input.
+     * Named keys are `Enter`, `Escape`, `Tab`, `Backspace`, `Delete`, `Space`, `Insert`, `Home`, `End`, `PageUp`, `PageDown`,
+     * `F1` to `F12` and the arrows; any other key must be a single character. A chord holds modifiers (`Control`, `Shift`,
+     * `Alt`, `Meta`, `ControlOrMeta`) while the last key is pressed.
+     * @example
+     *  await page.getByLabel("New todo").press("Enter");
+     *  await page.getByLabel("Name").press("Control+a");
+     */
+    press(key: string, options?: ActionOptions & {
+        delay?: number;
+    }): Promise<void>;
+    /** Waits until the field is editable and not covered, then replaces its value by typing `value`; an empty string clears it */
+    fill(value: string, options?: ActionOptions & {
+        output?: string;
+    }): Promise<void>;
+}

package/dist/locator/locator-element-methods.js

@@ -0,0 +1,228 @@
+import { waitForState, } from "./actionability.js";
+import { setChecked } from "./check-actions.js";
+import { clearElement, fillElement, focusElement, pressOnElement, pressSequentially, screenshotElement, } from "./element-actions.js";
+import { blurElement, dispatchEventOn } from "./event-actions.js";
+import { clickElement, hoverElement, tapElement, } from "./pointer-element-actions.js";
+import { readAccessibleDescription, readAccessibleName, readAllInnerTexts, readAllTextContents, readAttribute, readBoundingBox, readBoundingClientRect, readClassAttribute, readCssValue, readEnabledState, readInnerHTML, readInnerText, readInputValue, readIsChecked, readIsEditable, readIsEnabled, readIsVisible, readTextContent, } from "./element-reads.js";
+import { evaluateOnAll, evaluateOnElement } from "./evaluate.js";
+import { dropFiles, setInputFiles } from "./file-actions.js";
+import { selectOptions } from "./select-actions.js";
+/**
+ * The actions and reads of a `Locator` that work on the element its `access` resolves. `Locator` extends this
+ * and adds the chain, the fallbacks and the steps that build new locators.
+ */
+export class LocatorElementMethods {
+    /**
+     * Waits until the element is attached, visible, stable, enabled and not covered, then clicks it with real pointer
+     * input: its centre, or `position` (pixels from its top left corner). `button`, `clickCount`, `delay` (ms between press
+     * and release) and `modifiers` (keys held down) are as in Playwright
+     */
+    async click(options) {
+        await clickElement(this.access, options);
+    }
+    /** `click` with `clickCount: 2` */
+    async dblclick(options) {
+        await clickElement(this.access, { ...options, clickCount: 2 }, "dblclick");
+    }
+    /** Waits until the element is attached, visible, stable and not covered, then moves the mouse onto it (`:hover`, `mouseover`, tooltips) */
+    async hover(options) {
+        await hoverElement(this.access, options);
+    }
+    /** Waits like `click`, then touches the element with a touch pointer: `touchstart`, `touchend`, then the mouse events a tap ends in */
+    async tap(options) {
+        await tapElement(this.access, options);
+    }
+    /** Waits until the element is attached, then fires a synthetic event (`click`, `keydown`, ...; the class follows the type) at it, bubbling and composed */
+    async dispatchEvent(type, eventInit, options) {
+        await dispatchEventOn(this.access, type, eventInit, options);
+    }
+    /** Waits until the element is attached, then removes focus from it */
+    async blur(options) {
+        await blurElement(this.access, options);
+    }
+    /** Empties an input, textarea or editable element, as `fill("")` does */
+    async clear(options) {
+        await clearElement(this.access, options);
+    }
+    /** Focuses the element and types `text` into it one key press at a time, `delay` ms apart */
+    async pressSequentially(text, options) {
+        await pressSequentially(this.access, text, options);
+    }
+    /**
+     * Checks a checkbox, radio or `role=checkbox|radio|switch` element; does nothing when it is already checked.
+     * Waits like `click`, but a hidden input counts as reachable through its `<label>`, which is what gets clicked.
+     * `trial` waits without clicking. Throws when the click did not change the state.
+     * @example
+     *  await page.getByLabel("I accept the terms").check();
+     */
+    async check(options) {
+        await setChecked(this.access, "check", true, options);
+    }
+    /** Unchecks a checkbox or `role=checkbox|switch` element; does nothing when it is already unchecked. A radio button cannot be unchecked: throws */
+    async uncheck(options) {
+        await setChecked(this.access, "uncheck", false, options);
+    }
+    /** `check()` or `uncheck()`, whichever brings the element to `checked` */
+    async setChecked(checked, options) {
+        await setChecked(this.access, "setChecked", checked, options);
+    }
+    /**
+     * Selects options of a `<select>` or `<select multiple>` (which replaces its selection) and fires `input` and
+     * `change`. A string matches an option's value or its label; `{ value, label, index }` must match every field
+     * given. Waits until the select is visible and enabled and every option exists. Returns the values now selected.
+     * @example
+     *  await page.getByLabel("Country").selectOption("Netherlands");
+     *  await page.locator("select").selectOption([{ index: 0 }, { value: "b" }]);
+     */
+    async selectOption(values, options) {
+        return selectOptions(this.access, values, options);
+    }
+    /**
+     * Sets the files of an `<input type=file>`; `[]` clears it. Paths are relative to the project folder (absolute
+     * ones are used as they are); `generatedFile(…)` writes a file of a given size when the step runs.
+     * Waits for the input to be attached and enabled; it need not be visible, file inputs are often hidden behind a label.
+     * @example
+     *  await page.getByLabel("Avatar").setInputFiles("files/avatar.png");
+     *  await page.getByLabel("Upload").setInputFiles(generatedFile({ name: "huge.pdf", size: "60 MB" }));
+     */
+    async setInputFiles(files, options) {
+        await setInputFiles(this.access, files, options);
+    }
+    /**
+     * Drops files on the element, as dragging them from the desktop does: `dragenter`, `dragover` and `drop`
+     * with a `DataTransfer` holding the files. Takes what `setInputFiles` takes. The events are synthetic
+     * (`isTrusted` is false); a page that only accepts trusted drops ignores them.
+     * Waits for the element to be attached and visible.
+     * @example
+     *  await page.getByTestId("dropzone").dropFiles(["files/a.png", "files/b.png"]);
+     */
+    async dropFiles(files, options) {
+        await dropFiles(this.access, files, options);
+    }
+    /**
+     * Takes a screenshot of just this element, after scrolling it into view and waiting until it is attached and
+     * visible. Returns the image (also written to `options.path`).
+     * @example
+     *  await page.locator("div[@id='chart']").screenshot({ path: "out/chart.png" });
+     */
+    async screenshot(options = {}) {
+        return screenshotElement(this.access, options);
+    }
+    /** Waits until the element is attached, then focuses it */
+    async focus(options) {
+        await focusElement(this.access, options);
+    }
+    /** Waits until the element reaches `state` (default "visible"); does not scroll */
+    async waitFor(options = {}) {
+        await waitForState(this.actionability, options);
+    }
+    /** Returns the browser's getBoundingClientRect result for the given element */
+    async getBoundingClientRect() {
+        return readBoundingClientRect(this.access);
+    }
+    /** Whether the element exists, has a non-empty box and is not hidden by CSS */
+    async isVisible() {
+        return readIsVisible(this.actionability);
+    }
+    /** The opposite of `isVisible`: true for a hidden element and for one that is not there */
+    async isHidden() {
+        return !(await this.isVisible());
+    }
+    /** Trimmed text content, or null when the element is missing */
+    async textContent() {
+        return readTextContent(this.access);
+    }
+    /** Rendered text of the element (as a person would copy it, hidden text left out), untrimmed, or null when the element is missing */
+    async innerText() {
+        return readInnerText(this.access);
+    }
+    /** The markup inside the element, or null when the element is missing */
+    async innerHTML() {
+        return readInnerHTML(this.access);
+    }
+    /** `textContent` of every match, as the page has it (untrimmed, unlike `textContent()`); `[]` when none match. Does not wait */
+    async allTextContents() {
+        return readAllTextContents(this.access);
+    }
+    /** `innerText` of every match; `[]` when none match. Does not wait */
+    async allInnerTexts() {
+        return readAllInnerTexts(this.access);
+    }
+    /** The element's box in CSS pixels from the viewport's top left, or null when it is missing or not rendered (`display: none`). Does not wait or scroll */
+    async boundingBox() {
+        return readBoundingBox(this.access);
+    }
+    /**
+     * Waits until the element is attached (hidden is fine), then calls `fn(element, arg)` in the page and returns the result
+     * (see `page.evaluate` for what comes back). `fn` is a function or the source of one; a strict locator throws when several match.
+     * @example
+     *  const id = await page.getByTestId("row").evaluate((el) => el.dataset.id);
+     */
+    async evaluate(fn, arg, options) {
+        return evaluateOnElement(this.access, fn, arg, options);
+    }
+    /** Calls `fn(elements, arg)` in the page with an array of every match (empty when none; does not wait) and returns the result */
+    async evaluateAll(fn, arg) {
+        return evaluateOnAll(this.access, fn, arg);
+    }
+    /** Value of an input/textarea/select, or null when missing */
+    async inputValue() {
+        return readInputValue(this.access);
+    }
+    /** Attribute value, or null when the element or attribute is missing */
+    async getAttribute(name) {
+        return readAttribute(this.access, name);
+    }
+    /** Whether the element exists and is not disabled; does not wait */
+    async isEnabled() {
+        return readIsEnabled(this.actionability);
+    }
+    /** The opposite of `isEnabled`: true for a disabled element and for one that is not there; does not wait */
+    async isDisabled() {
+        return !(await this.isEnabled());
+    }
+    /** Like `isEnabled`, but null when the element is missing, so callers can tell "disabled" from "not there"; does not wait */
+    async enabledState() {
+        return readEnabledState(this.actionability);
+    }
+    /** Whether a checkbox or radio input is checked or the element has `aria-checked="true"`; null when the element is missing */
+    async isChecked() {
+        return readIsChecked(this.access);
+    }
+    /** The accessible name (what `getByRole`'s `name` is matched against), "" when there is none, or null when the element is missing */
+    async accessibleName() {
+        return readAccessibleName(this.access);
+    }
+    /** The accessible description (`aria-describedby`, `aria-description`, else `title` when it is not the name), or null when the element is missing */
+    async accessibleDescription() {
+        return readAccessibleDescription(this.access);
+    }
+    /** The class attribute as written ("" when the element has none), or null when the element is missing */
+    async classAttribute() {
+        return readClassAttribute(this.access);
+    }
+    /** Computed value of a CSS property (camelCase names become kebab-case, `--custom` is kept), or null when the element is missing */
+    async cssValue(name) {
+        return readCssValue(this.access, name);
+    }
+    /** Whether the element exists and accepts typing (enabled, not readonly, a text field); does not wait */
+    async isEditable() {
+        return readIsEditable(this.actionability);
+    }
+    /**
+     * Waits until the element is attached, visible and enabled, focuses it and presses `key` with real keyboard input.
+     * Named keys are `Enter`, `Escape`, `Tab`, `Backspace`, `Delete`, `Space`, `Insert`, `Home`, `End`, `PageUp`, `PageDown`,
+     * `F1` to `F12` and the arrows; any other key must be a single character. A chord holds modifiers (`Control`, `Shift`,
+     * `Alt`, `Meta`, `ControlOrMeta`) while the last key is pressed.
+     * @example
+     *  await page.getByLabel("New todo").press("Enter");
+     *  await page.getByLabel("Name").press("Control+a");
+     */
+    async press(key, options) {
+        await pressOnElement(this.access, key, options);
+    }
+    /** Waits until the field is editable and not covered, then replaces its value by typing `value`; an empty string clears it */
+    async fill(value, options) {
+        await fillElement(this.access, value, options);
+    }
+}

package/dist/locator/locator.d.ts

@@ -1,23 +1,17 @@
 import type { BiDiConnector } from "../transport/bidi-connection.js";
-import type { BrowsingContext, ElementRectangle } from "../types/bidi-modules/browsing-context.js";
+import type { BrowsingContext } from "../types/bidi-modules/browsing-context.js";
 import { ElementHandle } from "../script/element-handle.js";
-import type { PageFunction } from "../script/call-function.js";
-import type { ElementScreenshotOptions } from "../browser/screenshot.js";
-import type { FileInput } from "../browser/generated-files.js";
-import { type ActionOptions } from "./actionability.js";
-import { type CheckOptions } from "./check-actions.js";
+import { type ActionabilityContext } from "./actionability.js";
+import { type ElementAccess } from "./element-access.js";
 import { type DragOptions } from "./drag-actions.js";
-import { type ClickOptions, type PointerOptions } from "./pointer-element-actions.js";
-import { type BoundingBox } from "./element-reads.js";
-import type { WaitForState } from "./element-state.js";
 import type { HelperInstaller } from "./helper-realm.js";
 import { type StrictSource } from "./strict-mode.js";
 import type { RoleOptions } from "./role-locator.js";
 import { type Selector, type ExactOption, type TextOptions } from "./selector.js";
-import { type SelectOptionValue } from "./select-actions.js";
 import { type FilterOptions } from "./filter-step.js";
+import { LocatorElementMethods } from "./locator-element-methods.js";
 export type { ActionOptions } from "./actionability.js";
-export default class Locator {
+export default class Locator extends LocatorElementMethods {
     private biDiConnector;
     private contextId;
     private chain;
@@ -29,9 +23,9 @@ export default class Locator {
     private matched;
     private resolver;
     /** What the actionability waits use of this locator */
-    private actionability;
+    protected actionability: ActionabilityContext;
     /** What the reads and actions use of this locator */
-    private access;
+    protected access: ElementAccess;
     /**
      * `selector` is an xpath, or a chain of selector steps that each search inside the previous step's matches.
      * `helpers` is the page's helper realm. With it the actionability probe is installed once per
@@ -134,160 +128,12 @@ export default class Locator {
      */
     private resolveOne;
     private waitForActionable;
-    /**
-     * Waits until the element is attached, visible, stable, enabled and not covered, then clicks it with real pointer
-     * input: its centre, or `position` (pixels from its top left corner). `button`, `clickCount`, `delay` (ms between press
-     * and release) and `modifiers` (keys held down) are as in Playwright
-     */
-    click(options?: ClickOptions): Promise<void>;
-    /** `click` with `clickCount: 2` */
-    dblclick(options?: ClickOptions): Promise<void>;
-    /** Waits until the element is attached, visible, stable and not covered, then moves the mouse onto it (`:hover`, `mouseover`, tooltips) */
-    hover(options?: PointerOptions): Promise<void>;
-    /** Waits like `click`, then touches the element with a touch pointer: `touchstart`, `touchend`, then the mouse events a tap ends in */
-    tap(options?: PointerOptions): Promise<void>;
     /** Drags this element onto `target` with real pointer input; `sourcePosition`, `targetPosition` and `steps` shape the gesture. Firefox needs synthetic drop events, see the wiki */
     dragTo(target: Locator, options?: DragOptions): Promise<void>;
-    /** Waits until the element is attached, then fires a synthetic event (`click`, `keydown`, ...; the class follows the type) at it, bubbling and composed */
-    dispatchEvent(type: string, eventInit?: Record<string, unknown>, options?: ActionOptions): Promise<void>;
-    /** Waits until the element is attached, then removes focus from it */
-    blur(options?: ActionOptions): Promise<void>;
-    /** Empties an input, textarea or editable element, as `fill("")` does */
-    clear(options?: ActionOptions): Promise<void>;
-    /** Focuses the element and types `text` into it one key press at a time, `delay` ms apart */
-    pressSequentially(text: string, options?: ActionOptions & {
-        delay?: number;
-    }): Promise<void>;
-    /**
-     * Checks a checkbox, radio or `role=checkbox|radio|switch` element; does nothing when it is already checked.
-     * Waits like `click`, but a hidden input counts as reachable through its `<label>`, which is what gets clicked.
-     * `trial` waits without clicking. Throws when the click did not change the state.
-     * @example
-     *  await page.getByLabel("I accept the terms").check();
-     */
-    check(options?: CheckOptions): Promise<void>;
-    /** Unchecks a checkbox or `role=checkbox|switch` element; does nothing when it is already unchecked. A radio button cannot be unchecked: throws */
-    uncheck(options?: CheckOptions): Promise<void>;
-    /** `check()` or `uncheck()`, whichever brings the element to `checked` */
-    setChecked(checked: boolean, options?: CheckOptions): Promise<void>;
-    /**
-     * Selects options of a `<select>` or `<select multiple>` (which replaces its selection) and fires `input` and
-     * `change`. A string matches an option's value or its label; `{ value, label, index }` must match every field
-     * given. Waits until the select is visible and enabled and every option exists. Returns the values now selected.
-     * @example
-     *  await page.getByLabel("Country").selectOption("Netherlands");
-     *  await page.locator("select").selectOption([{ index: 0 }, { value: "b" }]);
-     */
-    selectOption(values: SelectOptionValue | SelectOptionValue[], options?: ActionOptions): Promise<string[]>;
-    /**
-     * Sets the files of an `<input type=file>`; `[]` clears it. Paths are relative to the project folder (absolute
-     * ones are used as they are); `generatedFile(…)` writes a file of a given size when the step runs.
-     * Waits for the input to be attached and enabled; it need not be visible, file inputs are often hidden behind a label.
-     * @example
-     *  await page.getByLabel("Avatar").setInputFiles("files/avatar.png");
-     *  await page.getByLabel("Upload").setInputFiles(generatedFile({ name: "huge.pdf", size: "60 MB" }));
-     */
-    setInputFiles(files: FileInput | FileInput[], options?: {
-        timeout?: number;
-    }): Promise<void>;
-    /**
-     * Drops files on the element, as dragging them from the desktop does: `dragenter`, `dragover` and `drop`
-     * with a `DataTransfer` holding the files. Takes what `setInputFiles` takes. The events are synthetic
-     * (`isTrusted` is false); a page that only accepts trusted drops ignores them.
-     * Waits for the element to be attached and visible.
-     * @example
-     *  await page.getByTestId("dropzone").dropFiles(["files/a.png", "files/b.png"]);
-     */
-    dropFiles(files: FileInput | FileInput[], options?: {
-        timeout?: number;
-    }): Promise<void>;
-    /**
-     * Takes a screenshot of just this element, after scrolling it into view and waiting until it is attached and
-     * visible. Returns the image (also written to `options.path`).
-     * @example
-     *  await page.locator("div[@id='chart']").screenshot({ path: "out/chart.png" });
-     */
-    screenshot(options?: ElementScreenshotOptions & {
-        timeout?: number;
-    }): Promise<Buffer>;
-    /** Waits until the element is attached, then focuses it */
-    focus(options?: ActionOptions): Promise<void>;
-    /** Waits until the element reaches `state` (default "visible"); does not scroll */
-    waitFor(options?: {
-        state?: WaitForState;
-        timeout?: number;
-    }): Promise<void>;
-    /** Returns the browser's getBoundingClientRect result for the given element */
-    getBoundingClientRect(): Promise<ElementRectangle>;
-    /** Whether the element exists, has a non-empty box and is not hidden by CSS */
-    isVisible(): Promise<boolean>;
-    /** The opposite of `isVisible`: true for a hidden element and for one that is not there */
-    isHidden(): Promise<boolean>;
-    /** Trimmed text content, or null when the element is missing */
-    textContent(): Promise<string | null>;
-    /** Rendered text of the element (as a person would copy it, hidden text left out), untrimmed, or null when the element is missing */
-    innerText(): Promise<string | null>;
-    /** The markup inside the element, or null when the element is missing */
-    innerHTML(): Promise<string | null>;
-    /** `textContent` of every match, as the page has it (untrimmed, unlike `textContent()`); `[]` when none match. Does not wait */
-    allTextContents(): Promise<string[]>;
-    /** `innerText` of every match; `[]` when none match. Does not wait */
-    allInnerTexts(): Promise<string[]>;
-    /** The element's box in CSS pixels from the viewport's top left, or null when it is missing or not rendered (`display: none`). Does not wait or scroll */
-    boundingBox(): Promise<BoundingBox | null>;
-    /**
-     * Waits until the element is attached (hidden is fine), then calls `fn(element, arg)` in the page and returns the result
-     * (see `page.evaluate` for what comes back). `fn` is a function or the source of one; a strict locator throws when several match.
-     * @example
-     *  const id = await page.getByTestId("row").evaluate((el) => el.dataset.id);
-     */
-    evaluate<R = unknown, A = unknown>(fn: PageFunction<[any, A], R>, arg?: A, options?: {
-        timeout?: number;
-    }): Promise<R>;
-    /** Calls `fn(elements, arg)` in the page with an array of every match (empty when none; does not wait) and returns the result */
-    evaluateAll<R = unknown, A = unknown>(fn: PageFunction<[any[], A], R>, arg?: A): Promise<R>;
-    /** Value of an input/textarea/select, or null when missing */
-    inputValue(): Promise<string | null>;
-    /** Attribute value, or null when the element or attribute is missing */
-    getAttribute(name: string): Promise<string | null>;
     /** References to the elements currently matching, in document order. Internal: for tooling that identifies elements */
     elements(): Promise<ElementHandle[]>;
     /** Number of elements currently matching */
     count(): Promise<number>;
-    /** Whether the element exists and is not disabled; does not wait */
-    isEnabled(): Promise<boolean>;
-    /** The opposite of `isEnabled`: true for a disabled element and for one that is not there; does not wait */
-    isDisabled(): Promise<boolean>;
-    /** Like `isEnabled`, but null when the element is missing, so callers can tell "disabled" from "not there"; does not wait */
-    enabledState(): Promise<boolean | null>;
-    /** Whether a checkbox or radio input is checked or the element has `aria-checked="true"`; null when the element is missing */
-    isChecked(): Promise<boolean | null>;
-    /** The accessible name (what `getByRole`'s `name` is matched against), "" when there is none, or null when the element is missing */
-    accessibleName(): Promise<string | null>;
-    /** The accessible description (`aria-describedby`, `aria-description`, else `title` when it is not the name), or null when the element is missing */
-    accessibleDescription(): Promise<string | null>;
-    /** The class attribute as written ("" when the element has none), or null when the element is missing */
-    classAttribute(): Promise<string | null>;
-    /** Computed value of a CSS property (camelCase names become kebab-case, `--custom` is kept), or null when the element is missing */
-    cssValue(name: string): Promise<string | null>;
-    /** Whether the element exists and accepts typing (enabled, not readonly, a text field); does not wait */
-    isEditable(): Promise<boolean>;
     /** Wait for certain time (ms). Default: 300ms  */
     wait(duration?: number): Promise<void>;
-    /**
-     * Waits until the element is attached, visible and enabled, focuses it and presses `key` with real keyboard input.
-     * Named keys are `Enter`, `Escape`, `Tab`, `Backspace`, `Delete`, `Space`, `Insert`, `Home`, `End`, `PageUp`, `PageDown`,
-     * `F1` to `F12` and the arrows; any other key must be a single character. A chord holds modifiers (`Control`, `Shift`,
-     * `Alt`, `Meta`, `ControlOrMeta`) while the last key is pressed.
-     * @example
-     *  await page.getByLabel("New todo").press("Enter");
-     *  await page.getByLabel("Name").press("Control+a");
-     */
-    press(key: string, options?: ActionOptions & {
-        delay?: number;
-    }): Promise<void>;
-    /** Waits until the field is editable and not covered, then replaces its value by typing `value`; an empty string clears it */
-    fill(value: string, options?: ActionOptions & {
-        output?: string;
-    }): Promise<void>;
 }