codeceptjs 3.6.5-beta.5 → 3.6.6-beta.1

package/README.md

@@ -9,7 +9,6 @@ Build Status:
 
 Appium Helper:
 [![Appium V2 Tests - Android](https://github.com/codeceptjs/CodeceptJS/actions/workflows/appiumV2_Android.yml/badge.svg)](https://github.com/codeceptjs/CodeceptJS/actions/workflows/appiumV2_Android.yml)
-[![Appium V2 Tests - iOS](https://github.com/codeceptjs/CodeceptJS/actions/workflows/appiumV2_iOS.yml/badge.svg)](https://github.com/codeceptjs/CodeceptJS/actions/workflows/appiumV2_iOS.yml)
 
 Web Helper:
 [![Playwright Tests](https://github.com/codeceptjs/CodeceptJS/actions/workflows/playwright.yml/badge.svg)](https://github.com/codeceptjs/CodeceptJS/actions/workflows/playwright.yml)

package/docs/webapi/waitForDisabled.mustache

@@ -0,0 +1,6 @@
+Waits for element to become disabled (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.
+@returns {void} automatically synchronized promise through #recorder

package/lib/helper/Playwright.js

@@ -2476,7 +2476,7 @@ class Playwright extends Helper {
   async waitForEnabled(locator, sec) {
     const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
     locator = new Locator(locator, 'css')
-    const matcher = await this.context
+
     let waiter
     const context = await this._getContext()
     if (!locator.isXPath()) {
@@ -2498,6 +2498,34 @@ class Playwright extends Helper {
     })
   }
 
+  /**
+   * {{> waitForDisabled }}
+   */
+  async waitForDisabled(locator, sec) {
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+
+    let waiter
+    const context = await this._getContext()
+    if (!locator.isXPath()) {
+      const valueFn = function ([locator]) {
+        return Array.from(document.querySelectorAll(locator)).filter((el) => el.disabled).length > 0
+      }
+      waiter = context.waitForFunction(valueFn, [locator.value], { timeout: waitTimeout })
+    } else {
+      const disabledFn = function ([locator, $XPath]) {
+        eval($XPath) // eslint-disable-line no-eval
+        return $XPath(null, locator).filter((el) => el.disabled).length > 0
+      }
+      waiter = context.waitForFunction(disabledFn, [locator.value, $XPath.toString()], { timeout: waitTimeout })
+    }
+    return waiter.catch((err) => {
+      throw new Error(
+        `element (${locator.toString()}) is still enabled after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
+  }
+
   /**
    * {{> waitForValue }}
    */

package/lib/helper/REST.js

@@ -206,7 +206,7 @@ class REST extends Helper {
       : this.debugSection('Request', JSON.stringify(_debugRequest))
 
     if (this.options.printCurl) {
-      this.debugSection('CURL Request', curlize(request));
+      this.debugSection('CURL Request', curlize(request))
     }
 
     let response
@@ -393,8 +393,13 @@ class REST extends Helper {
 module.exports = REST
 
 function curlize(request) {
-  if (request.data?.constructor.name.toLowerCase() === 'formdata') return 'cURL is not printed as the request body is not a JSON'
-  let curl = `curl --location --request ${request.method ? request.method.toUpperCase() : 'GET'} ${request.baseURL} `.replace("'", '')
+  if (request.data?.constructor.name.toLowerCase() === 'formdata')
+    return 'cURL is not printed as the request body is not a JSON'
+  let curl =
+    `curl --location --request ${request.method ? request.method.toUpperCase() : 'GET'} ${request.baseURL} `.replace(
+      "'",
+      '',
+    )
 
   if (request.headers) {
     Object.entries(request.headers).forEach(([key, value]) => {
@@ -411,4 +416,3 @@ function curlize(request) {
   }
   return curl
 }
-

package/lib/helper/SoftExpectHelper.js

@@ -0,0 +1,381 @@
+const ExpectHelper = require('./ExpectHelper')
+
+/**
+ * SoftAssertHelper is a utility class for performing soft assertions.
+ * Unlike traditional assertions that stop the execution on failure,
+ * soft assertions allow the execution to continue and report all failures at the end.
+ *
+ * ### Examples
+ *
+ * Zero-configuration when paired with other helpers like REST, Playwright:
+ *
+ * ```js
+ * // inside codecept.conf.js
+ * {
+ *   helpers: {
+ *     Playwright: {...},
+ *     SoftExpectHelper: {},
+ *   }
+ * }
+ * ```
+ *
+ * ```js
+ * // in scenario
+ * I.softExpectEqual('a', 'b')
+ * I.flushSoftAssertions() // Throws an error if any soft assertions have failed. The error message contains all the accumulated failures.
+ * ```
+ *
+ * ## Methods
+ */
+class SoftAssertHelper extends ExpectHelper {
+  constructor() {
+    super()
+    this.errors = []
+  }
+
+  /**
+   * Performs a soft assertion by executing the provided assertion function.
+   * If the assertion fails, the error is caught and stored without halting the execution.
+   *
+   * @param {Function} assertionFn - The assertion function to execute.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softAssert(assertionFn, customErrorMsg = '') {
+    try {
+      assertionFn()
+    } catch (error) {
+      this.errors.push({ customErrorMsg, error })
+    }
+  }
+
+  /**
+   * Throws an error if any soft assertions have failed.
+   * The error message contains all the accumulated failures.
+   *
+   * @throws {Error} If there are any soft assertion failures.
+   */
+  flushSoftAssertions() {
+    if (this.errors.length > 0) {
+      let errorMessage = 'Soft assertions failed:\n'
+      this.errors.forEach((err, index) => {
+        errorMessage += `\n[${index + 1}] ${err.customErrorMsg}\n${err.error.message}\n`
+      })
+      this.errors = []
+      throw new Error(errorMessage)
+    }
+  }
+
+  /**
+   * Softly asserts that two values are equal.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValue - The expected value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectEqual(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectEqual(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that two values are not equal.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValue - The expected value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectNotEqual(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectNotEqual(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that two values are deeply equal.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValue - The expected value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectDeepEqual(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that two values are not deeply equal.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValue - The expected value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectNotDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectNotDeepEqual(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that a value contains the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToContain - The value that should be contained within the actual value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectContain(actualValue, expectedValueToContain, customErrorMsg = '') {
+    this.softAssert(() => this.expectContain(actualValue, expectedValueToContain, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that a value does not contain the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToNotContain - The value that should not be contained within the actual value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectNotContain(actualValue, expectedValueToNotContain, customErrorMsg = '') {
+    this.softAssert(() => this.expectNotContain(actualValue, expectedValueToNotContain, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that a value starts with the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToStartWith - The value that the actual value should start with.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectStartsWith(actualValue, expectedValueToStartWith, customErrorMsg = '') {
+    this.softAssert(() => this.expectStartsWith(actualValue, expectedValueToStartWith, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that a value does not start with the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToNotStartWith - The value that the actual value should not start with.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectNotStartsWith(actualValue, expectedValueToNotStartWith, customErrorMsg = '') {
+    this.softAssert(
+      () => this.expectNotStartsWith(actualValue, expectedValueToNotStartWith, customErrorMsg),
+      customErrorMsg,
+    )
+  }
+
+  /**
+   * Softly asserts that a value ends with the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToEndWith - The value that the actual value should end with.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectEndsWith(actualValue, expectedValueToEndWith, customErrorMsg = '') {
+    this.softAssert(() => this.expectEndsWith(actualValue, expectedValueToEndWith, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that a value does not end with the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToNotEndWith - The value that the actual value should not end with.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectNotEndsWith(actualValue, expectedValueToNotEndWith, customErrorMsg = '') {
+    this.softAssert(
+      () => this.expectNotEndsWith(actualValue, expectedValueToNotEndWith, customErrorMsg),
+      customErrorMsg,
+    )
+  }
+
+  /**
+   * Softly asserts that the target data matches the given JSON schema.
+   *
+   * @param {*} targetData - The data to validate.
+   * @param {Object} jsonSchema - The JSON schema to validate against.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectJsonSchema(targetData, jsonSchema, customErrorMsg = '') {
+    this.softAssert(() => this.expectJsonSchema(targetData, jsonSchema, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that the target data matches the given JSON schema using AJV.
+   *
+   * @param {*} targetData - The data to validate.
+   * @param {Object} jsonSchema - The JSON schema to validate against.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   * @param {Object} [ajvOptions={ allErrors: true }] - Options to pass to AJV.
+   */
+  softExpectJsonSchemaUsingAJV(targetData, jsonSchema, customErrorMsg = '', ajvOptions = { allErrors: true }) {
+    this.softAssert(
+      () => this.expectJsonSchemaUsingAJV(targetData, jsonSchema, customErrorMsg, ajvOptions),
+      customErrorMsg,
+    )
+  }
+
+  /**
+   * Softly asserts that the target data has the specified property.
+   *
+   * @param {*} targetData - The data to check.
+   * @param {string} propertyName - The property name to check for.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion
+   fails. */ softExpectHasProperty(targetData, propertyName, customErrorMsg = '') {
+    this.softAssert(() => this.expectHasProperty(targetData, propertyName, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that the target data has a property with the specified name.
+   @param {*} targetData - The data to check.
+   @param {string} propertyName - The property name to check for.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectHasAProperty(targetData, propertyName, customErrorMsg = '') {
+    this.softAssert(() => this.expectHasAProperty(targetData, propertyName, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that the target data is of a specific type.
+   @param {*} targetData - The data to check.
+   @param {string} type - The expected type (e.g., 'string', 'number').
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectToBeA(targetData, type, customErrorMsg = '') {
+    this.softAssert(() => this.expectToBeA(targetData, type, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that the target data is of a specific type (alternative for articles).
+   @param {*} targetData - The data to check.
+   @param {string} type - The expected type (e.g., 'string', 'number').
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectToBeAn(targetData, type, customErrorMsg = '') {
+    this.softAssert(() => this.expectToBeAn(targetData, type, customErrorMsg), customErrorMsg)
+  }
+
+  /*
+   Softly asserts that the target data matches the specified regular expression.
+   @param {*} targetData - The data to check.
+   @param {RegExp} regex - The regular expression to match.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectMatchRegex(targetData, regex, customErrorMsg = '') {
+    this.softAssert(() => this.expectMatchRegex(targetData, regex, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that the target data has a specified length.
+   @param {*} targetData - The data to check.
+   @param {number} length - The expected length.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectLengthOf(targetData, length, customErrorMsg = '') {
+    this.softAssert(() => this.expectLengthOf(targetData, length, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the target data is empty.
+   @param {*} targetData - The data to check.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectEmpty(targetData, customErrorMsg = '') {
+    this.softAssert(() => this.expectEmpty(targetData, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the target data is true.
+   @param {*} targetData - The data to check.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectTrue(targetData, customErrorMsg = '') {
+    this.softAssert(() => this.expectTrue(targetData, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the target data is false.
+   @param {*} targetData - The data to check.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectFalse(targetData, customErrorMsg = '') {
+    this.softAssert(() => this.expectFalse(targetData, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the target data is above a specified value.
+   @param {*} targetData - The data to check.
+   @param {*} aboveThan - The value that the target data should be above.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectAbove(targetData, aboveThan, customErrorMsg = '') {
+    this.softAssert(() => this.expectAbove(targetData, aboveThan, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the target data is below a specified value.
+   @param {*} targetData - The data to check.
+   @param {*} belowThan - The value that the target data should be below.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectBelow(targetData, belowThan, customErrorMsg = '') {
+    this.softAssert(() => this.expectBelow(targetData, belowThan, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the length of the target data is above a specified value.
+   @param {*} targetData - The data to check.
+   @param {number} lengthAboveThan - The length that the target data should be above.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectLengthAboveThan(targetData, lengthAboveThan, customErrorMsg = '') {
+    this.softAssert(() => this.expectLengthAboveThan(targetData, lengthAboveThan, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that the length of the target data is below a specified value.
+   @param {*} targetData - The data to check.
+   @param {number} lengthBelowThan - The length that the target data should be below.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectLengthBelowThan(targetData, lengthBelowThan, customErrorMsg = '') {
+    this.softAssert(() => this.expectLengthBelowThan(targetData, lengthBelowThan, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that two values are equal, ignoring case.
+   @param {string} actualValue - The actual string value.
+   @param {string} expectedValue - The expected string value.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectEqualIgnoreCase(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectEqualIgnoreCase(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that two arrays have deep equality, considering members in any order.
+   @param {Array} actualValue - The actual array.
+   @param {Array} expectedValue - The expected array.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectDeepMembers(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectDeepMembers(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that an array (superset) deeply includes all members of another array (set).
+   @param {Array} superset - The array that should contain the expected members.
+   @param {Array} set - The array with members that should be included.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectDeepIncludeMembers(superset, set, customErrorMsg = '') {
+    this.softAssert(() => this.expectDeepIncludeMembers(superset, set, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that two objects are deeply equal, excluding specified fields.
+   @param {Object} actualValue - The actual object.
+   @param {Object} expectedValue - The expected object.
+   @param {Array<string>} fieldsToExclude - The fields to exclude from the comparison.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectDeepEqualExcluding(actualValue, expectedValue, fieldsToExclude, customErrorMsg = '') {
+    this.softAssert(
+      () => this.expectDeepEqualExcluding(actualValue, expectedValue, fieldsToExclude, customErrorMsg),
+      customErrorMsg,
+    )
+  }
+
+  /**
+   Softly asserts that a value matches the expected pattern.
+   @param {*} actualValue - The actual value.
+   @param {*} expectedPattern - The pattern the value should match.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectMatchesPattern(actualValue, expectedPattern, customErrorMsg = '') {
+    this.softAssert(() => this.expectMatchesPattern(actualValue, expectedPattern, customErrorMsg), customErrorMsg)
+  }
+}
+module.exports = SoftAssertHelper

package/lib/locator.js

@@ -175,7 +175,7 @@ class Locator {
    */
   toXPath(pseudoSelector = '') {
     const locator = `${this.value}${pseudoSelector}`;
-    const limitation = [':nth-of-type', ':first-of-type', ':last-of-type', ':nth-last-child', ':nth-last-of-type', ':checked', ':disabled', ':enabled', ':required', ':lang', ':nth-child'];
+    const limitation = [':nth-of-type', ':first-of-type', ':last-of-type', ':nth-last-child', ':nth-last-of-type', ':checked', ':disabled', ':enabled', ':required', ':lang', ':nth-child', ':has'];
 
     if (limitation.some(item => locator.includes(item))) {
       cssToXPath = require('css-to-xpath');
@@ -299,6 +299,49 @@ class Locator {
     return new Locator({ xpath });
   }
 
+  /**
+     * Adds condition: attribute value starts with text
+     * (analog of XPATH: [starts-with(@attr,'startValue')] or CSS [attr^='startValue']
+     * Example: I.click(locate('a').withAttrStartsWith('href', 'https://')));
+     * Works with any attribute: class, href etc.
+     * @param {string} attrName
+     * @param {string} startsWith
+     * @returns {Locator}
+    */
+  withAttrStartsWith(attrName, startsWith) {
+    const xpath = sprintf('%s[%s]', this.toXPath(), `starts-with(@${attrName}, "${startsWith}")`);
+    return new Locator({ xpath });
+  }
+
+  /**
+    * Adds condition: attribute value ends with text
+    * (analog of XPATH: [ends-with(@attr,'endValue')] or CSS [attr$='endValue']
+    * Example: I.click(locate('a').withAttrEndsWith('href', '.com')));
+    * Works with any attribute: class, href etc.
+    * @param {string} attrName
+    * @param {string} endsWith
+    * @returns {Locator}
+  */
+  withAttrEndsWith(attrName, endsWith) {
+    const xpath = sprintf('%s[%s]', this.toXPath(), `substring(@${attrName}, string-length(@${attrName}) - string-length("${endsWith}") + 1) = "${endsWith}"`,
+    );
+    return new Locator({ xpath });
+  }
+
+  /**
+     * Adds condition: attribute value contains text
+     * (analog of XPATH: [contains(@attr,'partOfAttribute')] or CSS [attr*='partOfAttribute']
+     * Example: I.click(locate('a').withAttrContains('href', 'google')));
+     * Works with any attribute: class, href etc.
+     * @param {string} attrName
+     * @param {string} partOfAttrValue
+     * @returns {Locator}
+     */
+  withAttrContains(attrName, partOfAttrValue) {
+    const xpath = sprintf('%s[%s]', this.toXPath(), `contains(@${attrName}, "${partOfAttrValue}")`);
+    return new Locator({ xpath });
+  }
+
   /**
    * @param {String} text
    * @returns {Locator}

package/lib/template/heal.js

@@ -5,6 +5,7 @@ heal.addRecipe('ai', {
   prepare: {
     html: ({ I }) => I.grabHTMLFrom('body'),
   },
+  suggest: true,
   steps: [
     'click',
     'fillField',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "3.6.5-beta.5",
+  "version": "3.6.6-beta.1",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",
@@ -75,9 +75,9 @@
     "@cucumber/gherkin": "26",
     "@cucumber/messages": "25.0.1",
     "@xmldom/xmldom": "0.8.10",
-    "acorn": "8.11.3",
+    "acorn": "8.12.1",
     "arrify": "2.0.1",
-    "axios": "1.7.2",
+    "axios": "1.7.3",
     "chai": "5.1.1",
     "chai-deep-match": "1.2.1",
     "chai-exclude": "2.1.1",
@@ -90,7 +90,7 @@
     "cross-spawn": "7.0.3",
     "css-to-xpath": "0.1.0",
     "csstoxpath": "1.6.0",
-    "devtools": "8.39.0",
+    "devtools": "8.40.2",
     "envinfo": "7.11.1",
     "escape-string-regexp": "4.0.0",
     "figures": "3.2.0",
@@ -99,13 +99,13 @@
     "glob": "6.0.1",
     "html-minifier-terser": "7.2.0",
     "inquirer": "6.5.2",
-    "joi": "17.13.1",
+    "joi": "17.13.3",
     "js-beautify": "1.15.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.merge": "4.6.2",
     "mkdirp": "1.0.4",
-    "mocha": "10.5.2",
-    "monocart-coverage-reports": "2.8.3",
+    "mocha": "10.6.0",
+    "monocart-coverage-reports": "2.10.0",
     "ms": "2.1.3",
     "ora-classic": "5.4.2",
     "pactum": "3.6.9",
@@ -114,7 +114,7 @@
     "promise-retry": "1.1.1",
     "resq": "1.11.0",
     "sprintf-js": "1.1.1",
-    "uuid": "9.0"
+    "uuid": "10.0"
   },
   "optionalDependencies": {
     "@codeceptjs/detox-helper": "1.0.8"
@@ -127,29 +127,29 @@
     "@types/chai": "4.3.16",
     "@types/inquirer": "9.0.3",
     "@types/node": "20.11.30",
-    "@wdio/sauce-service": "8.39.0",
+    "@wdio/sauce-service": "9.0.4",
     "@wdio/selenium-standalone-service": "8.3.2",
-    "@wdio/utils": "8.38.2",
+    "@wdio/utils": "9.0.6",
     "@xmldom/xmldom": "0.8.10",
     "apollo-server-express": "2.25.3",
     "chai-as-promised": "7.1.2",
     "chai-subset": "1.6.0",
     "contributor-faces": "1.1.0",
     "documentation": "12.3.0",
-    "electron": "30.1.0",
+    "electron": "31.3.1",
     "eslint": "8.57.0",
     "eslint-config-airbnb-base": "15.0.0",
     "eslint-plugin-import": "2.29.1",
-    "eslint-plugin-mocha": "10.4.3",
+    "eslint-plugin-mocha": "10.5.0",
     "expect": "29.7.0",
     "express": "4.19.2",
     "graphql": "16.9.0",
-    "husky": "8.0.3",
+    "husky": "9.1.4",
     "inquirer-test": "2.0.1",
     "jsdoc": "4.0.3",
     "jsdoc-typeof-plugin": "1.0.0",
     "json-server": "0.10.1",
-    "playwright": "1.45.0",
+    "playwright": "1.45.3",
     "prettier": "^3.3.2",
     "puppeteer": "22.12.1",
     "qrcode-terminal": "0.12.0",
@@ -162,11 +162,11 @@
     "ts-node": "10.9.2",
     "tsd": "^0.31.0",
     "tsd-jsdoc": "2.5.0",
-    "typedoc": "0.25.13",
-    "typedoc-plugin-markdown": "4.0.3",
-    "typescript": "5.4.5",
+    "typedoc": "0.26.5",
+    "typedoc-plugin-markdown": "4.2.6",
+    "typescript": "5.5.3",
     "wdio-docker-service": "1.5.0",
-    "webdriverio": "8.38.2",
+    "webdriverio": "8.39.1",
     "xml2js": "0.6.2",
     "xpath": "0.0.34"
   },

package/typings/promiseBasedTypes.d.ts

@@ -1181,7 +1181,6 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
-    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
@@ -1294,7 +1293,6 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
-    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
@@ -1967,7 +1965,6 @@ declare namespace CodeceptJS {
      * @property [httpsOpts] - key & cert values are the paths to .key and .crt files
      */
     // @ts-ignore
-    // @ts-ignore
     type MockServerConfig = {
         port?: number;
         host?: string;
@@ -2093,7 +2090,6 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
-    // @ts-ignore
     class MockServer {
         /**
          * Start the mock server
@@ -3168,7 +3164,6 @@ declare namespace CodeceptJS {
      * @property [testIdAttribute = data-testid] - locate elements based on the testIdAttribute. See more of [locate by test id](https://playwright.dev/docs/locators#locate-by-test-id).
      */
     // @ts-ignore
-    // @ts-ignore
     type PlaywrightConfig = {
         url?: string;
         browser?: 'chromium' | 'firefox' | 'webkit' | 'electron';
@@ -4762,6 +4757,13 @@ declare namespace CodeceptJS {
          * @param [sec = 1] - (optional) time in seconds to wait, 1 by default.
          */
         waitForEnabled(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<any>;
+        /**
+         * Waits for element to become disabled (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         * @param locator - element located by CSS|XPath|strict locator.
+         * @param [sec = 1] - (optional) time in seconds to wait, 1 by default.
+         */
+        waitForDisabled(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<any>;
         /**
          * Waits for the specified value to be in value attribute.
          *
@@ -6539,7 +6541,6 @@ declare namespace CodeceptJS {
      * @property [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
      */
     // @ts-ignore
-    // @ts-ignore
     type PuppeteerConfig = {
         url: string;
         basicAuth?: any;
@@ -8347,7 +8348,6 @@ declare namespace CodeceptJS {
      * @property [maxUploadFileSize] - set the max content file size in MB when performing api calls.
      */
     // @ts-ignore
-    // @ts-ignore
     type RESTConfig = {
         endpoint?: string;
         prettyPrintJson?: boolean;
@@ -8513,6 +8513,250 @@ declare namespace CodeceptJS {
          */
         sendDeleteRequest(url: any, headers?: any): Promise<any>;
     }
+    /**
+     * SoftAssertHelper is a utility class for performing soft assertions.
+     * Unlike traditional assertions that stop the execution on failure,
+     * soft assertions allow the execution to continue and report all failures at the end.
+     *
+     * ### Examples
+     *
+     * Zero-configuration when paired with other helpers like REST, Playwright:
+     *
+     * ```js
+     * // inside codecept.conf.js
+     * {
+     *   helpers: {
+     *     Playwright: {...},
+     *     SoftExpectHelper: {},
+     *   }
+     * }
+     * ```
+     *
+     * ```js
+     * // in scenario
+     * I.softExpectEqual('a', 'b')
+     * I.flushSoftAssertions() // Throws an error if any soft assertions have failed. The error message contains all the accumulated failures.
+     * ```
+     *
+     * ## Methods
+     */
+    class SoftAssertHelperTs {
+        /**
+         * Performs a soft assertion by executing the provided assertion function.
+         * If the assertion fails, the error is caught and stored without halting the execution.
+         * @param assertionFn - The assertion function to execute.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softAssert(assertionFn: (...params: any[]) => any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Throws an error if any soft assertions have failed.
+         * The error message contains all the accumulated failures.
+         */
+        flushSoftAssertions(): Promise<any>;
+        /**
+         * Softly asserts that two values are equal.
+         * @param actualValue - The actual value.
+         * @param expectedValue - The expected value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectEqual(actualValue: any, expectedValue: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that two values are not equal.
+         * @param actualValue - The actual value.
+         * @param expectedValue - The expected value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that two values are deeply equal.
+         * @param actualValue - The actual value.
+         * @param expectedValue - The expected value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectDeepEqual(actualValue: any, expectedValue: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that two values are not deeply equal.
+         * @param actualValue - The actual value.
+         * @param expectedValue - The expected value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectNotDeepEqual(actualValue: any, expectedValue: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that a value contains the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToContain - The value that should be contained within the actual value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectContain(actualValue: any, expectedValueToContain: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that a value does not contain the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToNotContain - The value that should not be contained within the actual value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectNotContain(actualValue: any, expectedValueToNotContain: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that a value starts with the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToStartWith - The value that the actual value should start with.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectStartsWith(actualValue: any, expectedValueToStartWith: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that a value does not start with the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToNotStartWith - The value that the actual value should not start with.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectNotStartsWith(actualValue: any, expectedValueToNotStartWith: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that a value ends with the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToEndWith - The value that the actual value should end with.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectEndsWith(actualValue: any, expectedValueToEndWith: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that a value does not end with the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToNotEndWith - The value that the actual value should not end with.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectNotEndsWith(actualValue: any, expectedValueToNotEndWith: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data matches the given JSON schema.
+         * @param targetData - The data to validate.
+         * @param jsonSchema - The JSON schema to validate against.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectJsonSchema(targetData: any, jsonSchema: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data matches the given JSON schema using AJV.
+         * @param targetData - The data to validate.
+         * @param jsonSchema - The JSON schema to validate against.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         * @param [ajvOptions = { allErrors: true }] - Options to pass to AJV.
+         */
+        softExpectJsonSchemaUsingAJV(targetData: any, jsonSchema: any, customErrorMsg?: string, ajvOptions?: any): Promise<any>;
+        /**
+         * Softly asserts that the target data has the specified property.
+         * @param targetData - The data to check.
+         * @param propertyName - The property name to check for.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion
+         *    fails.
+         */
+        softExpectHasProperty(targetData: any, propertyName: string, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data has a property with the specified name.
+         * @param targetData - The data to check.
+         * @param propertyName - The property name to check for.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectHasAProperty(targetData: any, propertyName: string, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data is of a specific type.
+         * @param targetData - The data to check.
+         * @param type - The expected type (e.g., 'string', 'number').
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectToBeA(targetData: any, type: string, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data is of a specific type (alternative for articles).
+         * @param targetData - The data to check.
+         * @param type - The expected type (e.g., 'string', 'number').
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectToBeAn(targetData: any, type: string, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data has a specified length.
+         * @param targetData - The data to check.
+         * @param length - The expected length.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectLengthOf(targetData: any, length: number, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data is empty.
+         * @param targetData - The data to check.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectEmpty(targetData: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data is true.
+         * @param targetData - The data to check.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectTrue(targetData: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data is false.
+         * @param targetData - The data to check.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectFalse(targetData: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data is above a specified value.
+         * @param targetData - The data to check.
+         * @param aboveThan - The value that the target data should be above.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectAbove(targetData: any, aboveThan: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the target data is below a specified value.
+         * @param targetData - The data to check.
+         * @param belowThan - The value that the target data should be below.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectBelow(targetData: any, belowThan: any, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the length of the target data is above a specified value.
+         * @param targetData - The data to check.
+         * @param lengthAboveThan - The length that the target data should be above.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectLengthAboveThan(targetData: any, lengthAboveThan: number, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that the length of the target data is below a specified value.
+         * @param targetData - The data to check.
+         * @param lengthBelowThan - The length that the target data should be below.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectLengthBelowThan(targetData: any, lengthBelowThan: number, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that two values are equal, ignoring case.
+         * @param actualValue - The actual string value.
+         * @param expectedValue - The expected string value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectEqualIgnoreCase(actualValue: string, expectedValue: string, customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that two arrays have deep equality, considering members in any order.
+         * @param actualValue - The actual array.
+         * @param expectedValue - The expected array.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectDeepMembers(actualValue: any[], expectedValue: any[], customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that an array (superset) deeply includes all members of another array (set).
+         * @param superset - The array that should contain the expected members.
+         * @param set - The array with members that should be included.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectDeepIncludeMembers(superset: any[], set: any[], customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that two objects are deeply equal, excluding specified fields.
+         * @param actualValue - The actual object.
+         * @param expectedValue - The expected object.
+         * @param fieldsToExclude - The fields to exclude from the comparison.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectDeepEqualExcluding(actualValue: any, expectedValue: any, fieldsToExclude: string[], customErrorMsg?: string): Promise<any>;
+        /**
+         * Softly asserts that a value matches the expected pattern.
+         * @param actualValue - The actual value.
+         * @param expectedPattern - The pattern the value should match.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectMatchesPattern(actualValue: any, expectedPattern: any, customErrorMsg?: string): Promise<any>;
+    }
     /**
      * Client Functions
      */
@@ -9467,7 +9711,6 @@ declare namespace CodeceptJS {
      * @property [devtoolsProtocol = false] - enable devtools protocol. Default: false. More info: https://webdriver.io/docs/automationProtocols/#devtools-protocol.
      */
     // @ts-ignore
-    // @ts-ignore
     type WebDriverConfig = {
         url: string;
         browser: string;

package/typings/types.d.ts

@@ -1205,7 +1205,6 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
-    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
@@ -1318,7 +1317,6 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
-    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
@@ -1994,7 +1992,6 @@ declare namespace CodeceptJS {
      * @property [httpsOpts] - key & cert values are the paths to .key and .crt files
      */
     // @ts-ignore
-    // @ts-ignore
     type MockServerConfig = {
         port?: number;
         host?: string;
@@ -2120,7 +2117,6 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
-    // @ts-ignore
     class MockServer {
         /**
          * Start the mock server
@@ -3261,7 +3257,6 @@ declare namespace CodeceptJS {
      * @property [testIdAttribute = data-testid] - locate elements based on the testIdAttribute. See more of [locate by test id](https://playwright.dev/docs/locators#locate-by-test-id).
      */
     // @ts-ignore
-    // @ts-ignore
     type PlaywrightConfig = {
         url?: string;
         browser?: 'chromium' | 'firefox' | 'webkit' | 'electron';
@@ -4914,6 +4909,14 @@ declare namespace CodeceptJS {
          * @returns automatically synchronized promise through #recorder
          */
         waitForEnabled(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        /**
+         * Waits for element to become disabled (by default waits for 1sec).
+         * Element can be located by CSS or XPath.
+         * @param locator - element located by CSS|XPath|strict locator.
+         * @param [sec = 1] - (optional) time in seconds to wait, 1 by default.
+         * @returns automatically synchronized promise through #recorder
+         */
+        waitForDisabled(locator: CodeceptJS.LocatorOrString, sec?: number): void;
         /**
          * Waits for the specified value to be in value attribute.
          *
@@ -6782,7 +6785,6 @@ declare namespace CodeceptJS {
      * @property [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
      */
     // @ts-ignore
-    // @ts-ignore
     type PuppeteerConfig = {
         url: string;
         basicAuth?: any;
@@ -8726,7 +8728,6 @@ declare namespace CodeceptJS {
      * @property [maxUploadFileSize] - set the max content file size in MB when performing api calls.
      */
     // @ts-ignore
-    // @ts-ignore
     type RESTConfig = {
         endpoint?: string;
         prettyPrintJson?: boolean;
@@ -8892,6 +8893,250 @@ declare namespace CodeceptJS {
          */
         sendDeleteRequest(url: any, headers?: any): Promise<any>;
     }
+    /**
+     * SoftAssertHelper is a utility class for performing soft assertions.
+     * Unlike traditional assertions that stop the execution on failure,
+     * soft assertions allow the execution to continue and report all failures at the end.
+     *
+     * ### Examples
+     *
+     * Zero-configuration when paired with other helpers like REST, Playwright:
+     *
+     * ```js
+     * // inside codecept.conf.js
+     * {
+     *   helpers: {
+     *     Playwright: {...},
+     *     SoftExpectHelper: {},
+     *   }
+     * }
+     * ```
+     *
+     * ```js
+     * // in scenario
+     * I.softExpectEqual('a', 'b')
+     * I.flushSoftAssertions() // Throws an error if any soft assertions have failed. The error message contains all the accumulated failures.
+     * ```
+     *
+     * ## Methods
+     */
+    class SoftAssertHelper {
+        /**
+         * Performs a soft assertion by executing the provided assertion function.
+         * If the assertion fails, the error is caught and stored without halting the execution.
+         * @param assertionFn - The assertion function to execute.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softAssert(assertionFn: (...params: any[]) => any, customErrorMsg?: string): void;
+        /**
+         * Throws an error if any soft assertions have failed.
+         * The error message contains all the accumulated failures.
+         */
+        flushSoftAssertions(): void;
+        /**
+         * Softly asserts that two values are equal.
+         * @param actualValue - The actual value.
+         * @param expectedValue - The expected value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectEqual(actualValue: any, expectedValue: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that two values are not equal.
+         * @param actualValue - The actual value.
+         * @param expectedValue - The expected value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that two values are deeply equal.
+         * @param actualValue - The actual value.
+         * @param expectedValue - The expected value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectDeepEqual(actualValue: any, expectedValue: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that two values are not deeply equal.
+         * @param actualValue - The actual value.
+         * @param expectedValue - The expected value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectNotDeepEqual(actualValue: any, expectedValue: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that a value contains the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToContain - The value that should be contained within the actual value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectContain(actualValue: any, expectedValueToContain: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that a value does not contain the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToNotContain - The value that should not be contained within the actual value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectNotContain(actualValue: any, expectedValueToNotContain: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that a value starts with the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToStartWith - The value that the actual value should start with.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectStartsWith(actualValue: any, expectedValueToStartWith: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that a value does not start with the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToNotStartWith - The value that the actual value should not start with.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectNotStartsWith(actualValue: any, expectedValueToNotStartWith: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that a value ends with the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToEndWith - The value that the actual value should end with.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectEndsWith(actualValue: any, expectedValueToEndWith: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that a value does not end with the expected value.
+         * @param actualValue - The actual value.
+         * @param expectedValueToNotEndWith - The value that the actual value should not end with.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectNotEndsWith(actualValue: any, expectedValueToNotEndWith: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data matches the given JSON schema.
+         * @param targetData - The data to validate.
+         * @param jsonSchema - The JSON schema to validate against.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectJsonSchema(targetData: any, jsonSchema: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data matches the given JSON schema using AJV.
+         * @param targetData - The data to validate.
+         * @param jsonSchema - The JSON schema to validate against.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         * @param [ajvOptions = { allErrors: true }] - Options to pass to AJV.
+         */
+        softExpectJsonSchemaUsingAJV(targetData: any, jsonSchema: any, customErrorMsg?: string, ajvOptions?: any): void;
+        /**
+         * Softly asserts that the target data has the specified property.
+         * @param targetData - The data to check.
+         * @param propertyName - The property name to check for.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion
+         *    fails.
+         */
+        softExpectHasProperty(targetData: any, propertyName: string, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data has a property with the specified name.
+         * @param targetData - The data to check.
+         * @param propertyName - The property name to check for.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectHasAProperty(targetData: any, propertyName: string, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data is of a specific type.
+         * @param targetData - The data to check.
+         * @param type - The expected type (e.g., 'string', 'number').
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectToBeA(targetData: any, type: string, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data is of a specific type (alternative for articles).
+         * @param targetData - The data to check.
+         * @param type - The expected type (e.g., 'string', 'number').
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectToBeAn(targetData: any, type: string, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data has a specified length.
+         * @param targetData - The data to check.
+         * @param length - The expected length.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectLengthOf(targetData: any, length: number, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data is empty.
+         * @param targetData - The data to check.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectEmpty(targetData: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data is true.
+         * @param targetData - The data to check.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectTrue(targetData: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data is false.
+         * @param targetData - The data to check.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectFalse(targetData: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data is above a specified value.
+         * @param targetData - The data to check.
+         * @param aboveThan - The value that the target data should be above.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectAbove(targetData: any, aboveThan: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the target data is below a specified value.
+         * @param targetData - The data to check.
+         * @param belowThan - The value that the target data should be below.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectBelow(targetData: any, belowThan: any, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the length of the target data is above a specified value.
+         * @param targetData - The data to check.
+         * @param lengthAboveThan - The length that the target data should be above.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectLengthAboveThan(targetData: any, lengthAboveThan: number, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that the length of the target data is below a specified value.
+         * @param targetData - The data to check.
+         * @param lengthBelowThan - The length that the target data should be below.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectLengthBelowThan(targetData: any, lengthBelowThan: number, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that two values are equal, ignoring case.
+         * @param actualValue - The actual string value.
+         * @param expectedValue - The expected string value.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectEqualIgnoreCase(actualValue: string, expectedValue: string, customErrorMsg?: string): void;
+        /**
+         * Softly asserts that two arrays have deep equality, considering members in any order.
+         * @param actualValue - The actual array.
+         * @param expectedValue - The expected array.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectDeepMembers(actualValue: any[], expectedValue: any[], customErrorMsg?: string): void;
+        /**
+         * Softly asserts that an array (superset) deeply includes all members of another array (set).
+         * @param superset - The array that should contain the expected members.
+         * @param set - The array with members that should be included.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectDeepIncludeMembers(superset: any[], set: any[], customErrorMsg?: string): void;
+        /**
+         * Softly asserts that two objects are deeply equal, excluding specified fields.
+         * @param actualValue - The actual object.
+         * @param expectedValue - The expected object.
+         * @param fieldsToExclude - The fields to exclude from the comparison.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectDeepEqualExcluding(actualValue: any, expectedValue: any, fieldsToExclude: string[], customErrorMsg?: string): void;
+        /**
+         * Softly asserts that a value matches the expected pattern.
+         * @param actualValue - The actual value.
+         * @param expectedPattern - The pattern the value should match.
+         * @param [customErrorMsg = ''] - A custom error message to display if the assertion fails.
+         */
+        softExpectMatchesPattern(actualValue: any, expectedPattern: any, customErrorMsg?: string): void;
+    }
     /**
      * Client Functions
      */
@@ -9906,7 +10151,6 @@ declare namespace CodeceptJS {
      * @property [devtoolsProtocol = false] - enable devtools protocol. Default: false. More info: https://webdriver.io/docs/automationProtocols/#devtools-protocol.
      */
     // @ts-ignore
-    // @ts-ignore
     type WebDriverConfig = {
         url: string;
         browser: string;
@@ -12376,6 +12620,27 @@ declare namespace CodeceptJS {
         withAttr(attributes: {
             [key: string]: string;
         }): Locator;
+        /**
+         * Adds condition: attribute value starts with text
+         * (analog of XPATH: [starts-with(@attr,'startValue')] or CSS [attr^='startValue']
+         * Example: I.click(locate('a').withAttrStartsWith('href', 'https://')));
+         * Works with any attribute: class, href etc.
+         */
+        withAttrStartsWith(attrName: string, startsWith: string): Locator;
+        /**
+         * Adds condition: attribute value ends with text
+         * (analog of XPATH: [ends-with(@attr,'endValue')] or CSS [attr$='endValue']
+         * Example: I.click(locate('a').withAttrEndsWith('href', '.com')));
+         * Works with any attribute: class, href etc.
+         */
+        withAttrEndsWith(attrName: string, endsWith: string): Locator;
+        /**
+         * Adds condition: attribute value contains text
+         * (analog of XPATH: [contains(@attr,'partOfAttribute')] or CSS [attr*='partOfAttribute']
+         * Example: I.click(locate('a').withAttrContains('href', 'google')));
+         * Works with any attribute: class, href etc.
+         */
+        withAttrContains(attrName: string, partOfAttrValue: string): Locator;
         withClassAttr(text: string): Locator;
         as(output: string): Locator;
         inside(locator: CodeceptJS.LocatorOrString): Locator;