expect-webdriverio 4.2.8 → 4.4.0

package/lib/matchers/element/toHaveComputedLabel.js

@@ -0,0 +1,26 @@
+import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+async function condition(el, label, options) {
+    const actualLabel = await el.getComputedLabel();
+    if (Array.isArray(label)) {
+        return compareTextWithArray(actualLabel, label, options);
+    }
+    return compareText(actualLabel, label, options);
+}
+export async function toHaveComputedLabel(received, label, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'computed label', verb = 'have' } = this;
+    let el = await received;
+    let actualLabel;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, condition, options, [label, options]);
+        el = result.el;
+        actualLabel = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualLabel, label), actualLabel, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message,
+    };
+}

package/lib/matchers/element/toHaveComputedLabelContaining.js

@@ -0,0 +1,7 @@
+import { toHaveComputedLabel } from './toHaveComputedLabel.js';
+export function toHaveComputedLabelContaining(el, label, options = {}) {
+    return toHaveComputedLabel.call(this, el, label, {
+        ...options,
+        containing: true
+    });
+}

package/lib/matchers/element/toHaveComputedRole.js

@@ -0,0 +1,26 @@
+import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+async function condition(el, role, options) {
+    const actualRole = await el.getComputedRole();
+    if (Array.isArray(role)) {
+        return compareTextWithArray(actualRole, role, options);
+    }
+    return compareText(actualRole, role, options);
+}
+export async function toHaveComputedRole(received, role, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'computed role', verb = 'have' } = this;
+    let el = await received;
+    let actualRole;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, condition, options, [role, options]);
+        el = result.el;
+        actualRole = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualRole, role), actualRole, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message,
+    };
+}

package/lib/matchers/element/toHaveComputedRoleContaining.js

@@ -0,0 +1,7 @@
+import { toHaveComputedRole } from './toHaveComputedRole.js';
+export function toHaveComputedRoleContaining(el, role, options = {}) {
+    return toHaveComputedRole.call(this, el, role, {
+        ...options,
+        containing: true
+    });
+}

package/lib/matchers/element/toHaveHTML.js

@@ -0,0 +1,26 @@
+import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+async function condition(el, html, options) {
+    const actualHTML = await el.getHTML(options.includeSelectorTag);
+    if (Array.isArray(html)) {
+        return compareTextWithArray(actualHTML, html, options);
+    }
+    return compareText(actualHTML, html, options);
+}
+export async function toHaveHTML(received, html, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'HTML', verb = 'have' } = this;
+    let el = await received;
+    let actualHTML;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, condition, options, [html, options]);
+        el = result.el;
+        actualHTML = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualHTML, html), actualHTML, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message
+    };
+}

package/lib/matchers/element/toHaveHTMLContaining.js

@@ -0,0 +1,7 @@
+import { toHaveHTML } from './toHaveHTML.js';
+export function toHaveHTMLContaining(el, html, options = {}) {
+    return toHaveHTML.call(this, el, html, {
+        ...options,
+        containing: true
+    });
+}

package/lib/matchers/element/toHaveHeight.js

@@ -0,0 +1,26 @@
+import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+async function condition(el, height) {
+    const actualHeight = await el.getSize('height');
+    return {
+        value: actualHeight,
+        result: actualHeight === height,
+    };
+}
+export async function toHaveHeight(received, height, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'height', verb = 'have' } = this;
+    let el = await received;
+    let actualHeight;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, condition, options, [height, options]);
+        el = result.el;
+        actualHeight = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualHeight, height), actualHeight, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message,
+    };
+}

package/lib/matchers/element/toHaveSize.js

@@ -0,0 +1,23 @@
+import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, compareObject, } from '../../utils.js';
+async function condition(el, size) {
+    const actualSize = await el.getSize();
+    return compareObject(actualSize, size);
+}
+export async function toHaveSize(received, size, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'size', verb = 'have' } = this;
+    let el = await received;
+    let actualSize;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, condition, options, [size, options]);
+        el = result.el;
+        actualSize = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualSize, size), actualSize, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message,
+    };
+}

package/lib/matchers/element/toHaveWidth.js

@@ -0,0 +1,26 @@
+import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+async function condition(el, width) {
+    const actualWidth = await el.getSize('width');
+    return {
+        value: actualWidth,
+        result: actualWidth === width,
+    };
+}
+export async function toHaveWidth(received, width, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'width', verb = 'have' } = this;
+    let el = await received;
+    let actualWidth;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, condition, options, [width, options]);
+        el = result.el;
+        actualWidth = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualWidth, width), actualWidth, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message,
+    };
+}

