codeceptjs 2.4.3 → 2.6.2

package/typings/types.d.ts

@@ -1871,18 +1871,26 @@ declare namespace CodeceptJS {
          */
         selectOption(select: CodeceptJS.LocatorOrString, option: string | any[]): void;
         /**
-         * Sets a cookie.
+         * Sets cookie(s).
+         *
+         * Can be a single cookie object or an array of cookies:
          *
          * ```js
          * I.setCookie({name: 'auth', value: true});
+         *
+         * // as array
+         * I.setCookie([
+         *   {name: 'auth', value: true},
+         *   {name: 'agree', value: true}
+         * ]);
          * ```
          *
-         * @param {object} cookie a cookie object.
+         * @param {object|array} cookie a cookie object or array of cookie objects.
          *
          * Wrapper for `.cookies.set(cookie)`.
          * [See more](https://github.com/segmentio/nightmare/blob/master/Readme.md#cookiessetcookie)
          */
-        setCookie(cookie: any): void;
+        setCookie(cookie: any | any[]): void;
         /**
          * Checks that cookie with given name exists.
          *
@@ -1977,21 +1985,1361 @@ declare namespace CodeceptJS {
          *
          * @param {string }text to wait for.
          * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
-         * @param {CodeceptJS.LocatorOrString} [context] (optional) element located by CSS|XPath|strict locator.
+         * @param {CodeceptJS.LocatorOrString} [context] (optional) element located by CSS|XPath|strict locator.
+         */
+        waitForText(text: string, sec?: number, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Waits for an element to become visible on a page (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         *
+         * ```js
+         * I.waitForVisible('#popup');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+         */
+        waitForVisible(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        /**
+         * Waits for an element to hide (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         *
+         * ```js
+         * I.waitToHide('#popup');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+         */
+        waitToHide(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        /**
+         * Waits for an element to be removed or become invisible on a page (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         *
+         * ```js
+         * I.waitForInvisible('#popup');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+         */
+        waitForInvisible(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        /**
+         * Waits for element to be present on page (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         *
+         * ```js
+         * I.waitForElement('.btn.continue');
+         * I.waitForElement('.btn.continue', 5); // wait for 5 secs
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} [sec] (optional, `1` by default) time in seconds to wait
+         */
+        waitForElement(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        /**
+         * Waits for an element to become not attached to the DOM on a page (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         *
+         * ```js
+         * I.waitForDetached('#popup');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+         */
+        waitForDetached(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        /**
+         * Reload the current page.
+         *
+         * ```js
+         * I.refreshPage();
+         * ```
+         *
+         */
+        refreshPage(): void;
+        /**
+         * Reload the page
+         */
+        refresh(): void;
+        /**
+         * Saves a screenshot to ouput folder (set in codecept.json or codecept.conf.js).
+         * Filename is relative to output folder.
+         * Optionally resize the window to the full available page `scrollHeight` and `scrollWidth` to capture the entire page by passing `true` in as the second argument.
+         *
+         * ```js
+         * I.saveScreenshot('debug.png');
+         * I.saveScreenshot('debug.png', true) //resizes to available scrollHeight and scrollWidth before taking screenshot
+         * ```
+         *
+         * @param {string} fileName file name to save.
+         * @param {boolean} [fullPage=false] (optional, `false` by default) flag to enable fullscreen screenshot mode.
+         */
+        saveScreenshot(fileName: string, fullPage?: boolean): void;
+        /**
+         * Scrolls to element matched by locator.
+         * Extra shift can be set with offsetX and offsetY options.
+         *
+         * ```js
+         * I.scrollTo('footer');
+         * I.scrollTo('#submit', 5, 5);
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
+         * @param {number} [offsetX=0] (optional, `0` by default) X-axis offset.
+         * @param {number} [offsetY=0] (optional, `0` by default) Y-axis offset.
+         */
+        scrollTo(locator: CodeceptJS.LocatorOrString, offsetX?: number, offsetY?: number): void;
+        /**
+         * Scroll page to the top.
+         *
+         * ```js
+         * I.scrollPageToTop();
+         * ```
+         *
+         */
+        scrollPageToTop(): void;
+        /**
+         * Scroll page to the bottom.
+         *
+         * ```js
+         * I.scrollPageToBottom();
+         * ```
+         *
+         */
+        scrollPageToBottom(): void;
+        /**
+         * Retrieves a page scroll position and returns it to test.
+         * Resumes test execution, so **should be used inside an async function with `await`** operator.
+         *
+         * ```js
+         * let { x, y } = await I.grabPageScrollPosition();
+         * ```
+         *
+         * @returns {Promise<Object<string, *>>} scroll position
+         */
+        grabPageScrollPosition(): Promise<{
+            [key: string]: any;
+        }>;
+    }
+    class Playwright {
+        /**
+         * Set the automatic popup response to Accept.
+         * This must be set before a popup is triggered.
+         *
+         * ```js
+         * I.amAcceptingPopups();
+         * I.click('#triggerPopup');
+         * I.acceptPopup();
+         * ```
+         */
+        amAcceptingPopups(): void;
+        /**
+         * Accepts the active JavaScript native popup window, as created by window.alert|window.confirm|window.prompt.
+         * Don't confuse popups with modal windows, as created by [various
+         * libraries](http://jster.net/category/windows-modals-popups).
+         */
+        acceptPopup(): void;
+        /**
+         * Set the automatic popup response to Cancel/Dismiss.
+         * This must be set before a popup is triggered.
+         *
+         * ```js
+         * I.amCancellingPopups();
+         * I.click('#triggerPopup');
+         * I.cancelPopup();
+         * ```
+         */
+        amCancellingPopups(): void;
+        /**
+         * Dismisses the active JavaScript popup, as created by window.alert|window.confirm|window.prompt.
+         */
+        cancelPopup(): void;
+        /**
+         * Checks that the active JavaScript popup, as created by `window.alert|window.confirm|window.prompt`, contains the
+         * given string.
+         *
+         * ```js
+         * I.seeInPopup('Popup text');
+         * ```
+         * @param {string} text value to check.
+         *
+         */
+        seeInPopup(text: string): void;
+        /**
+         * Set current page
+         * @param {object} page page to set
+         */
+        _setPage(page: any): void;
+        /**
+         * Add the 'dialog' event listener to a page
+         * @page {playwright.Page}
+         *
+         * The popup listener handles the dialog with the predefined action when it appears on the page.
+         * It also saves a reference to the object which is used in seeInPopup.
+         */
+        _addPopupListener(): void;
+        /**
+         * Gets page URL including hash.
+         */
+        _getPageUrl(): void;
+        /**
+         * Grab the text within the popup. If no popup is visible then it will return null
+         *
+         * ```js
+         * await I.grabPopupText();
+         * ```
+         * @return {Promise<string | null>}
+         */
+        grabPopupText(): Promise<string | null>;
+        /**
+         * Opens a web page in a browser. Requires relative or absolute url.
+         * If url starts with `/`, opens a web page of a site defined in `url` config parameter.
+         *
+         * ```js
+         * I.amOnPage('/'); // opens main page of website
+         * I.amOnPage('https://github.com'); // opens github
+         * I.amOnPage('/login'); // opens a login page
+         * ```
+         *
+         * @param {string} url url path or global url.
+         */
+        amOnPage(url: string): void;
+        /**
+         * Resize the current window to provided width and height.
+         * First parameter can be set to `maximize`.
+         *
+         * @param {number} width width in pixels or `maximize`.
+         * @param {number} height height in pixels.
+         *
+         * Unlike other drivers Playwright changes the size of a viewport, not the window!
+         * Playwright does not control the window of a browser so it can't adjust its real size.
+         * It also can't maximize a window.
+         *
+         * Update configuration to change real window size on start:
+         *
+         * ```js
+         * // inside codecept.conf.js
+         * // @codeceptjs/configure package must be installed
+         * { setWindowSize } = require('@codeceptjs/configure');
+         * ````
+         */
+        resizeWindow(width: number, height: number): void;
+        /**
+         * Set headers for all next requests
+         *
+         * ```js
+         * I.haveRequestHeaders({
+         *    'X-Sent-By': 'CodeceptJS',
+         * });
+         * ```
+         *
+         * @param {object} customHeaders headers to set
+         */
+        haveRequestHeaders(customHeaders: any): void;
+        /**
+         * Moves cursor to element matched by locator.
+         * Extra shift can be set with offsetX and offsetY options.
+         *
+         * ```js
+         * I.moveCursorTo('.tooltip');
+         * I.moveCursorTo('#submit', 5,5);
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
+         * @param {number} [offsetX=0] (optional, `0` by default) X-axis offset.
+         * @param {number} [offsetY=0] (optional, `0` by default) Y-axis offset.
+         *
+         *
+         */
+        moveCursorTo(locator: CodeceptJS.LocatorOrString, offsetX?: number, offsetY?: number): void;
+        /**
+         * Drag an item to a destination element.
+         *
+         * ```js
+         * I.dragAndDrop('#dragHandle', '#container');
+         * ```
+         *
+         * @param {string|object} srcElement located by CSS|XPath|strict locator.
+         * @param {string|object} destElement located by CSS|XPath|strict locator.
+         */
+        dragAndDrop(srcElement: string | any, destElement: string | any): void;
+        /**
+         * Reload the current page.
+         *
+         * ```js
+         * I.refreshPage();
+         * ```
+         *
+         */
+        refreshPage(): void;
+        /**
+         * Scroll page to the top.
+         *
+         * ```js
+         * I.scrollPageToTop();
+         * ```
+         *
+         */
+        scrollPageToTop(): void;
+        /**
+         * Scroll page to the bottom.
+         *
+         * ```js
+         * I.scrollPageToBottom();
+         * ```
+         *
+         */
+        scrollPageToBottom(): void;
+        /**
+         * Scrolls to element matched by locator.
+         * Extra shift can be set with offsetX and offsetY options.
+         *
+         * ```js
+         * I.scrollTo('footer');
+         * I.scrollTo('#submit', 5, 5);
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
+         * @param {number} [offsetX=0] (optional, `0` by default) X-axis offset.
+         * @param {number} [offsetY=0] (optional, `0` by default) Y-axis offset.
+         */
+        scrollTo(locator: CodeceptJS.LocatorOrString, offsetX?: number, offsetY?: number): void;
+        /**
+         * Checks that title contains text.
+         *
+         * ```js
+         * I.seeInTitle('Home Page');
+         * ```
+         *
+         * @param {string} text text value to check.
+         */
+        seeInTitle(text: string): void;
+        /**
+         * Retrieves a page scroll position and returns it to test.
+         * Resumes test execution, so **should be used inside an async function with `await`** operator.
+         *
+         * ```js
+         * let { x, y } = await I.grabPageScrollPosition();
+         * ```
+         *
+         * @returns {Promise<Object<string, *>>} scroll position
+         */
+        grabPageScrollPosition(): Promise<{
+            [key: string]: any;
+        }>;
+        /**
+         * Checks that title is equal to provided one.
+         *
+         * ```js
+         * I.seeTitleEquals('Test title.');
+         * ```
+         */
+        seeTitleEquals(): void;
+        /**
+         * Checks that title does not contain text.
+         *
+         * ```js
+         * I.dontSeeInTitle('Error');
+         * ```
+         *
+         * @param {string} text value to check.
+         */
+        dontSeeInTitle(text: string): void;
+        /**
+         * Retrieves a page title and returns it to test.
+         * Resumes test execution, so **should be used inside async with `await`** operator.
+         *
+         * ```js
+         * let title = await I.grabTitle();
+         * ```
+         *
+         * @returns {Promise<string>} title
+         */
+        grabTitle(): Promise<string>;
+        /**
+         * Get elements by different locator types, including strict locator
+         * Should be used in custom helpers:
+         *
+         * ```js
+         * const elements = await this.helpers['Playwright']._locate({name: 'password'});
+         * ```
+         *
+         *
+         */
+        _locate(): void;
+        /**
+         * Find a checkbox by providing human readable text:
+         * NOTE: Assumes the checkable element exists
+         *
+         * ```js
+         * this.helpers['Playwright']._locateCheckable('I agree with terms and conditions').then // ...
+         * ```
+         */
+        _locateCheckable(): void;
+        /**
+         * Find a clickable element by providing human readable text:
+         *
+         * ```js
+         * this.helpers['Playwright']._locateClickable('Next page').then // ...
+         * ```
+         */
+        _locateClickable(): void;
+        /**
+         * Find field elements by providing human readable text:
+         *
+         * ```js
+         * this.helpers['Playwright']._locateFields('Your email').then // ...
+         * ```
+         */
+        _locateFields(): void;
+        /**
+         * Switch focus to a particular tab by its number. It waits tabs loading and then switch tab
+         *
+         * ```js
+         * I.switchToNextTab();
+         * I.switchToNextTab(2);
+         * ```
+         *
+         * @param {number} [num=1]
+         */
+        switchToNextTab(num?: number): void;
+        /**
+         * Switch focus to a particular tab by its number. It waits tabs loading and then switch tab
+         *
+         * ```js
+         * I.switchToPreviousTab();
+         * I.switchToPreviousTab(2);
+         * ```
+         * @param {number} [num=1]
+         */
+        switchToPreviousTab(num?: number): void;
+        /**
+         * Close current tab and switches to previous.
+         *
+         * ```js
+         * I.closeCurrentTab();
+         * ```
+         */
+        closeCurrentTab(): void;
+        /**
+         * Close all tabs except for the current one.
+         *
+         * ```js
+         * I.closeOtherTabs();
+         * ```
+         */
+        closeOtherTabs(): void;
+        /**
+         * Open new tab and switch to it
+         *
+         * ```js
+         * I.openNewTab();
+         * ```
+         *
+         * You can pass in [page options](https://github.com/microsoft/playwright/blob/v0.12.1/docs/api.md#browsernewpageoptions) to emulate device on this page
+         *
+         * ```js
+         * // enable mobile
+         * I.openNewTab({ isMobile: true });
+         * ```
+         */
+        openNewTab(): void;
+        /**
+         * Grab number of open tabs.
+         *
+         * ```js
+         * let tabs = await I.grabNumberOfOpenTabs();
+         * ```
+         *
+         * @returns {Promise<number>} number of open tabs
+         */
+        grabNumberOfOpenTabs(): Promise<number>;
+        /**
+         * Checks that a given Element is visible
+         * Element is located by CSS or XPath.
+         *
+         * ```js
+         * I.seeElement('#modal');
+         * ```
+         * @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
+         *
+         */
+        seeElement(locator: CodeceptJS.LocatorOrString): void;
+        /**
+         * Opposite to `seeElement`. Checks that element is not visible (or in DOM)
+         *
+         * ```js
+         * I.dontSeeElement('.modal'); // modal is not shown
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|Strict locator.
+         *
+         */
+        dontSeeElement(locator: CodeceptJS.LocatorOrString): void;
+        /**
+         * Checks that a given Element is present in the DOM
+         * Element is located by CSS or XPath.
+         *
+         * ```js
+         * I.seeElementInDOM('#modal');
+         * ```
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         *
+         */
+        seeElementInDOM(locator: CodeceptJS.LocatorOrString): void;
+        /**
+         * Opposite to `seeElementInDOM`. Checks that element is not on page.
+         *
+         * ```js
+         * I.dontSeeElementInDOM('.nav'); // checks that element is not on page visible or not
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|Strict locator.
+         */
+        dontSeeElementInDOM(locator: CodeceptJS.LocatorOrString): void;
+        /**
+         * Handles a file download.Aa file name is required to save the file on disk.
+         * Files are saved to "output" directory.
+         *
+         * Should be used with [FileSystem helper](https://codecept.io/helpers/FileSystem) to check that file were downloaded correctly.
+         *
+         * ```js
+         * I.handleDownloads('downloads/avatar.jpg');
+         * I.click('Download Avatar');
+         * I.amInPath('output/downloads');
+         * I.waitForFile('downloads/avatar.jpg', 5);
+         *
+         * ```
+         *
+         * @param {string} [fileName] set filename for downloaded file
+         */
+        handleDownloads(fileName?: string): void;
+        /**
+         * Perform a click on a link or a button, given by a locator.
+         * If a fuzzy locator is given, the page will be searched for a button, link, or image matching the locator string.
+         * For buttons, the "value" attribute, "name" attribute, and inner text are searched. For links, the link text is searched.
+         * For images, the "alt" attribute and inner text of any parent links are searched.
+         *
+         * The second parameter is a context (CSS or XPath locator) to narrow the search.
+         *
+         * ```js
+         * // simple link
+         * I.click('Logout');
+         * // button of form
+         * I.click('Submit');
+         * // CSS button
+         * I.click('#form input[type=submit]');
+         * // XPath
+         * I.click('//form/*[@type=submit]');
+         * // link in context
+         * I.click('Logout', '#nav');
+         * // using strict locator
+         * I.click({css: 'nav a.login'});
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator clickable link or button located by text, or any element located by CSS|XPath|strict locator.
+         * @param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element to search in CSS|XPath|Strict locator.
+         *
+         *
+         *
+         */
+        click(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Clicks link and waits for navigation (deprecated)
+         */
+        clickLink(): void;
+        /**
+         *
+         * Force clicks an element without waiting for it to become visible and not animating.
+         *
+         * ```js
+         * I.forceClick('#hiddenButton');
+         * I.forceClick('Click me', '#hidden');
+         * ```
+         *
+         */
+        forceClick(): void;
+        /**
+         * Performs a double-click on an element matched by link|button|label|CSS or XPath.
+         * Context can be specified as second parameter to narrow search.
+         *
+         * ```js
+         * I.doubleClick('Edit');
+         * I.doubleClick('Edit', '.actions');
+         * I.doubleClick({css: 'button.accept'});
+         * I.doubleClick('.btn.edit');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator clickable link or button located by text, or any element located by CSS|XPath|strict locator.
+         * @param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element to search in CSS|XPath|Strict locator.
+         *
+         *
+         *
+         */
+        doubleClick(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Performs right click on a clickable element matched by semantic locator, CSS or XPath.
+         *
+         * ```js
+         * // right click element with id el
+         * I.rightClick('#el');
+         * // right click link or button with text "Click me"
+         * I.rightClick('Click me');
+         * // right click button with text "Click me" inside .context
+         * I.rightClick('Click me', '.context');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator clickable element located by CSS|XPath|strict locator.
+         * @param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element located by CSS|XPath|strict locator.
+         *
+         *
+         *
+         */
+        rightClick(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Selects a checkbox or radio button.
+         * Element is located by label or name or CSS or XPath.
+         *
+         * The second parameter is a context (CSS or XPath locator) to narrow the search.
+         *
+         * ```js
+         * I.checkOption('#agree');
+         * I.checkOption('I Agree to Terms and Conditions');
+         * I.checkOption('agree', '//form');
+         * ```
+         * @param {CodeceptJS.LocatorOrString} field checkbox located by label | name | CSS | XPath | strict locator.
+         * @param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element located by CSS | XPath | strict locator.
+         */
+        checkOption(field: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Unselects a checkbox or radio button.
+         * Element is located by label or name or CSS or XPath.
+         *
+         * The second parameter is a context (CSS or XPath locator) to narrow the search.
+         *
+         * ```js
+         * I.uncheckOption('#agree');
+         * I.uncheckOption('I Agree to Terms and Conditions');
+         * I.uncheckOption('agree', '//form');
+         * ```
+         * @param {CodeceptJS.LocatorOrString} field checkbox located by label | name | CSS | XPath | strict locator.
+         * @param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element located by CSS | XPath | strict locator.
+         */
+        uncheckOption(field: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Verifies that the specified checkbox is checked.
+         *
+         * ```js
+         * I.seeCheckboxIsChecked('Agree');
+         * I.seeCheckboxIsChecked('#agree'); // I suppose user agreed to terms
+         * I.seeCheckboxIsChecked({css: '#signup_form input[type=checkbox]'});
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} field located by label|name|CSS|XPath|strict locator.
+         *
+         */
+        seeCheckboxIsChecked(field: CodeceptJS.LocatorOrString): void;
+        /**
+         * Verifies that the specified checkbox is not checked.
+         *
+         * ```js
+         * I.dontSeeCheckboxIsChecked('#agree'); // located by ID
+         * I.dontSeeCheckboxIsChecked('I agree to terms'); // located by label
+         * I.dontSeeCheckboxIsChecked('agree'); // located by name
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} field located by label|name|CSS|XPath|strict locator.
+         *
+         */
+        dontSeeCheckboxIsChecked(field: CodeceptJS.LocatorOrString): void;
+        /**
+         * Presses a key in the browser and leaves it in a down state.
+         *
+         * To make combinations with modifier key and user operation (e.g. `'Control'` + [`click`](#click)).
+         *
+         * ```js
+         * I.pressKeyDown('Control');
+         * I.click('#element');
+         * I.pressKeyUp('Control');
+         * ```
+         *
+         * @param {string} key name of key to press down.
+         *
+         */
+        pressKeyDown(key: string): void;
+        /**
+         * Releases a key in the browser which was previously set to a down state.
+         *
+         * To make combinations with modifier key and user operation (e.g. `'Control'` + [`click`](#click)).
+         *
+         * ```js
+         * I.pressKeyDown('Control');
+         * I.click('#element');
+         * I.pressKeyUp('Control');
+         * ```
+         *
+         * @param {string} key name of key to release.
+         *
+         */
+        pressKeyUp(key: string): void;
+        /**
+         * Presses a key in the browser (on a focused element).
+         *
+         * _Hint:_ For populating text field or textarea, it is recommended to use [`fillField`](#fillfield).
+         *
+         * ```js
+         * I.pressKey('Backspace');
+         * ```
+         *
+         * To press a key in combination with modifier keys, pass the sequence as an array. All modifier keys (`'Alt'`, `'Control'`, `'Meta'`, `'Shift'`) will be released afterwards.
+         *
+         * ```js
+         * I.pressKey(['Control', 'Z']);
+         * ```
+         *
+         * For specifying operation modifier key based on operating system it is suggested to use `'CommandOrControl'`.
+         * This will press `'Command'` (also known as `'Meta'`) on macOS machines and `'Control'` on non-macOS machines.
+         *
+         * ```js
+         * I.pressKey(['CommandOrControl', 'Z']);
+         * ```
+         *
+         * Some of the supported key names are:
+         * - `'AltLeft'` or `'Alt'`
+         * - `'AltRight'`
+         * - `'ArrowDown'`
+         * - `'ArrowLeft'`
+         * - `'ArrowRight'`
+         * - `'ArrowUp'`
+         * - `'Backspace'`
+         * - `'Clear'`
+         * - `'ControlLeft'` or `'Control'`
+         * - `'ControlRight'`
+         * - `'Command'`
+         * - `'CommandOrControl'`
+         * - `'Delete'`
+         * - `'End'`
+         * - `'Enter'`
+         * - `'Escape'`
+         * - `'F1'` to `'F12'`
+         * - `'Home'`
+         * - `'Insert'`
+         * - `'MetaLeft'` or `'Meta'`
+         * - `'MetaRight'`
+         * - `'Numpad0'` to `'Numpad9'`
+         * - `'NumpadAdd'`
+         * - `'NumpadDecimal'`
+         * - `'NumpadDivide'`
+         * - `'NumpadMultiply'`
+         * - `'NumpadSubtract'`
+         * - `'PageDown'`
+         * - `'PageUp'`
+         * - `'Pause'`
+         * - `'Return'`
+         * - `'ShiftLeft'` or `'Shift'`
+         * - `'ShiftRight'`
+         * - `'Space'`
+         * - `'Tab'`
+         *
+         * @param {string|string[]} key key or array of keys to press.
+         *
+         *
+         * _Note:_ Shortcuts like `'Meta'` + `'A'` do not work on macOS ([GoogleChrome/Playwright#1313](https://github.com/GoogleChrome/Playwright/issues/1313)).
+         */
+        pressKey(key: string | string[]): void;
+        /**
+         * Fills a text field or textarea, after clearing its value, with the given string.
+         * Field is located by name, label, CSS, or XPath.
+         *
+         * ```js
+         * // by label
+         * I.fillField('Email', 'hello@world.com');
+         * // by name
+         * I.fillField('password', secret('123456'));
+         * // by CSS
+         * I.fillField('form#login input[name=username]', 'John');
+         * // or by strict locator
+         * I.fillField({css: 'form#login input[name=username]'}, 'John');
+         * ```
+         * @param {CodeceptJS.LocatorOrString} field located by label|name|CSS|XPath|strict locator.
+         * @param {string} value text value to fill.
+         *
+         *
+         */
+        fillField(field: CodeceptJS.LocatorOrString, value: string): void;
+        /**
+         * Clears a `<textarea>` or text `<input>` element's value.
+         *
+         * ```js
+         * I.clearField('Email');
+         * I.clearField('user[email]');
+         * I.clearField('#email');
+         * ```
+         * @param {string|object} editable field located by label|name|CSS|XPath|strict locator.
+         */
+        clearField(editable: string | any): void;
+        /**
+         * Appends text to a input field or textarea.
+         * Field is located by name, label, CSS or XPath
+         *
+         * ```js
+         * I.appendField('#myTextField', 'appended');
+         * ```
+         * @param {CodeceptJS.LocatorOrString} field located by label|name|CSS|XPath|strict locator
+         * @param {string} value text value to append.
+         *
+         *
+         */
+        appendField(field: CodeceptJS.LocatorOrString, value: string): void;
+        /**
+         * Checks that the given input field or textarea equals to given value.
+         * For fuzzy locators, fields are matched by label text, the "name" attribute, CSS, and XPath.
+         *
+         * ```js
+         * I.seeInField('Username', 'davert');
+         * I.seeInField({css: 'form textarea'},'Type your comment here');
+         * I.seeInField('form input[type=hidden]','hidden_value');
+         * I.seeInField('#searchform input','Search');
+         * ```
+         * @param {CodeceptJS.LocatorOrString} field located by label|name|CSS|XPath|strict locator.
+         * @param {string} value value to check.
+         *
+         */
+        seeInField(field: CodeceptJS.LocatorOrString, value: string): void;
+        /**
+         * Checks that value of input field or textarea doesn't equal to given value
+         * Opposite to `seeInField`.
+         *
+         * ```js
+         * I.dontSeeInField('email', 'user@user.com'); // field by name
+         * I.dontSeeInField({ css: 'form input.email' }, 'user@user.com'); // field by CSS
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} field located by label|name|CSS|XPath|strict locator.
+         * @param {string} value value to check.
+         */
+        dontSeeInField(field: CodeceptJS.LocatorOrString, value: string): void;
+        /**
+         * Attaches a file to element located by label, name, CSS or XPath
+         * Path to file is relative current codecept directory (where codecept.json or codecept.conf.js is located).
+         * File will be uploaded to remote system (if tests are running remotely).
+         *
+         * ```js
+         * I.attachFile('Avatar', 'data/avatar.jpg');
+         * I.attachFile('form input[name=avatar]', 'data/avatar.jpg');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator field located by label|name|CSS|XPath|strict locator.
+         * @param {string} pathToFile local file path relative to codecept.json config file.
+         *
+         */
+        attachFile(locator: CodeceptJS.LocatorOrString, pathToFile: string): void;
+        /**
+         * Selects an option in a drop-down select.
+         * Field is searched by label | name | CSS | XPath.
+         * Option is selected by visible text or by value.
+         *
+         * ```js
+         * I.selectOption('Choose Plan', 'Monthly'); // select by label
+         * I.selectOption('subscription', 'Monthly'); // match option by text
+         * I.selectOption('subscription', '0'); // or by value
+         * I.selectOption('//form/select[@name=account]','Premium');
+         * I.selectOption('form select[name=account]', 'Premium');
+         * I.selectOption({css: 'form select[name=account]'}, 'Premium');
+         * ```
+         *
+         * Provide an array for the second argument to select multiple options.
+         *
+         * ```js
+         * I.selectOption('Which OS do you use?', ['Android', 'iOS']);
+         * ```
+         * @param {CodeceptJS.LocatorOrString} select field located by label|name|CSS|XPath|strict locator.
+         * @param {string|Array<*>} option visible text or value of option.
+         */
+        selectOption(select: CodeceptJS.LocatorOrString, option: string | any[]): void;
+        /**
+         * Grab number of visible elements by locator.
+         *
+         * ```js
+         * let numOfElements = await I.grabNumberOfVisibleElements('p');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
+         * @returns {Promise<number>} number of visible elements
+         *
+         */
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
+        /**
+         * Checks that current url contains a provided fragment.
+         *
+         * ```js
+         * I.seeInCurrentUrl('/register'); // we are on registration page
+         * ```
+         *
+         * @param {string} url a fragment to check
+         */
+        seeInCurrentUrl(url: string): void;
+        /**
+         * Checks that current url does not contain a provided fragment.
+         *
+         * @param {string} url value to check.
+         */
+        dontSeeInCurrentUrl(url: string): void;
+        /**
+         * Checks that current url is equal to provided one.
+         * If a relative url provided, a configured url will be prepended to it.
+         * So both examples will work:
+         *
+         * ```js
+         * I.seeCurrentUrlEquals('/register');
+         * I.seeCurrentUrlEquals('http://my.site.com/register');
+         * ```
+         *
+         * @param {string} url value to check.
+         */
+        seeCurrentUrlEquals(url: string): void;
+        /**
+         * Checks that current url is not equal to provided one.
+         * If a relative url provided, a configured url will be prepended to it.
+         *
+         * ```js
+         * I.dontSeeCurrentUrlEquals('/login'); // relative url are ok
+         * I.dontSeeCurrentUrlEquals('http://mysite.com/login'); // absolute urls are also ok
+         * ```
+         *
+         * @param {string} url value to check.
+         */
+        dontSeeCurrentUrlEquals(url: string): void;
+        /**
+         * Checks that a page contains a visible text.
+         * Use context parameter to narrow down the search.
+         *
+         * ```js
+         * I.see('Welcome'); // text welcome on a page
+         * I.see('Welcome', '.content'); // text inside .content div
+         * I.see('Register', {css: 'form.register'}); // use strict locator
+         * ```
+         * @param {string} text expected on page.
+         * @param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element located by CSS|Xpath|strict locator in which to search for text.
+         *
+         *
+         */
+        see(text: string, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Checks that text is equal to provided one.
+         *
+         * ```js
+         * I.seeTextEquals('text', 'h1');
+         * ```
+         *
+         * @param {string} text element value to check.
+         * @param {CodeceptJS.LocatorOrString?} [context=null]  element located by CSS|XPath|strict locator.
+         */
+        seeTextEquals(text: string, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Opposite to `see`. Checks that a text is not present on a page.
+         * Use context parameter to narrow down the search.
+         *
+         * ```js
+         * I.dontSee('Login'); // assume we are already logged in.
+         * I.dontSee('Login', '.nav'); // no login inside .nav element
+         * ```
+         *
+         * @param {string} text which is not present.
+         * @param {CodeceptJS.LocatorOrString} [context] (optional) element located by CSS|XPath|strict locator in which to perfrom search.
+         *
+         *
+         *
+         */
+        dontSee(text: string, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Retrieves page source and returns it to test.
+         * Resumes test execution, so should be used inside an async function.
+         *
+         * ```js
+         * let pageSource = await I.grabSource();
+         * ```
+         *
+         * @returns {Promise<string>} source code
+         */
+        grabSource(): Promise<string>;
+        /**
+         * Get JS log from browser.
+         *
+         * ```js
+         * let logs = await I.grabBrowserLogs();
+         * console.log(JSON.stringify(logs))
+         * ```
+         * @return {Promise<any[]>}
+         */
+        grabBrowserLogs(): Promise<any[]>;
+        /**
+         * Get current URL from browser.
+         * Resumes test execution, so should be used inside an async function.
+         *
+         * ```js
+         * let url = await I.grabCurrentUrl();
+         * console.log(`Current URL is [${url}]`);
+         * ```
+         *
+         * @returns {Promise<string>} current URL
+         */
+        grabCurrentUrl(): Promise<string>;
+        /**
+         * Checks that the current page contains the given string in its raw source code.
+         *
+         * ```js
+         * I.seeInSource('<h1>Green eggs &amp; ham</h1>');
+         * ```
+         * @param {string} text value to check.
+         */
+        seeInSource(text: string): void;
+        /**
+         * Checks that the current page does not contains the given string in its raw source code.
+         *
+         * ```js
+         * I.dontSeeInSource('<!--'); // no comments in source
+         * ```
+         *
+         * @param {string} value to check.
+         *
+         */
+        dontSeeInSource(value: string): void;
+        /**
+         * Asserts that an element appears a given number of times in the DOM.
+         * Element is located by label or name or CSS or XPath.
+         *
+         *
+         * ```js
+         * I.seeNumberOfElements('#submitBtn', 1);
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} num number of elements.
+         *
+         *
+         *
+         */
+        seeNumberOfElements(locator: CodeceptJS.LocatorOrString, num: number): void;
+        /**
+         * Asserts that an element is visible a given number of times.
+         * Element is located by CSS or XPath.
+         *
+         * ```js
+         * I.seeNumberOfVisibleElements('.buttons', 3);
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} num number of elements.
+         *
+         *
+         *
+         */
+        seeNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, num: number): void;
+        /**
+         * Sets cookie(s).
+         *
+         * Can be a single cookie object or an array of cookies:
+         *
+         * ```js
+         * I.setCookie({name: 'auth', value: true});
+         *
+         * // as array
+         * I.setCookie([
+         *   {name: 'auth', value: true},
+         *   {name: 'agree', value: true}
+         * ]);
+         * ```
+         *
+         * @param {object|array} cookie a cookie object or array of cookie objects.
+         */
+        setCookie(cookie: any | any[]): void;
+        /**
+         * Checks that cookie with given name exists.
+         *
+         * ```js
+         * I.seeCookie('Auth');
+         * ```
+         *
+         * @param {string} name cookie name.
+         *
+         *
+         */
+        seeCookie(name: string): void;
+        /**
+         * Checks that cookie with given name does not exist.
+         *
+         * ```js
+         * I.dontSeeCookie('auth'); // no auth cookie
+         * ```
+         *
+         * @param {string} name cookie name.
+         */
+        dontSeeCookie(name: string): void;
+        /**
+         * Gets a cookie object by name.
+         * If none provided gets all cookies.
+         * Resumes test execution, so **should be used inside async with `await`** operator.
+         *
+         * ```js
+         * let cookie = await I.grabCookie('auth');
+         * assert(cookie.value, '123456');
+         * ```
+         *
+         * @param {?string} [name=null] cookie name.
+         * @returns {Promise<string>} attribute value
+         *
+         * Returns cookie in JSON format. If name not passed returns all cookies for this domain.
+         */
+        grabCookie(name?: string): Promise<string>;
+        /**
+         * Clears a cookie by name,
+         * if none provided clears all cookies.
+         *
+         * ```js
+         * I.clearCookie();
+         * I.clearCookie('test');
+         * ```
+         *
+         * @param {?string} [cookie=null] (optional, `null` by default) cookie name
+         */
+        clearCookie(cookie?: string): void;
+        /**
+         * Executes a script on the page:
+         *
+         * ```js
+         * I.executeScript(() => window.alert('Hello world'));
+         * ```
+         *
+         * Additional parameters of the function can be passed as an object argument:
+         *
+         * ```js
+         * I.executeScript(({x, y}) => x + y, {x, y});
+         * ```
+         * You can pass only one parameter into a function
+         * but you can pass in array or object.
+         *
+         * ```js
+         * I.executeScript(([x, y]) => x + y, [x, y]);
+         * ```
+         * If a function returns a Promise it will wait for its resolution.
+         */
+        executeScript(): void;
+        /**
+         * Retrieves a text from an element located by CSS or XPath and returns it to test.
+         * Resumes test execution, so **should be used inside async with `await`** operator.
+         *
+         * ```js
+         * let pin = await I.grabTextFrom('#pin');
+         * ```
+         * If multiple elements found returns an array of texts.
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @returns {Promise<string|string[]>} attribute value
+         *
+         */
+        grabTextFrom(locator: CodeceptJS.LocatorOrString): Promise<string | string[]>;
+        /**
+         * Retrieves a value from a form element located by CSS or XPath and returns it to test.
+         * Resumes test execution, so **should be used inside async function with `await`** operator.
+         *
+         * ```js
+         * let email = await I.grabValueFrom('input[name=email]');
+         * ```
+         * @param {CodeceptJS.LocatorOrString} locator field located by label|name|CSS|XPath|strict locator.
+         * @returns {Promise<string>} attribute value
+         */
+        grabValueFrom(locator: CodeceptJS.LocatorOrString): Promise<string>;
+        /**
+         * Retrieves the innerHTML from an element located by CSS or XPath and returns it to test.
+         * Resumes test execution, so **should be used inside async function with `await`** operator.
+         * If more than one element is found - an array of HTMLs returned.
+         *
+         * ```js
+         * let postHTML = await I.grabHTMLFrom('#post');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} element located by CSS|XPath|strict locator.
+         * @returns {Promise<string>} HTML code for an element
+         */
+        grabHTMLFrom(element: CodeceptJS.LocatorOrString): Promise<string>;
+        /**
+         * Grab CSS property for given locator
+         * Resumes test execution, so **should be used inside an async function with `await`** operator.
+         *
+         * ```js
+         * const value = await I.grabCssPropertyFrom('h3', 'font-weight');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {string} cssProperty CSS property name.
+         * @returns {Promise<string>} CSS value
+         *
+         */
+        grabCssPropertyFrom(locator: CodeceptJS.LocatorOrString, cssProperty: string): Promise<string>;
+        /**
+         * Checks that all elements with given locator have given CSS properties.
+         *
+         * ```js
+         * I.seeCssPropertiesOnElements('h3', { 'font-weight': "bold"});
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
+         * @param {object} cssProperties object with CSS properties and their values to check.
+         *
+         */
+        seeCssPropertiesOnElements(locator: CodeceptJS.LocatorOrString, cssProperties: any): void;
+        /**
+         * Checks that all elements with given locator have given attributes.
+         *
+         * ```js
+         * I.seeAttributesOnElements('//form', { method: "post"});
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
+         * @param {object} attributes attributes and their values to check.
+         *
+         */
+        seeAttributesOnElements(locator: CodeceptJS.LocatorOrString, attributes: any): void;
+        /**
+         * Drag the scrubber of a slider to a given position
+         * For fuzzy locators, fields are matched by label text, the "name" attribute, CSS, and XPath.
+         *
+         * ```js
+         * I.dragSlider('#slider', 30);
+         * I.dragSlider('#slider', -70);
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator located by label|name|CSS|XPath|strict locator.
+         * @param {number} offsetX position to drag.
+         *
+         */
+        dragSlider(locator: CodeceptJS.LocatorOrString, offsetX: number): void;
+        /**
+         * Retrieves an attribute from an element located by CSS or XPath and returns it to test.
+         * An array as a result will be returned if there are more than one matched element.
+         * Resumes test execution, so **should be used inside async with `await`** operator.
+         *
+         * ```js
+         * let hint = await I.grabAttributeFrom('#tooltip', 'title');
+         * ```
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {string} attr attribute name.
+         * @returns {Promise<string>} attribute value
+         *
+         */
+        grabAttributeFrom(locator: CodeceptJS.LocatorOrString, attr: string): Promise<string>;
+        /**
+         * Saves a screenshot to ouput folder (set in codecept.json or codecept.conf.js).
+         * Filename is relative to output folder.
+         * Optionally resize the window to the full available page `scrollHeight` and `scrollWidth` to capture the entire page by passing `true` in as the second argument.
+         *
+         * ```js
+         * I.saveScreenshot('debug.png');
+         * I.saveScreenshot('debug.png', true) //resizes to available scrollHeight and scrollWidth before taking screenshot
+         * ```
+         *
+         * @param {string} fileName file name to save.
+         * @param {boolean} [fullPage=false] (optional, `false` by default) flag to enable fullscreen screenshot mode.
+         */
+        saveScreenshot(fileName: string, fullPage?: boolean): void;
+        /**
+         * Pauses execution for a number of seconds.
+         *
+         * ```js
+         * I.wait(2); // wait 2 secs
+         * ```
+         *
+         * @param {number} sec number of second to wait.
+         */
+        wait(sec: number): void;
+        /**
+         * Waits for element to become enabled (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} [sec=1] (optional) time in seconds to wait, 1 by default.
+         */
+        waitForEnabled(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        /**
+         * Waits for the specified value to be in value attribute.
+         *
+         * ```js
+         * I.waitForValue('//input', "GoodValue");
+         * ```
+         *
+         * @param {string|object} field input field.
+         * @param {string }value expected value.
+         * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+         */
+        waitForValue(field: string | any, value: string, sec?: number): void;
+        /**
+         * Waits for a specified number of elements on the page.
+         *
+         * ```js
+         * I.waitNumberOfVisibleElements('a', 3);
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} num number of elements.
+         * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+         *
+         */
+        waitNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, num: number, sec?: number): void;
+        /**
+         * Waits for element to be clickable (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         *
+         * ```js
+         * I.waitForClickable('.btn.continue');
+         * I.waitForClickable('.btn.continue', 5); // wait for 5 secs
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} [sec] (optional, `1` by default) time in seconds to wait
+         */
+        waitForClickable(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        /**
+         * Waits for element to be present on page (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         *
+         * ```js
+         * I.waitForElement('.btn.continue');
+         * I.waitForElement('.btn.continue', 5); // wait for 5 secs
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} [sec] (optional, `1` by default) time in seconds to wait
+         *
+         */
+        waitForElement(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        /**
+         * Waits for an element to become visible on a page (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         *
+         * ```js
+         * I.waitForVisible('#popup');
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+         *
+         * This method accepts [React selectors](https://codecept.io/react).
          */
-        waitForText(text: string, sec?: number, context?: CodeceptJS.LocatorOrString): void;
+        waitForVisible(locator: CodeceptJS.LocatorOrString, sec?: number): void;
         /**
-         * Waits for an element to become visible on a page (by default waits for 1sec).
+         * Waits for an element to be removed or become invisible on a page (by default waits for 1sec).
          * Element can be located by CSS or XPath.
          *
          * ```js
-         * I.waitForVisible('#popup');
+         * I.waitForInvisible('#popup');
          * ```
          *
          * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
          * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
          */
-        waitForVisible(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        waitForInvisible(locator: CodeceptJS.LocatorOrString, sec?: number): void;
         /**
          * Waits for an element to hide (by default waits for 1sec).
          * Element can be located by CSS or XPath.
@@ -2005,114 +3353,177 @@ declare namespace CodeceptJS {
          */
         waitToHide(locator: CodeceptJS.LocatorOrString, sec?: number): void;
         /**
-         * Waits for an element to be removed or become invisible on a page (by default waits for 1sec).
-         * Element can be located by CSS or XPath.
+         * Waiting for the part of the URL to match the expected. Useful for SPA to understand that page was changed.
          *
          * ```js
-         * I.waitForInvisible('#popup');
+         * I.waitInUrl('/info', 2);
          * ```
          *
-         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {string} urlPart value to check.
          * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
          */
-        waitForInvisible(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        waitInUrl(urlPart: string, sec?: number): void;
         /**
-         * Waits for element to be present on page (by default waits for 1sec).
-         * Element can be located by CSS or XPath.
+         * Waits for the entire URL to match the expected
          *
          * ```js
-         * I.waitForElement('.btn.continue');
-         * I.waitForElement('.btn.continue', 5); // wait for 5 secs
+         * I.waitUrlEquals('/info', 2);
+         * I.waitUrlEquals('http://127.0.0.1:8000/info');
          * ```
          *
-         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
-         * @param {number} [sec] (optional, `1` by default) time in seconds to wait
+         * @param {string} urlPart value to check.
+         * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
          */
-        waitForElement(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        waitUrlEquals(urlPart: string, sec?: number): void;
         /**
-         * Waits for an element to become not attached to the DOM on a page (by default waits for 1sec).
+         * Waits for a text to appear (by default waits for 1sec).
          * Element can be located by CSS or XPath.
+         * Narrow down search results by providing context.
          *
          * ```js
-         * I.waitForDetached('#popup');
+         * I.waitForText('Thank you, form has been submitted');
+         * I.waitForText('Thank you, form has been submitted', 5, '#modal');
          * ```
          *
-         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {string }text to wait for.
          * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+         * @param {CodeceptJS.LocatorOrString} [context] (optional) element located by CSS|XPath|strict locator.
          */
-        waitForDetached(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        waitForText(text: string, sec?: number, context?: CodeceptJS.LocatorOrString): void;
         /**
-         * Reload the current page.
+         * Waits for a network request.
          *
          * ```js
-         * I.refreshPage();
+         * I.waitForRequest('http://example.com/resource');
+         * I.waitForRequest(request => request.url() === 'http://example.com' && request.method() === 'GET');
          * ```
          *
+         * @param {string|function} urlOrPredicate
+         * @param {?number} [sec=null] seconds to wait
          */
-        refreshPage(): void;
+        waitForRequest(urlOrPredicate: string | ((...params: any[]) => any), sec?: number): void;
         /**
-         * Reload the page
+         * Waits for a network request.
+         *
+         * ```js
+         * I.waitForResponse('http://example.com/resource');
+         * I.waitForResponse(request => request.url() === 'http://example.com' && request.method() === 'GET');
+         * ```
+         *
+         * @param {string|function} urlOrPredicate
+         * @param {?number} [sec=null] number of seconds to wait
          */
-        refresh(): void;
+        waitForResponse(urlOrPredicate: string | ((...params: any[]) => any), sec?: number): void;
         /**
-         * Saves a screenshot to ouput folder (set in codecept.json or codecept.conf.js).
-         * Filename is relative to output folder.
-         * Optionally resize the window to the full available page `scrollHeight` and `scrollWidth` to capture the entire page by passing `true` in as the second argument.
+         * Switches frame or in case of null locator reverts to parent.
          *
          * ```js
-         * I.saveScreenshot('debug.png');
-         * I.saveScreenshot('debug.png', true) //resizes to available scrollHeight and scrollWidth before taking screenshot
+         * I.switchTo('iframe'); // switch to first iframe
+         * I.switchTo(); // switch back to main page
          * ```
          *
-         * @param {string} fileName file name to save.
-         * @param {boolean} [fullPage=false] (optional, `false` by default) flag to enable fullscreen screenshot mode.
+         * @param {?CodeceptJS.LocatorOrString} [locator=null] (optional, `null` by default) element located by CSS|XPath|strict locator.
          */
-        saveScreenshot(fileName: string, fullPage?: boolean): void;
+        switchTo(locator?: CodeceptJS.LocatorOrString): void;
         /**
-         * Scrolls to element matched by locator.
-         * Extra shift can be set with offsetX and offsetY options.
+         * Waits for a function to return true (waits for 1 sec by default).
+         * Running in browser context.
          *
          * ```js
-         * I.scrollTo('footer');
-         * I.scrollTo('#submit', 5, 5);
+         * I.waitForFunction(fn[, [args[, timeout]])
          * ```
          *
-         * @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
-         * @param {number} [offsetX=0] (optional, `0` by default) X-axis offset.
-         * @param {number} [offsetY=0] (optional, `0` by default) Y-axis offset.
+         * ```js
+         * I.waitForFunction(() => window.requests == 0);
+         * I.waitForFunction(() => window.requests == 0, 5); // waits for 5 sec
+         * I.waitForFunction((count) => window.requests == count, [3], 5) // pass args and wait for 5 sec
+         * ```
+         *
+         * @param {string|function} fn to be executed in browser context.
+         * @param {any[]|number} [argsOrSec] (optional, `1` by default) arguments for function or seconds.
+         * @param {number} [sec] (optional, `1` by default) time in seconds to wait
+         *
          */
-        scrollTo(locator: CodeceptJS.LocatorOrString, offsetX?: number, offsetY?: number): void;
+        waitForFunction(fn: string | ((...params: any[]) => any), argsOrSec?: any[] | number, sec?: number): void;
         /**
-         * Scroll page to the top.
+         * Waits for navigation to finish. By default takes configured `waitForNavigation` option.
+         *
+         * See [Pupeteer's reference](https://github.com/GoogleChrome/Playwright/blob/master/docs/api.md#pagewaitfornavigationoptions)
+         *
+         * @param {*} opts
+         */
+        waitForNavigation(opts: any): void;
+        /**
+         * Waits for a function to return true (waits for 1sec by default).
          *
          * ```js
-         * I.scrollPageToTop();
+         * I.waitUntil(() => window.requests == 0);
+         * I.waitUntil(() => window.requests == 0, 5);
          * ```
          *
+         * @param {function|string} fn function which is executed in browser context.
+         * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
+         * @param {string} [timeoutMsg=''] message to show in case of timeout fail.
+         * @param {?number} [interval=null]
          */
-        scrollPageToTop(): void;
+        waitUntil(fn: ((...params: any[]) => any) | string, sec?: number, timeoutMsg?: string, interval?: number): void;
         /**
-         * Scroll page to the bottom.
+         * Waits for an element to become not attached to the DOM on a page (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
          *
          * ```js
-         * I.scrollPageToBottom();
+         * I.waitForDetached('#popup');
          * ```
          *
+         * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+         * @param {number} [sec=1] (optional, `1` by default) time in seconds to wait
          */
-        scrollPageToBottom(): void;
+        waitForDetached(locator: CodeceptJS.LocatorOrString, sec?: number): void;
         /**
-         * Retrieves a page scroll position and returns it to test.
+         * Grab the data from performance timing using Navigation Timing API.
+         * The returned data will contain following things in ms:
+         * - responseEnd,
+         * - domInteractive,
+         * - domContentLoadedEventEnd,
+         * - loadEventEnd
          * Resumes test execution, so **should be used inside an async function with `await`** operator.
          *
          * ```js
-         * let { x, y } = await I.grabPageScrollPosition();
+         * await I.amOnPage('https://example.com');
+         * let data = await I.grabDataFromPerformanceTiming();
+         * //Returned data
+         * { // all results are in [ms]
+         *   responseEnd: 23,
+         *   domInteractive: 44,
+         *   domContentLoadedEventEnd: 196,
+         *   loadEventEnd: 241
+         * }
          * ```
+         */
+        grabDataFromPerformanceTiming(): void;
+        /**
+         * Grab the width, height, location of given locator.
+         * Provide `width` or `height`as second param to get your desired prop.
+         * Resumes test execution, so **should be used inside an async function with `await`** operator.
          *
-         * @returns {Promise<Object<string, *>>} scroll position
+         * Returns an object with `x`, `y`, `width`, `height` keys.
+         *
+         * ```js
+         * const value = await I.grabElementBoundingRect('h3');
+         * // value is like { x: 226.5, y: 89, width: 527, height: 220 }
+         * ```
+         *
+         * To get only one metric use second parameter:
+         *
+         * ```js
+         * const width = await I.grabElementBoundingRect('h3', 'width');
+         * // width == 527
+         * ```
+         * @param {string|object} locator element located by CSS|XPath|strict locator.
+         * @param {string} elementSize x, y, width or height of the given element.
+         * @returns {object} Element bounding rectangle
          */
-        grabPageScrollPosition(): Promise<{
-            [key: string]: any;
-        }>;
+        grabElementBoundingRect(locator: string | any, elementSize: string): any;
     }
     /**
      * This helper works the same as MockRequest helper. It has been included for backwards compatibility
@@ -2938,8 +4349,14 @@ declare namespace CodeceptJS {
         /**
          * Checks that the active JavaScript popup, as created by `window.alert|window.confirm|window.prompt`, contains the
          * given string.
+         *
+         * ```js
+         * I.seeInPopup('Popup text');
+         * ```
+         * @param {string} text value to check.
+         *
          */
-        seeInPopup(): void;
+        seeInPopup(text: string): void;
         /**
          * Grab the text within the popup. If no popup is visible then it will return null
          *
@@ -3300,15 +4717,23 @@ declare namespace CodeceptJS {
          */
         resetModule(): void;
         /**
-         * Sets a cookie.
+         * Sets cookie(s).
+         *
+         * Can be a single cookie object or an array of cookies:
          *
          * ```js
          * I.setCookie({name: 'auth', value: true});
+         *
+         * // as array
+         * I.setCookie([
+         *   {name: 'auth', value: true},
+         *   {name: 'agree', value: true}
+         * ]);
          * ```
          *
-         * @param {object} cookie a cookie object.
+         * @param {object|array} cookie a cookie object or array of cookie objects.
          */
-        setCookie(cookie: any): void;
+        setCookie(cookie: any | any[]): void;
     }
     class Puppeteer {
         /**
@@ -3346,8 +4771,14 @@ declare namespace CodeceptJS {
         /**
          * Checks that the active JavaScript popup, as created by `window.alert|window.confirm|window.prompt`, contains the
          * given string.
+         *
+         * ```js
+         * I.seeInPopup('Popup text');
+         * ```
+         * @param {string} text value to check.
+         *
          */
-        seeInPopup(): void;
+        seeInPopup(text: string): void;
         /**
          * Set current page
          * @param {object} page page to set
@@ -3695,6 +5126,39 @@ declare namespace CodeceptJS {
          * {{ react }}
          */
         click(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Perform an emulated click on a link or a button, given by a locator.
+         * Unlike normal click instead of sending native event, emulates a click with JavaScript.
+         * This works on hidden, animated or inactive elements as well.
+         *
+         * If a fuzzy locator is given, the page will be searched for a button, link, or image matching the locator string.
+         * For buttons, the "value" attribute, "name" attribute, and inner text are searched. For links, the link text is searched.
+         * For images, the "alt" attribute and inner text of any parent links are searched.
+         *
+         * The second parameter is a context (CSS or XPath locator) to narrow the search.
+         *
+         * ```js
+         * // simple link
+         * I.forceClick('Logout');
+         * // button of form
+         * I.forceClick('Submit');
+         * // CSS button
+         * I.forceClick('#form input[type=submit]');
+         * // XPath
+         * I.forceClick('//form/*[@type=submit]');
+         * // link in context
+         * I.forceClick('Logout', '#nav');
+         * // using strict locator
+         * I.forceClick({css: 'nav a.login'});
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator clickable link or button located by text, or any element located by CSS|XPath|strict locator.
+         * @param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element to search in CSS|XPath|Strict locator.
+         *
+         *
+         * {{ react }}
+         */
+        forceClick(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString): void;
         /**
          * Performs a click on a link and waits for navigation before moving on.
          *
@@ -4003,6 +5467,8 @@ declare namespace CodeceptJS {
          *
          * @param {CodeceptJS.LocatorOrString} locator field located by label|name|CSS|XPath|strict locator.
          * @param {string} pathToFile local file path relative to codecept.json config file.
+         *
+         * > ⚠ There is an [issue with file upload in Puppeteer 2.1.0 & 2.1.1](https://github.com/puppeteer/puppeteer/issues/5420), downgrade to 2.0.0 if you face it.
          */
         attachFile(locator: CodeceptJS.LocatorOrString, pathToFile: string): void;
         /**
@@ -4208,15 +5674,23 @@ declare namespace CodeceptJS {
          */
         seeNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, num: number): void;
         /**
-         * Sets a cookie.
+         * Sets cookie(s).
+         *
+         * Can be a single cookie object or an array of cookies:
          *
          * ```js
          * I.setCookie({name: 'auth', value: true});
+         *
+         * // as array
+         * I.setCookie([
+         *   {name: 'auth', value: true},
+         *   {name: 'agree', value: true}
+         * ]);
          * ```
          *
-         * @param {object} cookie a cookie object.
+         * @param {object|array} cookie a cookie object or array of cookie objects.
          */
-        setCookie(cookie: any): void;
+        setCookie(cookie: any | any[]): void;
         /**
          * Checks that cookie with given name exists.
          *
@@ -5475,15 +6949,23 @@ declare namespace CodeceptJS {
          */
         switchTo(locator?: CodeceptJS.LocatorOrString): void;
         /**
-         * Sets a cookie.
+         * Sets cookie(s).
+         *
+         * Can be a single cookie object or an array of cookies:
          *
          * ```js
          * I.setCookie({name: 'auth', value: true});
+         *
+         * // as array
+         * I.setCookie([
+         *   {name: 'auth', value: true},
+         *   {name: 'agree', value: true}
+         * ]);
          * ```
          *
-         * @param {object} cookie a cookie object.
+         * @param {object|array} cookie a cookie object or array of cookie objects.
          */
-        setCookie(cookie: any): void;
+        setCookie(cookie: any | any[]): void;
         /**
          * Checks that cookie with given name exists.
          *
@@ -5644,6 +7126,24 @@ declare namespace CodeceptJS {
         waitForText(text: string, sec?: number, context?: CodeceptJS.LocatorOrString): void;
     }
     class WebDriver {
+        /**
+         * Check if locator is type of "Shadow"
+         *
+         * @param {object} locator
+         */
+        _isShadowLocator(locator: any): void;
+        /**
+         * Locate Element within the Shadow Dom
+         *
+         * @param {object} locator
+         */
+        _locateShadow(locator: any): void;
+        /**
+         * Smart Wait to locate an element
+         *
+         * @param {object} locator
+         */
+        _smartWait(locator: any): void;
         /**
          * Get elements by different locator types, including strict locator.
          * Should be used in custom helpers:
@@ -5670,7 +7170,8 @@ declare namespace CodeceptJS {
          * Find a clickable element by providing human readable text:
          *
          * ```js
-         * this.helpers['WebDriver']._locateClickable('Next page').then // ...
+         * const els = await this.helpers.WebDriver._locateClickable('Next page');
+         * const els = await this.helpers.WebDriver._locateClickable('Next page', '.pages');
          * ```
          *
          * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
@@ -5743,6 +7244,39 @@ declare namespace CodeceptJS {
          * {{ react }}
          */
         click(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString): void;
+        /**
+         * Perform an emulated click on a link or a button, given by a locator.
+         * Unlike normal click instead of sending native event, emulates a click with JavaScript.
+         * This works on hidden, animated or inactive elements as well.
+         *
+         * If a fuzzy locator is given, the page will be searched for a button, link, or image matching the locator string.
+         * For buttons, the "value" attribute, "name" attribute, and inner text are searched. For links, the link text is searched.
+         * For images, the "alt" attribute and inner text of any parent links are searched.
+         *
+         * The second parameter is a context (CSS or XPath locator) to narrow the search.
+         *
+         * ```js
+         * // simple link
+         * I.forceClick('Logout');
+         * // button of form
+         * I.forceClick('Submit');
+         * // CSS button
+         * I.forceClick('#form input[type=submit]');
+         * // XPath
+         * I.forceClick('//form/*[@type=submit]');
+         * // link in context
+         * I.forceClick('Logout', '#nav');
+         * // using strict locator
+         * I.forceClick({css: 'nav a.login'});
+         * ```
+         *
+         * @param {CodeceptJS.LocatorOrString} locator clickable link or button located by text, or any element located by CSS|XPath|strict locator.
+         * @param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element to search in CSS|XPath|Strict locator.
+         *
+         *
+         * {{ react }}
+         */
+        forceClick(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString): void;
         /**
          * Performs a double-click on an element matched by link|button|label|CSS or XPath.
          * Context can be specified as second parameter to narrow search.
@@ -6438,19 +7972,27 @@ declare namespace CodeceptJS {
          */
         saveScreenshot(fileName: string, fullPage?: boolean): void;
         /**
-         * Sets a cookie.
+         * Sets cookie(s).
+         *
+         * Can be a single cookie object or an array of cookies:
          *
          * ```js
          * I.setCookie({name: 'auth', value: true});
+         *
+         * // as array
+         * I.setCookie([
+         *   {name: 'auth', value: true},
+         *   {name: 'agree', value: true}
+         * ]);
          * ```
          *
-         * @param {object} cookie a cookie object.
+         * @param {object|array} cookie a cookie object or array of cookie objects.
          *
          *
          * Uses Selenium's JSON [cookie
          * format](https://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object).
          */
-        setCookie(cookie: any): void;
+        setCookie(cookie: any | any[]): void;
         /**
          * Clears a cookie by name,
          * if none provided clears all cookies.
@@ -6623,6 +8165,22 @@ declare namespace CodeceptJS {
          * _Note:_ In case a text field or textarea is focused be aware that some browsers do not respect active modifier when combining modifier keys with other keys.
          */
         pressKey(key: string | string[]): void;
+        /**
+         *
+         * Types out the given string or the array of keys provided.
+         * _Note:_ Should only be used when using [`fillField`](#fillfield) is not an option.
+         *
+         * ```js
+         * // When passing in a string
+         * I.type('Type this out.');
+         * // When passing in an array
+         * I.type(['T', 'E', 'X', 'T']);
+         * ```
+         *
+         * @param {string|string[]} key or array of keys to type.
+         * Type out given array of keys or a string of text
+         */
+        type(key: string | string[]): void;
         /**
          * Resize the current window to provided width and height.
          * First parameter can be set to `maximize`.
@@ -8430,9 +9988,9 @@ declare namespace CodeceptJS {
          * Get Mocha instance
          *
          * @api
-         * @returns {Mocha | {}}
+         * @returns { * }
          */
-        static mocha(): Mocha | any;
+        static mocha(): any;
         /**
          * Append new services to container
          *
@@ -8496,6 +10054,7 @@ declare namespace CodeceptJS {
          * @property {'test.passed'} passed
          * @property {'test.failed'} failed
          * @property {'test.finish'} finished
+         * @property {'test.skipped'} skipped
          */
         const test: {
             started: 'test.start';
@@ -8504,6 +10063,7 @@ declare namespace CodeceptJS {
             passed: 'test.passed';
             failed: 'test.failed';
             finished: 'test.finish';
+            skipped: 'test.skipped';
         };
         /**
          * @type {object}