/// <reference types="jest" />
import { Locator } from 'playwright-core';
export type Matchers<T> = LocatorAssertions & PageAssertions & APIResponseAssertions & jest.JestMatchers<T>;
interface LocatorAssertions {
    /**
     * Makes the assertion check for the opposite condition. For example, this code tests that the Locator doesn't contain text
     * `"error"`:
     *
     * ```js
     * await expect(locator).not.toContainText('error');
     * ```
     *
     */
    not: Matchers<any>;
    /**
     * Ensures the [Locator] points to a checked input.
     *
     * ```js
     * const locator = page.getByLabel('Subscribe to newsletter');
     * await expect(locator).toBeChecked();
     * ```
     *
     * @param options
     */
    toBeChecked(options?: {
        checked?: boolean;
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to a disabled element. Element is disabled if it has "disabled" attribute or is disabled
     * via ['aria-disabled'](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-disabled). Note
     * that only native control elements such as HTML `button`, `input`, `select`, `textarea`, `option`, `optgroup` can be
     * disabled by setting "disabled" attribute. "disabled" attribute on other elements is ignored by the browser.
     *
     * ```js
     * const locator = page.locator('button.submit');
     * await expect(locator).toBeDisabled();
     * ```
     *
     * @param options
     */
    toBeDisabled(options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to an editable element.
     *
     * ```js
     * const locator = page.getByRole('textbox');
     * await expect(locator).toBeEditable();
     * ```
     *
     * @param options
     */
    toBeEditable(options?: {
        editable?: boolean;
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to an empty editable element or to a DOM node that has no text.
     *
     * ```js
     * const locator = page.locator('div.warning');
     * await expect(locator).toBeEmpty();
     * ```
     *
     * @param options
     */
    toBeEmpty(options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to an enabled element.
     *
     * ```js
     * const locator = page.locator('button.submit');
     * await expect(locator).toBeEnabled();
     * ```
     *
     * @param options
     */
    toBeEnabled(options?: {
        enabled?: boolean;
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to a focused DOM node.
     *
     * ```js
     * const locator = page.getByRole('textbox');
     * await expect(locator).toBeFocused();
     * ```
     *
     * @param options
     */
    toBeFocused(options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures that [Locator] either does not resolve to any DOM node, or resolves to a
     * [non-visible](https://playwright.dev/docs/api/actionability#visible) one.
     *
     * ```js
     * const locator = page.locator('.my-element');
     * await expect(locator).toBeHidden();
     * ```
     *
     * @param options
     */
    toBeHidden(options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures that [Locator] points to an [attached](https://playwright.dev/docs/api/actionability#attached) and [visible](https://playwright.dev/docs/api/actionability#visible)
     * DOM node.
     *
     * ```js
     * const locator = page.locator('.my-element');
     * await expect(locator).toBeVisible();
     * ```
     *
     * @param options
     */
    toBeVisible(options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
        visible?: boolean;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to an element that contains the given text. You can use regular expressions for the value
     * as well.
     *
     * ```js
     * const locator = page.locator('.title');
     * await expect(locator).toContainText('substring');
     * await expect(locator).toContainText(/\d messages/);
     * ```
     *
     * If you pass an array as an expected value, the expectations are:
     * 1. Locator resolves to a list of elements.
     * 1. Elements from a **subset** of this list contain text from the expected array, respectively.
     * 1. The matching subset of elements has the same order as the expected array.
     * 1. Each text value from the expected array is matched by some element from the list.
     *
     * For example, consider the following list:
     *
     * ```html
     * <ul>
     *   <li>Item Text 1</li>
     *   <li>Item Text 2</li>
     *   <li>Item Text 3</li>
     * </ul>
     * ```
     *
     * Let's see how we can use the assertion:
     *
     * ```js
     * // ✓ Contains the right items in the right order
     * await expect(page.locator('ul > li')).toContainText(['Text 1', 'Text 3']);
     *
     * // ✖ Wrong order
     * await expect(page.locator('ul > li')).toContainText(['Text 3', 'Text 2']);
     *
     * // ✖ No item contains this text
     * await expect(page.locator('ul > li')).toContainText(['Some 33']);
     *
     * // ✖ Locator points to the outer list element, not to the list items
     * await expect(page.locator('ul')).toContainText(['Text 3']);
     * ```
     *
     * @param expected Expected substring or RegExp or a list of those.
     * @param options
     */
    toContainText(expected: string | RegExp | Array<string | RegExp>, options?: {
        /**
         * Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
         * expression flag if specified.
         */
        ignoreCase?: boolean;
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
        /**
         * Whether to use `element.innerText` instead of `element.textContent` when retrieving DOM node text.
         */
        useInnerText?: boolean;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to an element with given attribute.
     *
     * ```js
     * const locator = page.locator('input');
     * await expect(locator).toHaveAttribute('type', 'text');
     * ```
     *
     * @param name Attribute name.
     * @param value Expected attribute value.
     * @param options
     */
    toHaveAttribute(name: string, value: string | RegExp, options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to an element with given CSS classes. This needs to be a full match or using a relaxed
     * regular expression.
     *
     * ```html
     * <div class='selected row' id='component'></div>
     * ```
     *
     * ```js
     * const locator = page.locator('#component');
     * await expect(locator).toHaveClass(/selected/);
     * await expect(locator).toHaveClass('selected row');
     * ```
     *
     * Note that if array is passed as an expected value, entire lists of elements can be asserted:
     *
     * ```js
     * const locator = page.locator('list > .component');
     * await expect(locator).toHaveClass(['component', 'component selected', 'component']);
     * ```
     *
     * @param expected Expected class or RegExp or a list of those.
     * @param options
     */
    toHaveClass(expected: string | RegExp | Array<string | RegExp>, options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] resolves to an exact number of DOM nodes.
     *
     * ```js
     * const list = page.locator('list > .component');
     * await expect(list).toHaveCount(3);
     * ```
     *
     * @param count Expected count.
     * @param options
     */
    toHaveCount(count: number, options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] resolves to an element with the given computed CSS style.
     *
     * ```js
     * const locator = page.getByRole('button');
     * await expect(locator).toHaveCSS('display', 'flex');
     * ```
     *
     * @param name CSS property name.
     * @param value CSS property value.
     * @param options
     */
    toHaveCSS(name: string, value: string | RegExp, options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to an element with the given DOM Node ID.
     *
     * ```js
     * const locator = page.getByRole('textbox');
     * await expect(locator).toHaveId('lastname');
     * ```
     *
     * @param id Element id.
     * @param options
     */
    toHaveId(id: string | RegExp, options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to an element with given JavaScript property. Note that this property can be of a primitive
     * type as well as a plain serializable JavaScript object.
     *
     * ```js
     * const locator = page.locator('.component');
     * await expect(locator).toHaveJSProperty('loaded', true);
     * ```
     *
     * @param name Property name.
     * @param value Property value.
     * @param options
     */
    toHaveJSProperty(name: string, value: any, options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * This function will wait until two consecutive locator screenshots yield the same result, and then compare the last
     * screenshot with the expectation.
     *
     * ```js
     * const locator = page.getByRole('button');
     * await expect(locator).toHaveScreenshot('image.png');
     * ```
     *
     * @param name Snapshot name.
     * @param options
     */
    toHaveScreenshot(name: string | Array<string>, options?: {
        /**
         * When set to `"disabled"`, stops CSS animations, CSS transitions and Web Animations. Animations get different treatment
         * depending on their duration:
         * - finite animations are fast-forwarded to completion, so they'll fire `transitionend` event.
         * - infinite animations are canceled to initial state, and then played over after the screenshot.
         *
         * Defaults to `"disabled"` that disables animations.
         */
        animations?: 'disabled' | 'allow';
        /**
         * When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be changed.
         * Defaults to `"hide"`.
         */
        caret?: 'hide' | 'initial';
        /**
         * Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink box
         * `#FF00FF` that completely covers its bounding box.
         */
        mask?: Array<Locator>;
        /**
         * An acceptable ratio of pixels that are different to the total amount of pixels, between `0` and `1`. Default is
         * configurable with `TestConfig.expect`. Unset by default.
         */
        maxDiffPixelRatio?: number;
        /**
         * An acceptable amount of pixels that could be different. Default is configurable with `TestConfig.expect`. Unset by
         * default.
         */
        maxDiffPixels?: number;
        /**
         * Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
         * Defaults to `false`.
         */
        omitBackground?: boolean;
        /**
         * When set to `"css"`, screenshot will have a single pixel per each css pixel on the page. For high-dpi devices, this will
         * keep screenshots small. Using `"device"` option will produce a single pixel per each device pixel, so screenhots of
         * high-dpi devices will be twice as large or even larger.
         *
         * Defaults to `"css"`.
         */
        scale?: 'css' | 'device';
        /**
         * An acceptable perceived color difference in the [YIQ color space](https://en.wikipedia.org/wiki/YIQ) between the same
         * pixel in compared images, between zero (strict) and one (lax), default is configurable with `TestConfig.expect`.
         * Defaults to `0.2`.
         */
        threshold?: number;
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * This function will wait until two consecutive locator screenshots yield the same result, and then compare the last
     * screenshot with the expectation.
     *
     * ```js
     * const locator = page.getByRole('button');
     * await expect(locator).toHaveScreenshot();
     * ```
     *
     * @param options
     */
    toHaveScreenshot(options?: {
        /**
         * When set to `"disabled"`, stops CSS animations, CSS transitions and Web Animations. Animations get different treatment
         * depending on their duration:
         * - finite animations are fast-forwarded to completion, so they'll fire `transitionend` event.
         * - infinite animations are canceled to initial state, and then played over after the screenshot.
         *
         * Defaults to `"disabled"` that disables animations.
         */
        animations?: 'disabled' | 'allow';
        /**
         * When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be changed.
         * Defaults to `"hide"`.
         */
        caret?: 'hide' | 'initial';
        /**
         * Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink box
         * `#FF00FF` that completely covers its bounding box.
         */
        mask?: Array<Locator>;
        /**
         * An acceptable ratio of pixels that are different to the total amount of pixels, between `0` and `1`. Default is
         * configurable with `TestConfig.expect`. Unset by default.
         */
        maxDiffPixelRatio?: number;
        /**
         * An acceptable amount of pixels that could be different. Default is configurable with `TestConfig.expect`. Unset by
         * default.
         */
        maxDiffPixels?: number;
        /**
         * Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
         * Defaults to `false`.
         */
        omitBackground?: boolean;
        /**
         * When set to `"css"`, screenshot will have a single pixel per each css pixel on the page. For high-dpi devices, this will
         * keep screenshots small. Using `"device"` option will produce a single pixel per each device pixel, so screenhots of
         * high-dpi devices will be twice as large or even larger.
         *
         * Defaults to `"css"`.
         */
        scale?: 'css' | 'device';
        /**
         * An acceptable perceived color difference in the [YIQ color space](https://en.wikipedia.org/wiki/YIQ) between the same
         * pixel in compared images, between zero (strict) and one (lax), default is configurable with `TestConfig.expect`.
         * Defaults to `0.2`.
         */
        threshold?: number;
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to an element with the given text. You can use regular expressions for the value as well.
     *
     * ```js
     * const locator = page.locator('.title');
     * await expect(locator).toHaveText(/Welcome, Test User/);
     * await expect(locator).toHaveText(/Welcome, .*\/);
     * ```
     *
     * If you pass an array as an expected value, the expectations are:
     * 1. Locator resolves to a list of elements.
     * 1. The number of elements equals the number of expected values in the array.
     * 1. Elements from the list have text matching expected array values, one by one, in order.
     *
     * For example, consider the following list:
     *
     * ```html
     * <ul>
     *   <li>Text 1</li>
     *   <li>Text 2</li>
     *   <li>Text 3</li>
     * </ul>
     * ```
     *
     * Let's see how we can use the assertion:
     *
     * ```js
     * // ✓ Has the right items in the right order
     * await expect(page.locator('ul > li')).toHaveText(['Text 1', 'Text 2', 'Text 3']);
     *
     * // ✖ Wrong order
     * await expect(page.locator('ul > li')).toHaveText(['Text 3', 'Text 2', 'Text 1']);
     *
     * // ✖ Last item does not match
     * await expect(page.locator('ul > li')).toHaveText(['Text 1', 'Text 2', 'Text']);
     *
     * // ✖ Locator points to the outer list element, not to the list items
     * await expect(page.locator('ul')).toHaveText(['Text 1', 'Text 2', 'Text 3']);
     * ```
     *
     * @param expected Expected substring or RegExp or a list of those.
     * @param options
     */
    toHaveText(expected: string | RegExp | Array<string | RegExp>, options?: {
        /**
         * Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
         * expression flag if specified.
         */
        ignoreCase?: boolean;
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
        /**
         * Whether to use `element.innerText` instead of `element.textContent` when retrieving DOM node text.
         */
        useInnerText?: boolean;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to an element with the given input value. You can use regular expressions for the value as
     * well.
     *
     * ```js
     * const locator = page.locator('input[type=number]');
     * await expect(locator).toHaveValue(/[0-9]/);
     * ```
     *
     * @param value Expected value.
     * @param options
     */
    toHaveValue(value: string | RegExp, options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the [Locator] points to multi-select/combobox (i.e. a `select` with the `multiple` attribute) and the specified
     * values are selected.
     *
     * For example, given the following element:
     *
     * ```html
     * <select id="favorite-colors" multiple>
     *   <option value="R">Red</option>
     *   <option value="G">Green</option>
     *   <option value="B">Blue</option>
     * </select>
     * ```
     *
     * ```js
     * const locator = page.locator("id=favorite-colors");
     * await locator.selectOption(["R", "G"]);
     * await expect(locator).toHaveValues([/R/, /G/]);
     * ```
     *
     * @param values Expected options currently selected.
     * @param options
     */
    toHaveValues(values: Array<string | RegExp>, options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
}
/**
 * The [PageAssertions] class provides assertion methods that can be used to make assertions about the [Page] state in the
 * tests. A new instance of [PageAssertions] is created by calling
 * [expect(page)](https://playwright.dev/docs/api/class-playwrightassertions#playwright-assertions-expect-page):
 *
 * ```js
 * import { test, expect } from '@playwright/test';
 *
 * test('navigates to login', async ({ page }) => {
 *   // ...
 *   await page.getByText('Sign in').click();
 *   await expect(page).toHaveURL(/.*\/login/);
 * });
 * ```
 *
 */
interface PageAssertions {
    /**
     * Makes the assertion check for the opposite condition. For example, this code tests that the page URL doesn't contain
     * `"error"`:
     *
     * ```js
     * await expect(page).not.toHaveURL('error');
     * ```
     *
     */
    not: Matchers<any>;
    /**
     * This function will wait until two consecutive page screenshots yield the same result, and then compare the last
     * screenshot with the expectation.
     *
     * ```js
     * await expect(page).toHaveScreenshot('image.png');
     * ```
     *
     * @param name Snapshot name.
     * @param options
     */
    toHaveScreenshot(name: string | Array<string>, options?: {
        /**
         * When set to `"disabled"`, stops CSS animations, CSS transitions and Web Animations. Animations get different treatment
         * depending on their duration:
         * - finite animations are fast-forwarded to completion, so they'll fire `transitionend` event.
         * - infinite animations are canceled to initial state, and then played over after the screenshot.
         *
         * Defaults to `"disabled"` that disables animations.
         */
        animations?: 'disabled' | 'allow';
        /**
         * When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be changed.
         * Defaults to `"hide"`.
         */
        caret?: 'hide' | 'initial';
        /**
         * An object which specifies clipping of the resulting image. Should have the following fields:
         */
        clip?: {
            /**
             * x-coordinate of top-left corner of clip area
             */
            x: number;
            /**
             * y-coordinate of top-left corner of clip area
             */
            y: number;
            /**
             * width of clipping area
             */
            width: number;
            /**
             * height of clipping area
             */
            height: number;
        };
        /**
         * When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Defaults to
         * `false`.
         */
        fullPage?: boolean;
        /**
         * Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink box
         * `#FF00FF` that completely covers its bounding box.
         */
        mask?: Array<Locator>;
        /**
         * An acceptable ratio of pixels that are different to the total amount of pixels, between `0` and `1`. Default is
         * configurable with `TestConfig.expect`. Unset by default.
         */
        maxDiffPixelRatio?: number;
        /**
         * An acceptable amount of pixels that could be different. Default is configurable with `TestConfig.expect`. Unset by
         * default.
         */
        maxDiffPixels?: number;
        /**
         * Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
         * Defaults to `false`.
         */
        omitBackground?: boolean;
        /**
         * When set to `"css"`, screenshot will have a single pixel per each css pixel on the page. For high-dpi devices, this will
         * keep screenshots small. Using `"device"` option will produce a single pixel per each device pixel, so screenhots of
         * high-dpi devices will be twice as large or even larger.
         *
         * Defaults to `"css"`.
         */
        scale?: 'css' | 'device';
        /**
         * An acceptable perceived color difference in the [YIQ color space](https://en.wikipedia.org/wiki/YIQ) between the same
         * pixel in compared images, between zero (strict) and one (lax), default is configurable with `TestConfig.expect`.
         * Defaults to `0.2`.
         */
        threshold?: number;
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * This function will wait until two consecutive page screenshots yield the same result, and then compare the last
     * screenshot with the expectation.
     *
     * ```js
     * await expect(page).toHaveScreenshot();
     * ```
     *
     * @param options
     */
    toHaveScreenshot(options?: {
        /**
         * When set to `"disabled"`, stops CSS animations, CSS transitions and Web Animations. Animations get different treatment
         * depending on their duration:
         * - finite animations are fast-forwarded to completion, so they'll fire `transitionend` event.
         * - infinite animations are canceled to initial state, and then played over after the screenshot.
         *
         * Defaults to `"disabled"` that disables animations.
         */
        animations?: 'disabled' | 'allow';
        /**
         * When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be changed.
         * Defaults to `"hide"`.
         */
        caret?: 'hide' | 'initial';
        /**
         * An object which specifies clipping of the resulting image. Should have the following fields:
         */
        clip?: {
            /**
             * x-coordinate of top-left corner of clip area
             */
            x: number;
            /**
             * y-coordinate of top-left corner of clip area
             */
            y: number;
            /**
             * width of clipping area
             */
            width: number;
            /**
             * height of clipping area
             */
            height: number;
        };
        /**
         * When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Defaults to
         * `false`.
         */
        fullPage?: boolean;
        /**
         * Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink box
         * `#FF00FF` that completely covers its bounding box.
         */
        mask?: Array<Locator>;
        /**
         * An acceptable ratio of pixels that are different to the total amount of pixels, between `0` and `1`. Default is
         * configurable with `TestConfig.expect`. Unset by default.
         */
        maxDiffPixelRatio?: number;
        /**
         * An acceptable amount of pixels that could be different. Default is configurable with `TestConfig.expect`. Unset by
         * default.
         */
        maxDiffPixels?: number;
        /**
         * Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
         * Defaults to `false`.
         */
        omitBackground?: boolean;
        /**
         * When set to `"css"`, screenshot will have a single pixel per each css pixel on the page. For high-dpi devices, this will
         * keep screenshots small. Using `"device"` option will produce a single pixel per each device pixel, so screenhots of
         * high-dpi devices will be twice as large or even larger.
         *
         * Defaults to `"css"`.
         */
        scale?: 'css' | 'device';
        /**
         * An acceptable perceived color difference in the [YIQ color space](https://en.wikipedia.org/wiki/YIQ) between the same
         * pixel in compared images, between zero (strict) and one (lax), default is configurable with `TestConfig.expect`.
         * Defaults to `0.2`.
         */
        threshold?: number;
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the page has the given title.
     *
     * ```js
     * await expect(page).toHaveTitle(/.*checkout/);
     * ```
     *
     * @param titleOrRegExp Expected title or RegExp.
     * @param options
     */
    toHaveTitle(titleOrRegExp: string | RegExp, options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
    /**
     * Ensures the page is navigated to the given URL.
     *
     * ```js
     * await expect(page).toHaveURL(/.*checkout/);
     * ```
     *
     * @param urlOrRegExp Expected URL string or RegExp.
     * @param options
     */
    toHaveURL(urlOrRegExp: string | RegExp, options?: {
        /**
         * Time to retry the assertion for. Defaults to `timeout` in `TestConfig.expect`.
         */
        timeout?: number;
    }): Promise<void>;
}
interface APIResponseAssertions {
    /**
     * Makes the assertion check for the opposite condition. For example, this code tests that the response status is not
     * successful:
     *
     * ```js
     * await expect(response).not.toBeOK();
     * ```
     *
     */
    not: Matchers<any>;
    /**
     * Ensures the response status code is within `200..299` range.
     *
     * ```js
     * await expect(response).toBeOK();
     * ```
     *
     */
    toBeOK(): Promise<void>;
}
export {};
//# sourceMappingURL=playwright-types.d.ts.map