package/lib/utils.js

@@ -1,3 +1,4 @@
+import isEqual from 'lodash.isequal';
 import { executeCommand } from './util/executeCommand.js';
 import { wrapExpectedWithArray, updateElementsArray } from './util/elementsUtil.js';
 import { enhanceError, enhanceErrorBe, numberError } from './util/formatMessage.js';
@@ -67,7 +68,7 @@ const compareNumbers = (actual, options = {}) => {
     }
     return false;
 };
-export const compareText = (actual, expected, { ignoreCase = false, trim = true, containing = false }) => {
+export const compareText = (actual, expected, { ignoreCase = false, trim = true, containing = false, atStart = false, atEnd = false, atIndex, replace }) => {
     if (typeof actual !== 'string') {
         return {
             value: actual,
@@ -77,6 +78,9 @@ export const compareText = (actual, expected, { ignoreCase = false, trim = true,
     if (trim) {
         actual = actual.trim();
     }
+    if (Array.isArray(replace)) {
+        actual = replaceActual(replace, actual);
+    }
     if (ignoreCase) {
         actual = actual.toLowerCase();
         if (!(expected instanceof RegExp)) {
@@ -95,12 +99,30 @@ export const compareText = (actual, expected, { ignoreCase = false, trim = true,
             result: actual.includes(expected)
         };
     }
+    if (atStart) {
+        return {
+            value: actual,
+            result: actual.startsWith(expected)
+        };
+    }
+    if (atEnd) {
+        return {
+            value: actual,
+            result: actual.endsWith(expected)
+        };
+    }
+    if (atIndex) {
+        return {
+            value: actual,
+            result: actual.substring(atIndex, actual.length).startsWith(expected)
+        };
+    }
     return {
         value: actual,
         result: actual === expected
     };
 };
-export const compareTextWithArray = (actual, expectedArray, { ignoreCase = false, trim = false, containing = false }) => {
+export const compareTextWithArray = (actual, expectedArray, { ignoreCase = false, trim = false, containing = false, atStart = false, atEnd = false, atIndex, replace }) => {
     if (typeof actual !== 'string') {
         return {
             value: actual,
@@ -110,18 +132,48 @@ export const compareTextWithArray = (actual, expectedArray, { ignoreCase = false
     if (trim) {
         actual = actual.trim();
     }
+    if (Array.isArray(replace)) {
+        actual = replaceActual(replace, actual);
+    }
     if (ignoreCase) {
         actual = actual.toLowerCase();
         expectedArray = expectedArray.map(item => (item instanceof RegExp) ? item : item.toLowerCase());
     }
     const textInArray = expectedArray.some((expected) => {
-        return expected instanceof RegExp ? !!actual.match(expected) : containing ? actual.includes(expected) : actual === expected;
+        if (expected instanceof RegExp) {
+            return !!actual.match(expected);
+        }
+        if (containing) {
+            return actual.includes(expected);
+        }
+        if (atStart) {
+            return actual.startsWith(expected);
+        }
+        if (atEnd) {
+            return actual.endsWith(expected);
+        }
+        if (atIndex) {
+            return actual.substring(atIndex, actual.length).startsWith(expected);
+        }
+        return actual === expected;
     });
     return {
         value: actual,
         result: textInArray
     };
 };
+export const compareObject = (actual, expected) => {
+    if (typeof actual !== 'object' || Array.isArray(actual)) {
+        return {
+            value: actual,
+            result: false
+        };
+    }
+    return {
+        value: actual,
+        result: isEqual(actual, expected)
+    };
+};
 export const compareStyle = async (actualEl, style, { ignoreCase = true, trim = false }) => {
     let result = true;
     const actual = {};
@@ -151,3 +203,17 @@ function aliasFn(fn, { verb, expectation } = {}, ...args) {
     return fn.apply(this, args);
 }
 export { updateElementsArray, wrapExpectedWithArray, enhanceError, numberError, executeCommand, executeCommandBe, waitUntil, compareNumbers, aliasFn };
+function replaceActual(replace, actual) {
+    const hasMultipleReplacers = replace.every(r => Array.isArray(r));
+    const replacers = hasMultipleReplacers
+        ? replace
+        : [replace];
+    if (replacers.some(r => Array.isArray(r) && r.length !== 2)) {
+        throw new Error('Replacers need to have a searchValue and a replaceValue');
+    }
+    for (const replacer of replacers) {
+        const [searchValue, replaceValue] = replacer;
+        actual = actual.replace(searchValue, replaceValue);
+    }
+    return actual;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "4.2.8",
+  "version": "4.4.0",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -60,6 +60,7 @@
   "devDependencies": {
     "@types/debug": "^4.1.8",
     "@types/jest": "^29.5.4",
+    "@types/lodash.isequal": "^4.5.6",
     "@types/node": "^20.6.0",
     "@typescript-eslint/eslint-plugin": "^6.7.0",
     "@typescript-eslint/parser": "^6.7.0",
@@ -75,7 +76,7 @@
     "rimraf": "^5.0.1",
     "shelljs": "^0.8.5",
     "typescript": "^5.2.2",
-    "vitest": "0.34.4",
+    "vitest": "0.34.5",
     "webdriverio": "^8.16.7"
   },
   "optionalDependencies": {
@@ -84,6 +85,7 @@
   },
   "dependencies": {
     "expect": "^29.7.0",
-    "jest-matcher-utils": "^29.7.0"
+    "jest-matcher-utils": "^29.7.0",
+    "lodash.isequal": "^4.5.0"
   }
 }

package/types/expect-webdriverio.d.ts

@@ -1,330 +1,469 @@
-declare namespace ExpectWebdriverIO {
-    function expect<T = unknown, R extends void | Promise<void> = void | Promise<void>>(actual: T): Matchers<R, T>
-    function setOptions(options: DefaultOptions): void
-    function getConfig(): any
-    const matchers: Record<string, ((actual: any, ...expected: any[]) => Promise<{
-        pass: boolean;
-        message(): string;
-    }>)>
-
-    interface DefaultOptions {
-        /**
-         * time in ms to wait for expectation to succeed. Default: 3000
-         */
-        wait?: number
-
-        /**
-         * interval between attempts. Default: 100
-         */
-        interval?: number
-    }
-
-    interface CommandOptions extends DefaultOptions {
-        /**
-         * user message to prepend before assertion error
-         */
-        message?: string
-    }
-
-    interface StringOptions extends CommandOptions {
-        /**
-         * apply `toLowerCase` to both actual and expected values
-         */
-        ignoreCase?: boolean
-
-        /**
-         * apply `trim` to actual value
-         */
-        trim?: boolean
-
-        /**
-         * expect actual value to contain expected value.
-         * Otherwise strict equal
-         */
-        containing?: boolean
-
-        /**
-         * might be helpful to force converting property value to string
-         */
-        asString?: boolean
-    }
-
-    interface NumberOptions extends CommandOptions {
-        /**
-         * equals
-         */
-        eq?: number
-        /**
-         * less than or equals
-         */
-        lte?: number
-
-        /**
-         * greater than or equals
-         */
-        gte?: number
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    interface Matchers<R, T> {
-        // ===== $ or $$ =====
-        /**
-         * `WebdriverIO.Element` -> `isDisplayed`
-         */
-        toBeDisplayed(options?: ExpectWebdriverIO.CommandOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `isExisting`
-         */
-        toExist(options?: ExpectWebdriverIO.CommandOptions): R
-        /**
-         * `WebdriverIO.Element` -> `isExisting`
-         */
-        toBePresent(options?: ExpectWebdriverIO.CommandOptions): R
-        /**
-         * `WebdriverIO.Element` -> `isExisting`
-         */
-        toBeExisting(options?: ExpectWebdriverIO.CommandOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getAttribute`
-         */
-        toHaveAttribute(attribute: string, value?: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-        /**
-         * `WebdriverIO.Element` -> `getAttribute`
-         */
-        toHaveAttr(attribute: string, value?: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getAttribute`
-         * Element's attribute includes the value.
-         */
-        toHaveAttributeContaining(
-            attribute: string,
-            contains: string | RegExp,
-            options?: ExpectWebdriverIO.StringOptions
-        ): R
-        /**
-         * `WebdriverIO.Element` -> `getAttribute`
-         * Element's attribute includes the value.
-         */
-        toHaveAttrContaining(
-            attribute: string,
-            contains: string | RegExp,
-            options?: ExpectWebdriverIO.StringOptions
-        ): R
-
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` class
-         * @deprecated since v1.3.1 - use `toHaveElementClass` instead.
-         */
-        toHaveClass(className: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` class
-         */
-        toHaveElementClass(className: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` class
-         * @deprecated since v1.3.1 - use `toHaveElementClassContaining` instead.
-         * Element's class includes the className.
-         */
-        toHaveClassContaining(className: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` class
-         * Element's class includes the className.
-         */
-        toHaveElementClassContaining(className: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getProperty`
-         */
-        toHaveElementProperty(property: string | RegExp, value?: any, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getProperty` value
-         */
-        toHaveValue(value: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-        /**
-         * `WebdriverIO.Element` -> `getProperty` value
-         * Element's value includes the value.
-         */
-        toHaveValueContaining(value: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `isClickable`
-         */
-        toBeClickable(options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `!isEnabled`
-         */
-        toBeDisabled(options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `isDisplayedInViewport`
-         */
-        toBeDisplayedInViewport(options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `isEnabled`
-         */
-        toBeEnabled(options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `isFocused`
-         */
-        toBeFocused(options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `isSelected`
-         */
-        toBeSelected(options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `isSelected`
-         */
-        toBeChecked(options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `$$('./*').length`
-         * supports less / greater then or equals to be passed in options
-         */
-        toHaveChildren(
-            size?: number | ExpectWebdriverIO.NumberOptions,
-            options?: ExpectWebdriverIO.NumberOptions
-        ): R
-
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` href
-         */
-        toHaveHref(href: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` href
-         */
-        toHaveLink(href: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` href
-         * Element's href includes the value provided
-         */
-        toHaveHrefContaining(href: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` href
-         * Element's href includes the value provided
-         */
-        toHaveLinkContaining(href: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getProperty` value
-         */
-        toHaveId(id: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getText`
-         */
-        toHaveText(text: string | RegExp | Array<string | RegExp>, options?: ExpectWebdriverIO.StringOptions): R
-        /**
-         * `WebdriverIO.Element` -> `getText`
-         * Element's text includes the text provided
-         */
-        toHaveTextContaining(text: string | RegExp | Array<string | RegExp>, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-        * `WebdriverIO.Element` -> `getAttribute("style")`
-        */
-        toHaveStyle(style: { [key: string]: string; }, options?: ExpectWebdriverIO.StringOptions): R
-
-        // ===== browser only =====
-        /**
-         * `WebdriverIO.Browser` -> `getUrl`
-         */
-        toHaveUrl(url: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        // ===== browser only =====
-        /**
-         * `WebdriverIO.Browser` -> `getUrl`
-         * Browser's url includes the provided text
-         */
-        toHaveUrlContaining(url: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Browser` -> `getTitle`
-         */
-        toHaveTitle(title: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        // ===== browser only =====
-        /**
-         * `WebdriverIO.Browser` -> `getTitle`
-         * Browser's title includes the provided text
-         */
-        toHaveTitleContaining(title: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
-
-        // ===== $$ only =====
-        /**
-         * `WebdriverIO.ElementArray` -> `$$('...').length`
-         * supports less / greater then or equals to be passed in options
-         */
-        toBeElementsArrayOfSize(
-            size: number | ExpectWebdriverIO.NumberOptions,
-            options?: ExpectWebdriverIO.NumberOptions
-        ): R
-
-        // ==== network mock ====
-
-        /**
-         * Check that `WebdriverIO.Mock` was called
-         */
-        toBeRequested(options?: ExpectWebdriverIO.CommandOptions): R
-
-        /**
-         * Check that `WebdriverIO.Mock` was called N times
-         */
-        toBeRequestedTimes(
-            times: number | ExpectWebdriverIO.NumberOptions,
-            options?: ExpectWebdriverIO.NumberOptions
-        ): R
-
-        /**
-         * Check that `WebdriverIO.Mock` was called with the specific parameters
-         */
-        toBeRequestedWith(requestedWith: RequestedWith, options?: ExpectWebdriverIO.CommandOptions): R
-    }
-
-    type RequestedWith = {
-        url?: string | ExpectWebdriverIO.PartialMatcher | ((url: string) => boolean)
-        method?: string | Array<string>
-        statusCode?: number | Array<number>
-        requestHeaders?:
-            | Record<string, string>
-            | ExpectWebdriverIO.PartialMatcher
-            | ((headers: Record<string, string>) => boolean)
-        responseHeaders?:
-            | Record<string, string>
-            | ExpectWebdriverIO.PartialMatcher
-            | ((headers: Record<string, string>) => boolean)
-        postData?:
-            | string
-            | ExpectWebdriverIO.JsonCompatible
-            | ExpectWebdriverIO.PartialMatcher
-            | ((r: string | undefined) => boolean)
-        response?:
-            | string
-            | ExpectWebdriverIO.JsonCompatible
-            | ExpectWebdriverIO.PartialMatcher
-            | ((r: string) => boolean)
-    }
-
-    type jsonPrimitive = string | number | boolean | null
-    type jsonObject = { [x: string]: jsonPrimitive | jsonObject | jsonArray }
-    type jsonArray = Array<jsonPrimitive | jsonObject | jsonArray>
-    type JsonCompatible = jsonObject | jsonArray
-
-    interface PartialMatcher {
-        sample?: any
-        asymmetricMatch?(...args: any[]): boolean
+type searchValue = string | RegExp
+type replaceValue = string | ((substring: string, ...args: any[]) => string)
+export type Replacer = [searchValue, replaceValue]
+
+declare global {
+    namespace ExpectWebdriverIO {
+        function expect<T = unknown, R extends void | Promise<void> = void | Promise<void>>(
+            actual: T
+        ): Matchers<R, T>
+        function setOptions(options: DefaultOptions): void
+        function getConfig(): any
+        const matchers: Record<
+            string,
+            (
+                actual: any,
+                ...expected: any[]
+            ) => Promise<{
+                pass: boolean
+                message(): string
+            }>
+        >
+
+        interface DefaultOptions {
+            /**
+             * time in ms to wait for expectation to succeed. Default: 3000
+             */
+            wait?: number
+
+            /**
+             * interval between attempts. Default: 100
+             */
+            interval?: number
+        }
+
+        interface CommandOptions extends DefaultOptions {
+            /**
+             * user message to prepend before assertion error
+             */
+            message?: string
+        }
+
+        interface HTMLOptions extends StringOptions {
+            /**
+             * return the HTML with the selector tag included
+             */
+            includeSelectorTag?: boolean
+        }
+
+        interface StringOptions extends CommandOptions {
+            /**
+             * apply `toLowerCase` to both actual and expected values
+             */
+            ignoreCase?: boolean
+
+            /**
+             * apply `trim` to actual value
+             */
+            trim?: boolean
+
+            /**
+             * expect actual value to contain expected value.
+             * Otherwise strict equal
+             */
+            containing?: boolean
+
+            /**
+             * expect actual value to start with the expected value
+             * Otherwise strict equal
+             */
+            atStart?: boolean
+
+            /**
+             * expect actual value to end with the expected value
+             * Otherwise strict equal
+             */
+            atEnd?: boolean
+
+            /**
+             * expect actual value to have the expected value at the given index (index starts at 0 not 1)
+             * Otherwise strict equal
+             */
+            atIndex?: number
+
+            /**
+             * replace the actual value (example: strip newlines from the value) and expect it to match the expected value
+             * Otherwise strict equal
+             */
+            replace?: Replacer | Replacer[]
+
+            /**
+             * might be helpful to force converting property value to string
+             */
+            asString?: boolean
+        }
+
+        interface NumberOptions extends CommandOptions {
+            /**
+             * equals
+             */
+            eq?: number
+            /**
+             * less than or equals
+             */
+            lte?: number
+
+            /**
+             * greater than or equals
+             */
+            gte?: number
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        interface Matchers<R, T> {
+            // ===== $ or $$ =====
+            /**
+             * `WebdriverIO.Element` -> `isDisplayed`
+             */
+            toBeDisplayed(options?: ExpectWebdriverIO.CommandOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `isExisting`
+             */
+            toExist(options?: ExpectWebdriverIO.CommandOptions): R
+            /**
+             * `WebdriverIO.Element` -> `isExisting`
+             */
+            toBePresent(options?: ExpectWebdriverIO.CommandOptions): R
+            /**
+             * `WebdriverIO.Element` -> `isExisting`
+             */
+            toBeExisting(options?: ExpectWebdriverIO.CommandOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `getAttribute`
+             */
+            toHaveAttribute(
+                attribute: string,
+                value?: string | RegExp,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+            /**
+             * `WebdriverIO.Element` -> `getAttribute`
+             */
+            toHaveAttr(
+                attribute: string,
+                value?: string | RegExp,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+
+            /**
+             * `WebdriverIO.Element` -> `getAttribute`
+             * Element's attribute includes the value.
+             */
+            toHaveAttributeContaining(
+                attribute: string,
+                contains: string | RegExp,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+            /**
+             * `WebdriverIO.Element` -> `getAttribute`
+             * Element's attribute includes the value.
+             */
+            toHaveAttrContaining(
+                attribute: string,
+                contains: string | RegExp,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+
+            /**
+             * `WebdriverIO.Element` -> `getAttribute` class
+             * @deprecated since v1.3.1 - use `toHaveElementClass` instead.
+             */
+            toHaveClass(className: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `getAttribute` class
+             */
+            toHaveElementClass(className: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `getAttribute` class
+             * @deprecated since v1.3.1 - use `toHaveElementClassContaining` instead.
+             * Element's class includes the className.
+             */
+            toHaveClassContaining(className: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `getAttribute` class
+             * Element's class includes the className.
+             */
+            toHaveElementClassContaining(
+                className: string | RegExp,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+
+            /**
+             * `WebdriverIO.Element` -> `getProperty`
+             */
+            toHaveElementProperty(
+                property: string | RegExp,
+                value?: any,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+
+            /**
+             * `WebdriverIO.Element` -> `getProperty` value
+             */
+            toHaveValue(value: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+            /**
+             * `WebdriverIO.Element` -> `getProperty` value
+             * Element's value includes the value.
+             */
+            toHaveValueContaining(value: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `isClickable`
+             */
+            toBeClickable(options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `!isEnabled`
+             */
+            toBeDisabled(options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `isDisplayedInViewport`
+             */
+            toBeDisplayedInViewport(options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `isEnabled`
+             */
+            toBeEnabled(options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `isFocused`
+             */
+            toBeFocused(options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `isSelected`
+             */
+            toBeSelected(options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `isSelected`
+             */
+            toBeChecked(options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `$$('./*').length`
+             * supports less / greater then or equals to be passed in options
+             */
+            toHaveChildren(
+                size?: number | ExpectWebdriverIO.NumberOptions,
+                options?: ExpectWebdriverIO.NumberOptions
+            ): R
+
+            /**
+             * `WebdriverIO.Element` -> `getAttribute` href
+             */
+            toHaveHref(href: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+            /**
+             * `WebdriverIO.Element` -> `getAttribute` href
+             */
+            toHaveLink(href: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `getAttribute` href
+             * Element's href includes the value provided
+             */
+            toHaveHrefContaining(href: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+            /**
+             * `WebdriverIO.Element` -> `getAttribute` href
+             * Element's href includes the value provided
+             */
+            toHaveLinkContaining(href: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `getProperty` value
+             */
+            toHaveId(id: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `getText`
+             * Element's text equals the text provided
+             */
+            toHaveText(
+                text: string | RegExp | Array<string | RegExp>,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+            /**
+             * `WebdriverIO.Element` -> `getText`
+             * Element's text includes the text provided
+             */
+            toHaveTextContaining(
+                text: string | RegExp | Array<string | RegExp>,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+
+            /**
+             * `WebdriverIO.Element` -> `getHTML`
+             * Element's html equals the html provided
+             */
+            toHaveHTML(
+                html: string | RegExp | Array<string | RegExp>,
+                options?: ExpectWebdriverIO.HTMLOptions
+            ): R
+            /**
+             * `WebdriverIO.Element` -> `getHTML`
+             * Element's html includes the html provided
+             */
+            toHaveHTMLContaining(
+                html: string | RegExp | Array<string | RegExp>,
+                options?: ExpectWebdriverIO.HTMLOptions
+            ): R
+
+            /**
+             * `WebdriverIO.Element` -> `getComputedLabel`
+             * Element's computed label equals the computed label provided
+             */
+            toHaveComputedLabel(
+                computedLabel: string | RegExp | Array<string | RegExp>,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+            /**
+             * `WebdriverIO.Element` -> `getComputedLabel`
+             * Element's computed label includes the computed label provided
+             */
+            toHaveComputedLabelContaining(
+                computedLabel: string | RegExp | Array<string | RegExp>,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+
+            /**
+             * `WebdriverIO.Element` -> `getComputedRole`
+             * Element's computed role equals the computed role provided
+             */
+            toHaveComputedRole(
+                computedRole: string | RegExp | Array<string | RegExp>,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+            /**
+             * `WebdriverIO.Element` -> `getComputedRole`
+             * Element's computed role includes the computed role provided
+             */
+            toHaveComputedRoleContaining(
+                computedRole: string | RegExp | Array<string | RegExp>,
+                options?: ExpectWebdriverIO.StringOptions
+            ): R
+
+            /**
+             * `WebdriverIO.Element` -> `getSize('width')`
+             * Element's width equals the width provided
+             */
+            toHaveWidth(width: number, options?: ExpectWebdriverIO.CommandOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `getSize('height')`
+             * Element's height equals the height provided
+             */
+            toHaveHeight(height: number, options?: ExpectWebdriverIO.CommandOptions): R
+
+            /**
+             * `WebdriverIO.Element` -> `getSize()`
+             * Element's size equals the size provided
+             */
+            toHaveHeight(
+                size: { height: number; width: number },
+                options?: ExpectWebdriverIO.CommandOptions
+            ): R
+
+            /**
+             * `WebdriverIO.Element` -> `getAttribute("style")`
+             */
+            toHaveStyle(style: { [key: string]: string }, options?: ExpectWebdriverIO.StringOptions): R
+
+            // ===== browser only =====
+            /**
+             * `WebdriverIO.Browser` -> `getUrl`
+             */
+            toHaveUrl(url: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            // ===== browser only =====
+            /**
+             * `WebdriverIO.Browser` -> `getUrl`
+             * Browser's url includes the provided text
+             */
+            toHaveUrlContaining(url: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            /**
+             * `WebdriverIO.Browser` -> `getTitle`
+             */
+            toHaveTitle(title: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            // ===== browser only =====
+            /**
+             * `WebdriverIO.Browser` -> `getTitle`
+             * Browser's title includes the provided text
+             */
+            toHaveTitleContaining(title: string | RegExp, options?: ExpectWebdriverIO.StringOptions): R
+
+            // ===== $$ only =====
+            /**
+             * `WebdriverIO.ElementArray` -> `$$('...').length`
+             * supports less / greater then or equals to be passed in options
+             */
+            toBeElementsArrayOfSize(
+                size: number | ExpectWebdriverIO.NumberOptions,
+                options?: ExpectWebdriverIO.NumberOptions
+            ): R
+
+            // ==== network mock ====
+
+            /**
+             * Check that `WebdriverIO.Mock` was called
+             */
+            toBeRequested(options?: ExpectWebdriverIO.CommandOptions): R
+
+            /**
+             * Check that `WebdriverIO.Mock` was called N times
+             */
+            toBeRequestedTimes(
+                times: number | ExpectWebdriverIO.NumberOptions,
+                options?: ExpectWebdriverIO.NumberOptions
+            ): R
+
+            /**
+             * Check that `WebdriverIO.Mock` was called with the specific parameters
+             */
+            toBeRequestedWith(requestedWith: RequestedWith, options?: ExpectWebdriverIO.CommandOptions): R
+        }
+
+        type RequestedWith = {
+            url?: string | ExpectWebdriverIO.PartialMatcher | ((url: string) => boolean)
+            method?: string | Array<string>
+            statusCode?: number | Array<number>
+            requestHeaders?:
+                | Record<string, string>
+                | ExpectWebdriverIO.PartialMatcher
+                | ((headers: Record<string, string>) => boolean)
+            responseHeaders?:
+                | Record<string, string>
+                | ExpectWebdriverIO.PartialMatcher
+                | ((headers: Record<string, string>) => boolean)
+            postData?:
+                | string
+                | ExpectWebdriverIO.JsonCompatible
+                | ExpectWebdriverIO.PartialMatcher
+                | ((r: string | undefined) => boolean)
+            response?:
+                | string
+                | ExpectWebdriverIO.JsonCompatible
+                | ExpectWebdriverIO.PartialMatcher
+                | ((r: string) => boolean)
+        }
+
+        type jsonPrimitive = string | number | boolean | null
+        type jsonObject = { [x: string]: jsonPrimitive | jsonObject | jsonArray }
+        type jsonArray = Array<jsonPrimitive | jsonObject | jsonArray>
+        type JsonCompatible = jsonObject | jsonArray
+
+        interface PartialMatcher {
+            sample?: any
+            asymmetricMatch?(...args: any[]): boolean
+        }
     }
 }