expect-webdriverio 5.4.3 → 5.6.0

package/types/expect-webdriverio.d.ts

@@ -4,15 +4,527 @@ type Test = import('@wdio/types').Frameworks.Test
 type TestResult = import('@wdio/types').Frameworks.TestResult
 type PickleStep = import('@wdio/types').Frameworks.PickleStep
 type Scenario = import('@wdio/types').Frameworks.Scenario
+
 type SnapshotResult = import('@vitest/snapshot').SnapshotResult
 type SnapshotUpdateState = import('@vitest/snapshot').SnapshotUpdateState
 
+type ChainablePromiseElement = import('webdriverio').ChainablePromiseElement
+type ChainablePromiseArray = import('webdriverio').ChainablePromiseArray
+
+type ExpectLibAsymmetricMatchers = import('expect').AsymmetricMatchers
+type ExpectLibAsymmetricMatcher<T> = import('expect').AsymmetricMatcher<T>
+type ExpectLibMatchers<R extends void | Promise<void>, T> = import('expect').Matchers<R, T>
+type ExpectLibExpect = import('expect').Expect
+type ExpectLibInverse<Matchers> = import('expect').Inverse<Matchers>
+type ExpectLibSyncExpectationResult = import('expect').SyncExpectationResult
+type ExpectLibAsyncExpectationResult = import('expect').AsyncExpectationResult
+type ExpectLibExpectationResult = import('expect').ExpectationResult
+type ExpectLibMatcherContext = import('expect').MatcherContext
+
+// Extracted from the expect library, this is the type of the matcher function used in the expect library.
+type RawMatcherFn<Context extends ExpectLibMatcherContext = ExpectLibMatcherContext> = {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (this: Context, actual: any, ...expected: Array<any>): ExpectLibExpectationResult;
+}
+
+/**
+ * Real Promise and wdio chainable promise types.
+ */
+type WdioPromiseLike<T = unknown> = PromiseLike<T> | ChainablePromiseElement | ChainablePromiseArray
+type ElementPromise = Promise<WebdriverIO.Element>
+type ElementArrayPromise = Promise<WebdriverIO.ElementArray>
+
+/**
+ * Only Wdio real promise
+ */
+type WdioOnlyPromiseLike = ElementPromise | ElementArrayPromise | ChainablePromiseElement | ChainablePromiseArray
+
+/**
+ * Only wdio real promise or potential promise usage on element or element array or browser
+ */
+type WdioOnlyMaybePromiseLike = ElementPromise | ElementArrayPromise | ChainablePromiseElement | ChainablePromiseArray | WebdriverIO.Browser | WebdriverIO.Element | WebdriverIO.ElementArray
+
+/**
+ * Note we are defining Matchers outside of the namespace as done in jest library until we can make every typing work correctly.
+ * Once we have all types working, we could check to bring those back into the `ExpectWebdriverIO` namespace.
+ */
+
+/**
+ * Type helpers to be able to targets specific types mostly used in conjunctions with the Type of the `actual` parameter of the `expect`
+ */
+type ElementOrArrayLike = ElementLike | ElementArrayLike
+type ElementLike = WebdriverIO.Element | ChainablePromiseElement
+type ElementArrayLike = WebdriverIO.ElementArray | ChainablePromiseArray
+type MockPromise = Promise<WebdriverIO.Mock>
+
+/**
+ * Type helpers allowing to use the function when the expect(actual: T) is of the expected type T.
+ */
+type FnWhenBrowser<ActualT, Fn> = ActualT extends WebdriverIO.Browser ? Fn : never
+type FnWhenElementOrArrayLike<ActualT, Fn> = ActualT extends ElementOrArrayLike ? Fn : never
+type FnWhenElementArrayLike<ActualT, Fn> = ActualT extends ElementArrayLike ? Fn : never
+
+/**
+ * Same as the other but because of Jasmine and it's expectAsync typing which does not force T to be a promise, then we need to account for `WebdriverIO.Mock
+ */
+type FnWhenMock<ActualT, Fn> = ActualT extends MockPromise | WebdriverIO.Mock ? Fn : never
+
+/**
+ * Matchers dedicated to Wdio Browser.
+ * When asserting on a browser's properties requiring to be awaited, the return type is a Promise.
+ * When actual is not a browser, the return type is never, so the function cannot be used.
+ */
+interface WdioBrowserMatchers<_R, ActualT>{
+    /**
+     * `WebdriverIO.Browser` -> `getUrl`
+     */
+    toHaveUrl: FnWhenBrowser<ActualT, (url: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>, options?: ExpectWebdriverIO.StringOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Browser` -> `getTitle`
+     */
+    toHaveTitle: FnWhenBrowser<ActualT, (title: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>, options?: ExpectWebdriverIO.StringOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Browser` -> `execute`
+     */
+    toHaveClipboardText: FnWhenBrowser<ActualT, (clipboardText: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>, options?: ExpectWebdriverIO.StringOptions) => Promise<void>>
+}
+
+/**
+ * Matchers dedicated to Network Mocking.
+ * When asserting we wait for the result with `await waitUntil()`, therefore the return type needs to be a Promise.
+ * When actual is not a WebdriverIO.Mock, the return type is never, so the function cannot be used.
+ */
+interface WdioNetworkMatchers<_R, ActualT> {
+    /**
+     * Check that `WebdriverIO.Mock` was called
+     */
+    toBeRequested: FnWhenMock<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+    /**
+     * Check that `WebdriverIO.Mock` was called N times
+     */
+    toBeRequestedTimes: FnWhenMock<ActualT, (times: number | ExpectWebdriverIO.NumberOptions, options?: ExpectWebdriverIO.NumberOptions) => Promise<void>>
+
+    /**
+     * Check that `WebdriverIO.Mock` was called with the specific parameters
+     */
+    toBeRequestedWith: FnWhenMock<ActualT, (requestedWith: ExpectWebdriverIO.RequestedWith, options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+}
+
+/**
+ * Matchers dedicated to WebdriverIO Element or ElementArray (or chainable).
+ * When asserting on an element or element array's properties requiring to be awaited, the return type is a Promise.
+ * When actual is neither of WebdriverIO.Element, WebdriverIO.ElementArray, ChainableElement, ChainableElementArray, the return type is never, so the function cannot be used.
+ */
+interface WdioElementOrArrayMatchers<_R, ActualT = unknown> {
+    // ===== $ or $$ =====
+    /**
+     * `WebdriverIO.Element` -> `isDisplayed`
+     */
+    toBeDisplayed: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `isExisting`
+     */
+    toExist: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `isExisting`
+     */
+    toBePresent: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `isExisting`
+     */
+    toBeExisting: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getAttribute`
+     */
+    toHaveAttribute: FnWhenElementOrArrayLike<ActualT, (
+        attribute: string, value?: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>,
+        options?: ExpectWebdriverIO.StringOptions)
+    => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getAttribute`
+     */
+    toHaveAttr: FnWhenElementOrArrayLike<ActualT, (
+        attribute: string, value?: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getAttribute` class
+     * @deprecated since v1.3.1 - use `toHaveElementClass` instead.
+     */
+    toHaveClass: FnWhenElementOrArrayLike<ActualT, (
+        className: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getAttribute` class
+     *
+     * Checks if an element has the specified class or matches any of the provided class patterns.
+     * @param className - The class name(s) or pattern(s) to match against.
+     * @param options - Optional settings that can be passed to the function.
+     *
+     * **Usage**
+     * ```js
+     * // Check if an element has the class 'btn'
+     * await expect(element).toHaveElementClass('btn');
+     *
+     * // Check if an element has any of the specified classes
+     * await expect(element).toHaveElementClass(['btn', 'btn-large']);
+     * ```
+     */
+    toHaveElementClass: FnWhenElementOrArrayLike<ActualT, (
+        className: string | RegExp | Array<string | RegExp> | ExpectWebdriverIO.PartialMatcher<string>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getProperty`
+     */
+    toHaveElementProperty: FnWhenElementOrArrayLike<ActualT, (
+        property: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>,
+        value?: unknown,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getProperty` value
+     */
+    toHaveValue: FnWhenElementOrArrayLike<ActualT, (
+        value: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `isClickable`
+     */
+    toBeClickable: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `!isEnabled`
+     */
+    toBeDisabled: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `isDisplayedInViewport`
+     */
+    toBeDisplayedInViewport: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `isEnabled`
+     */
+    toBeEnabled: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `isFocused`
+     */
+    toBeFocused: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `isSelected`
+     */
+    toBeSelected: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `isSelected`
+     */
+    toBeChecked: FnWhenElementOrArrayLike<ActualT, (options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `$$('./*').length`
+     * supports less / greater then or equals to be passed in options
+     */
+    toHaveChildren: FnWhenElementOrArrayLike<ActualT, (
+        size?: number | ExpectWebdriverIO.NumberOptions,
+        options?: ExpectWebdriverIO.NumberOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getAttribute` href
+     */
+    toHaveHref: FnWhenElementOrArrayLike<ActualT, (
+        href: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getAttribute` href
+     */
+    toHaveLink: FnWhenElementOrArrayLike<ActualT, (
+        href: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getProperty` value
+     */
+    toHaveId: FnWhenElementOrArrayLike<ActualT, (
+        id: string | RegExp | ExpectWebdriverIO.PartialMatcher<string>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getSize` value
+     */
+    toHaveSize: FnWhenElementOrArrayLike<ActualT, (
+        size: { height: number; width: number },
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getText`
+     * Element's text equals the text provided
+     *
+     * @param text - The expected text to match.
+     * @param options - Optional settings that can be passed to the function.
+     *
+     * **Usage**
+     *
+     * ```js
+     * // Check if an element has the text
+     * const elem = await $('.container')
+     * await expect(elem).toHaveText('Next-gen browser and mobile automation test framework for Node.js')
+     *
+     * // Check if an element array contains the specified text
+     * const elem = await $$('ul > li')
+     * await expect(elem).toHaveText(['Coffee', 'Tea', 'Milk'])
+     * ```
+     */
+    toHaveText: FnWhenElementOrArrayLike<ActualT, (
+        text: string | RegExp | ExpectWebdriverIO.PartialMatcher<string> | Array<string | RegExp | ExpectWebdriverIO.PartialMatcher<string>>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getHTML`
+     * Element's html equals the html provided
+     */
+    toHaveHTML: FnWhenElementOrArrayLike<ActualT, (
+        html: string | RegExp | ExpectWebdriverIO.PartialMatcher<string> | Array<string | RegExp>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getComputedLabel`
+     * Element's computed label equals the computed label provided
+     */
+    toHaveComputedLabel: FnWhenElementOrArrayLike<ActualT, (
+        computedLabel: string | RegExp | ExpectWebdriverIO.PartialMatcher<string> | Array<string | RegExp>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getComputedRole`
+     * Element's computed role equals the computed role provided
+     */
+    toHaveComputedRole: FnWhenElementOrArrayLike<ActualT, (
+        computedRole: string | RegExp | ExpectWebdriverIO.PartialMatcher<string> | Array<string | RegExp>,
+        options?: ExpectWebdriverIO.StringOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getSize('width')`
+     * Element's width equals the width provided
+     */
+    toHaveWidth: FnWhenElementOrArrayLike<ActualT, (width: number, options?: ExpectWebdriverIO.CommandOptions) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getSize('height')` or `getSize()`
+     * Checks if the element's height equals the given number, or its size equals the given object.
+     *
+     * @param heightOrSize - Either a number (height) or an object with height and width.
+     * @param options - Optional command options.
+     *
+     * **Usage Example:**
+     * ```js
+     * await expect(element).toHaveHeight(42)
+     * await expect(element).toHaveHeight({ height: 42, width: 42 })
+     * ```
+     */
+    toHaveHeight: FnWhenElementOrArrayLike<ActualT, (
+        heightOrSize: number | { height: number; width: number },
+        options?: ExpectWebdriverIO.CommandOptions
+    ) => Promise<void>>
+
+    /**
+     * `WebdriverIO.Element` -> `getAttribute("style")`
+     */
+    toHaveStyle: FnWhenElementOrArrayLike<ActualT, (style: { [key: string]: string }, options?: ExpectWebdriverIO.StringOptions) => Promise<void>>
+}
+
+/**
+ * Matchers dedicated to WebdriverIO ElementArray (or its chainable).
+ * When asserting on each element's properties requiring awaiting, then return type is a Promise.
+ * When actual is not of WebdriverIO.ElementArray nor ChainableElementArray, the return type is never, so the function cannot be used.
+ */
+interface WdioElementArrayOnlyMatchers<_R, ActualT = unknown> {
+    // ===== $$ only =====
+    /**
+     * `WebdriverIO.ElementArray` -> `$$('...').length`
+     * supports less / greater then or equals to be passed in options
+     */
+    toBeElementsArrayOfSize: FnWhenElementArrayLike<ActualT, (
+        size: number | ExpectWebdriverIO.NumberOptions,
+        options?: ExpectWebdriverIO.NumberOptions
+    ) => Promise<void> & Promise<WebdriverIO.ElementArray>>
+}
+
+/**
+ * Matchers supporting basic snapshot tests as well as DOM snapshot testing.
+ * When the actual is a WebdriverIO.Element, we need to await the `outerHTML` therefore the return type is a Promise.
+ *
+ * ⚠️ these matchers overload the similar matchers from jest-expect library.
+ * Therefore, they also need to be redefined in the jest.d.ts file so correctly overload the matchers from the Jest namespace.
+ * @see jest.d.ts
+ */
+interface WdioJestOverloadedMatchers<_R, ActualT> {
+    /**
+     * snapshot matcher
+     * @param label optional snapshot label
+     */
+    toMatchSnapshot(label?: string): ActualT extends WdioPromiseLike ? Promise<void> : void;
+    /**
+     * inline snapshot matcher
+     * @param snapshot snapshot string (autogenerated if not specified)
+     * @param label optional snapshot label
+     */
+    toMatchInlineSnapshot(snapshot?: string, label?: string): ActualT extends WdioPromiseLike ? Promise<void> : void;
+}
+
+/**
+ * All the specific WebDriverIO only matchers, excluding the generic matchers from the expect library.
+ */
+type WdioCustomMatchers<R, ActualT> = WdioJestOverloadedMatchers<R, ActualT> & WdioBrowserMatchers<R, ActualT> & WdioElementOrArrayMatchers<R, ActualT> & WdioElementArrayOnlyMatchers<R, ActualT> & WdioNetworkMatchers<R, ActualT>
+
+/**
+ * All the matchers that WebdriverIO Library supports including the generic matchers from the expect library.
+ */
+type WdioMatchers<R extends void | Promise<void>, ActualT> = WdioCustomMatchers<R, ActualT> & ExpectLibMatchers<R, ActualT>
+
+/**
+ * Expects specific to WebdriverIO, excluding the generic expect matchers.
+ */
+interface WdioCustomExpect {
+    /**
+     * Creates a soft assertion wrapper around standard expect
+     * Soft assertions record failures but don't throw errors immediately
+     * All failures are collected and reported at the end of the test
+     * Note: Until fixed, soft only support wdio custom matchers, and not the `expect` library matchers. Moreover, it always returns a Promise.
+     */
+    soft<T = unknown>(actual: T): T extends PromiseLike<unknown> ? ExpectWebdriverIO.MatchersAndInverse<Promise<void>, T> & ExpectWebdriverIO.PromiseMatchers<T> : ExpectWebdriverIO.MatchersAndInverse<void, T>;
+
+    /**
+     * Get all current soft assertion failures
+     */
+    getSoftFailures(testId?: string): ExpectWebdriverIO.SoftFailure[]
+
+    /**
+     * Manually assert all soft failures (throws an error if any failures exist)
+     */
+    assertSoftFailures(testId?: string): void
+
+    /**
+     * Clear all current soft assertion failures
+     */
+    clearSoftFailures(testId?: string): void
+}
+
+/**
+ * Expects supported by the expect-webdriverio library, including the generic expect matchers.
+ */
+type WdioExpect = WdioCustomExpect & ExpectLibExpect
+
+/**
+ * Asymmetric matchers supported by the expect-webdriverio library.
+ * The type is the same as the one from the expect library, but we need to redefine it to have it available in the `ExpectWebdriverIO` namespace.
+ */
+type WdioAsymmetricMatchers = ExpectLibAsymmetricMatchers
+
+/**
+ * Implementation of the asymmetric matcher. Equivalent as the PartialMatcher but with sample used by implementations.
+ * For the runtime but not the typing.
+ */
+type WdioAsymmetricMatcher<R> = ExpectWebdriverIO.PartialMatcher<R> & {
+    // Overwrite protected properties of expect.AsymmetricMatcher to access them
+    sample: R;
+}
+
 declare namespace ExpectWebdriverIO {
+    /**
+     * When importing expect from 'expect-webdriverio', instead of using globals this is the one used.
+     * Note: Using a const instead of a function, else we cannot use asymmetric matcher like expect.anything().
+     */
     const expect: ExpectWebdriverIO.Expect
+
+    /**
+     * Used by the webdriverio main project to configure the matchers in the runner.
+     */
     function setOptions(options: DefaultOptions): void
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     function getConfig(): any
 
+    /**
+     * The below block are overloaded types from the expect library.
+     * They are required to show "everything" under the `ExpectWebdriverIO` namespace.
+     * They are also required to be be able to declare custom asymmetric/normal matchers under the `ExpectWebdriverIO` namespace.
+     * The type `T` must stay named `T` to correctly overload the expect function from the expect library.
+     */
+
+    /**
+     * Expect defining the custom wdio expect and also pulling on asymmetric matchers.
+     * `AsymmetricMatchers` and `Inverse<AsymmetricMatchers>` needs to be defined and be before the `expect` library Expect (aka `WdioExpect`).
+     * The above allows to have custom asymmetric matchers under the `ExpectWebdriverIO` namespace.
+     */
+    interface Expect extends ExpectWebdriverIO.AsymmetricMatchers, ExpectLibInverse<ExpectWebdriverIO.InverseAsymmetricMatchers>, WdioExpect {
+        /**
+         * The `expect` function is used every time you want to test a value.
+         * You will rarely call `expect` by itself.
+         *
+         * expect function declaration contains two generics:
+         *  - T: the type of the actual value, e.g. any type, not just WebdriverIO.Browser or WebdriverIO.Element
+         *  - R: the type of the return value, e.g. Promise<void> or void
+         *
+         * Note: The function must stay here in the namespace to overwrite correctly the expect function from the expect library.
+         *
+         * @param actual The value to apply matchers against.
+         */
+        <T = unknown>(actual: T): T extends PromiseLike<unknown> ? ExpectWebdriverIO.MatchersAndInverse<void, T> & ExpectWebdriverIO.PromiseMatchers<T> : ExpectWebdriverIO.MatchersAndInverse<void, T>;
+    }
+
+    interface Matchers<R extends void | Promise<void>, T> extends WdioMatchers<R, T> {}
+
+    interface AsymmetricMatchers extends WdioAsymmetricMatchers {}
+
+    interface InverseAsymmetricMatchers extends Omit<ExpectWebdriverIO.AsymmetricMatchers, 'anything' | 'any'> {}
+
+    /**
+     * End of block overloading types from the expect library.
+     */
+
+    type MatchersAndInverse<R extends void | Promise<void>, ActualT> = ExpectWebdriverIO.Matchers<R, ActualT> & ExpectLibInverse<ExpectWebdriverIO.Matchers<R, ActualT>>
+
+    /**
+     * Take from expect library
+     */
+    type PromiseMatchers<T = unknown> = {
+        /**
+         * Unwraps the reason of a rejected promise so any other matcher can be chained.
+         * If the promise is fulfilled the assertion fails.
+         */
+        rejects: MatchersAndInverse<Promise<void>, T>;
+        /**
+         * Unwraps the value of a fulfilled promise so any other matcher can be chained.
+         * If the promise is rejected the assertion fails.
+         */
+        resolves: MatchersAndInverse<Promise<void>, T>;
+    }
     interface SnapshotServiceArgs {
         updateState?: SnapshotUpdateState
         resolveSnapshotPath?: (path: string, extension: string) => string
@@ -47,7 +559,7 @@ declare namespace ExpectWebdriverIO {
 
     class SoftAssertionService implements ServiceInstance {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        constructor(serviceOptions?: SoftAssertionServiceOptions, capabilities?: any, config?: any)
+        constructor(serviceOptions?: SoftAssertionServiceOptions, capabilities?: unknown, config?: any)
         beforeTest(test: Test): void
         beforeStep(step: PickleStep, scenario: Scenario): void
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -55,20 +567,15 @@ declare namespace ExpectWebdriverIO {
         afterStep(step: PickleStep, scenario: Scenario, result: { passed: boolean, error?: Error }): void
     }
 
-    interface AssertionResult {
-        pass: boolean
-        message(): string
-    }
+    interface AssertionResult extends ExpectLibSyncExpectationResult {}
+    type AsyncAssertionResult = ExpectLibAsyncExpectationResult
 
-    const matchers: Map<
-        string,
-        (
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            actual: any,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            ...expected: any[]
-        ) => Promise<AssertionResult>
-    >
+    /**
+     * Used by the wdio main project to configure the matchers in the runner when using Jasmine or Jest.
+     * Equivalent as `MatchersObject` from the expect library.
+     * @see https://github.com/jestjs/jest/blob/fd3d6cf9fe416b549a74b6577e5e1ea1130e3659/packages/expect/src/types.ts#L43C13-L43C27
+     */
+    const matchers: Map<string, RawMatcherFn>
 
     interface AssertionHookParams {
         /**
@@ -195,290 +702,28 @@ declare namespace ExpectWebdriverIO {
         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 | ExpectWebdriverIO.PartialMatcher,
-            options?: ExpectWebdriverIO.StringOptions
-        ): R
-        /**
-         * `WebdriverIO.Element` -> `getAttribute`
-         */
-        toHaveAttr(attribute: string, value?: string | RegExp | ExpectWebdriverIO.PartialMatcher, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` class
-         * @deprecated since v1.3.1 - use `toHaveElementClass` instead.
-         */
-        toHaveClass(className: string | RegExp | ExpectWebdriverIO.PartialMatcher, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` class
-         *
-         * Checks if an element has the specified class or matches any of the provided class patterns.
-         * @param className - The class name(s) or pattern(s) to match against.
-         * @param options - Optional settings that can be passed to the function.
-         *
-         * **Usage**
-         * ```js
-         * // Check if an element has the class 'btn'
-         * await expect(element).toHaveElementClass('btn')
-         *
-         * // Check if an element has any of the specified classes
-         * await expect(element).toHaveElementClass(['btn', 'btn-large'])
-         * ```
-         */
-        toHaveElementClass(className: string | RegExp | Array<string | RegExp> | ExpectWebdriverIO.PartialMatcher, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getProperty`
-         */
-        toHaveElementProperty(
-            property: string | RegExp | ExpectWebdriverIO.PartialMatcher,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            value?: any,
-            options?: ExpectWebdriverIO.StringOptions
-        ): R
-
-        /**
-         * `WebdriverIO.Element` -> `getProperty` value
-         */
-        toHaveValue(value: string | RegExp | ExpectWebdriverIO.PartialMatcher, 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 | ExpectWebdriverIO.PartialMatcher, options?: ExpectWebdriverIO.StringOptions): R
-        /**
-         * `WebdriverIO.Element` -> `getAttribute` href
-         */
-        toHaveLink(href: string | RegExp | ExpectWebdriverIO.PartialMatcher, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getProperty` value
-         */
-        toHaveId(id: string | RegExp | ExpectWebdriverIO.PartialMatcher, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getSize` value
-         */
-        toHaveSize(size: { height: number; width: number }, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getText`
-         * Element's text equals the text provided
-         *
-         * @param text - The expected text to match.
-         * @param options - Optional settings that can be passed to the function.
-         *
-         * **Usage**
-         *
-         * ```js
-         * // Check if an element has the text
-         * const elem = await $('.container')
-         * await expect(elem).toHaveText('Next-gen browser and mobile automation test framework for Node.js')
-         *
-         * // Check if an element array contains the specified text
-         * const elem = await $$('ul > li')
-         * await expect(elem).toHaveText(['Coffee', 'Tea', 'Milk'])
-         * ```
-         */
-        toHaveText(
-            text: string | RegExp | ExpectWebdriverIO.PartialMatcher | Array<string | RegExp | ExpectWebdriverIO.PartialMatcher>,
-            options?: ExpectWebdriverIO.StringOptions
-        ): R
-
-        /**
-         * `WebdriverIO.Element` -> `getHTML`
-         * Element's html equals the html provided
-         */
-        toHaveHTML(html: string | RegExp | ExpectWebdriverIO.PartialMatcher | Array<string | RegExp>, options?: ExpectWebdriverIO.HTMLOptions): R
-
-        /**
-         * `WebdriverIO.Element` -> `getComputedLabel`
-         * Element's computed label equals the computed label provided
-         */
-        toHaveComputedLabel(
-            computedLabel: string | RegExp | ExpectWebdriverIO.PartialMatcher | Array<string | RegExp>,
-            options?: ExpectWebdriverIO.StringOptions
-        ): R
-
-        /**
-         * `WebdriverIO.Element` -> `getComputedRole`
-         * Element's computed role equals the computed role provided
-         */
-        toHaveComputedRole(
-            computedRole: string | RegExp | ExpectWebdriverIO.PartialMatcher | 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 | ExpectWebdriverIO.PartialMatcher, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Browser` -> `getTitle`
-         */
-        toHaveTitle(title: string | RegExp | ExpectWebdriverIO.PartialMatcher, options?: ExpectWebdriverIO.StringOptions): R
-
-        /**
-         * `WebdriverIO.Browser` -> `execute`
-         */
-        toHaveClipboardText(clipboardText: string | RegExp | ExpectWebdriverIO.PartialMatcher, 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 & Promise<WebdriverIO.ElementArray>
-
-        // ==== 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
-        /**
-         * snapshot matcher
-         * @param label optional snapshot label
-         */
-        toMatchSnapshot(label?: string): R
-        /**
-         * inline snapshot matcher
-         * @param snapshot snapshot string (autogenerated if not specified)
-         * @param label optional snapshot label
-         */
-        toMatchInlineSnapshot(snapshot?: string, label?: string): R
-    }
-
     type RequestedWith = {
-        url?: string | ExpectWebdriverIO.PartialMatcher | ((url: string) => boolean)
+        url?: string | ExpectWebdriverIO.PartialMatcher<string>| ((url: string) => boolean)
         method?: string | Array<string>
         statusCode?: number | Array<number>
         requestHeaders?:
             | Record<string, string>
-            | ExpectWebdriverIO.PartialMatcher
+            | ExpectWebdriverIO.PartialMatcher<Record<string, string>>
             | ((headers: Record<string, string>) => boolean)
         responseHeaders?:
             | Record<string, string>
-            | ExpectWebdriverIO.PartialMatcher
+            | ExpectWebdriverIO.PartialMatcher<Record<string, string>>
             | ((headers: Record<string, string>) => boolean)
         postData?:
             | string
             | ExpectWebdriverIO.JsonCompatible
-            | ExpectWebdriverIO.PartialMatcher
-            | ((r: string | undefined) => boolean)
+            | ExpectWebdriverIO.PartialMatcher<string | ExpectWebdriverIO.JsonCompatible>
+            | ((postData: string | undefined) => boolean)
         response?:
             | string
             | ExpectWebdriverIO.JsonCompatible
-            | ExpectWebdriverIO.PartialMatcher
-            | ((r: string) => boolean)
+            | ExpectWebdriverIO.PartialMatcher<string | ExpectWebdriverIO.JsonCompatible>
+            | ((response: unknown) => boolean)
     }
 
     type jsonPrimitive = string | number | boolean | null
@@ -486,66 +731,11 @@ declare namespace ExpectWebdriverIO {
     type jsonArray = Array<jsonPrimitive | jsonObject | jsonArray>
     type JsonCompatible = jsonObject | jsonArray
 
-    interface PartialMatcher {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        sample?: any
-        $$typeof: symbol
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        asymmetricMatch(...args: any[]): boolean
-        toString(): string
-    }
-
     /**
-     * expect function declaration, containing two generics:
-     *  - T: the type of the actual value, e.g. WebdriverIO.Browser or WebdriverIO.Element
-     *  - R: the type of the return value, e.g. Promise<void> or void
+     * Allow to partially matches value. Same as asymmetric matcher in jest.
+     * Some properties are omitted for the type check to work correctly.
      */
-    interface Expect {
-        <T = unknown, R extends void | Promise<void> = void | Promise<void>>(actual: T): Matchers<R, T>
-
-        /**
-         * Creates a soft assertion wrapper around standard expect
-         * Soft assertions record failures but don't throw errors immediately
-         * All failures are collected and reported at the end of the test
-         */
-        soft<T = unknown>(actual: T): Matchers<Promise<void>, T>
-
-        /**
-         * Get all current soft assertion failures
-         */
-        getSoftFailures(testId?: string): SoftFailure[]
-
-        /**
-         * Manually assert all soft failures (throws an error if any failures exist)
-         */
-        assertSoftFailures(testId?: string): void
-
-        /**
-         * Clear all current soft assertion failures
-         */
-        clearSoftFailures(testId?: string): void
-
-        // Standard asymmetric matchers from Jest
-        extend(map: Record<string, Function>): void
-        anything(): PartialMatcher
-        any(sample: unknown): PartialMatcher
-        stringContaining(expected: string): PartialMatcher
-        objectContaining(sample: Record<string, unknown>): PartialMatcher
-        arrayContaining(sample: Array<unknown>): PartialMatcher
-        stringMatching(expected: string | RegExp): PartialMatcher
-        not: AsymmetricMatchers
-    }
-
-    interface AsymmetricMatchers {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        any(expectedObject: any): PartialMatcher
-        anything(): PartialMatcher
-        arrayContaining(sample: Array<unknown>): PartialMatcher
-        objectContaining(sample: Record<string, unknown>): PartialMatcher
-        stringContaining(expected: string): PartialMatcher
-        stringMatching(expected: string | RegExp): PartialMatcher
-        not: AsymmetricMatchers
-    }
+    type PartialMatcher<T> = Omit<ExpectLibAsymmetricMatcher<T>, 'sample' | 'inverse' | '$$typeof'>
 }
 
 declare module 'expect-webdriverio' {