codeceptjs 3.6.5 → 3.6.6-beta.1

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

@@ -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",
+  "version": "3.6.6-beta.1",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",
@@ -77,7 +77,7 @@
     "@xmldom/xmldom": "0.8.10",
     "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.1",
+    "devtools": "8.40.2",
     "envinfo": "7.11.1",
     "escape-string-regexp": "4.0.0",
     "figures": "3.2.0",
@@ -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,24 +127,24 @@
     "@types/chai": "4.3.16",
     "@types/inquirer": "9.0.3",
     "@types/node": "20.11.30",
-    "@wdio/sauce-service": "8.39.1",
+    "@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": "31.3.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": "9.1.1",
+    "husky": "9.1.4",
     "inquirer-test": "2.0.1",
     "jsdoc": "4.0.3",
     "jsdoc-typeof-plugin": "1.0.0",
@@ -163,7 +163,7 @@
     "tsd": "^0.31.0",
     "tsd-jsdoc": "2.5.0",
     "typedoc": "0.26.5",
-    "typedoc-plugin-markdown": "4.2.1",
+    "typedoc-plugin-markdown": "4.2.6",
     "typescript": "5.5.3",
     "wdio-docker-service": "1.5.0",
     "webdriverio": "8.39.1",

package/typings/promiseBasedTypes.d.ts

@@ -1180,6 +1180,7 @@ declare namespace CodeceptJS {
      *
      * ## Methods
      */
+    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
@@ -1291,6 +1292,7 @@ declare namespace CodeceptJS {
      *
      * ## Methods
      */
+    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
@@ -1962,6 +1964,7 @@ declare namespace CodeceptJS {
      * @property [host = "0.0.0.0"] - Mock server host
      * @property [httpsOpts] - key & cert values are the paths to .key and .crt files
      */
+    // @ts-ignore
     type MockServerConfig = {
         port?: number;
         host?: string;
@@ -2086,6 +2089,7 @@ declare namespace CodeceptJS {
      *
      * ## Methods
      */
+    // @ts-ignore
     class MockServer {
         /**
          * Start the mock server
@@ -3159,6 +3163,7 @@ declare namespace CodeceptJS {
      * @property [recordHar] - record HAR and will be saved to `output/har`. See more of [HAR options](https://playwright.dev/docs/api/class-browser#browser-new-context-option-record-har).
      * @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
     type PlaywrightConfig = {
         url?: string;
         browser?: 'chromium' | 'firefox' | 'webkit' | 'electron';
@@ -6535,6 +6540,7 @@ declare namespace CodeceptJS {
      * @property [chrome] - pass additional [Puppeteer run options](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#puppeteerlaunchoptions).
      * @property [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
      */
+    // @ts-ignore
     type PuppeteerConfig = {
         url: string;
         basicAuth?: any;
@@ -8341,6 +8347,7 @@ declare namespace CodeceptJS {
      * @property [onResponse] - an async function which can update response object.
      * @property [maxUploadFileSize] - set the max content file size in MB when performing api calls.
      */
+    // @ts-ignore
     type RESTConfig = {
         endpoint?: string;
         prettyPrintJson?: boolean;
@@ -8506,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
      */
@@ -9459,6 +9710,7 @@ declare namespace CodeceptJS {
      * @property [logLevel = silent] - level of logging verbosity. Default: silent. Options: trace | debug | info | warn | error | silent. More info: https://webdriver.io/docs/configuration/#loglevel
      * @property [devtoolsProtocol = false] - enable devtools protocol. Default: false. More info: https://webdriver.io/docs/automationProtocols/#devtools-protocol.
      */
+    // @ts-ignore
     type WebDriverConfig = {
         url: string;
         browser: string;

package/typings/types.d.ts

@@ -1204,6 +1204,7 @@ declare namespace CodeceptJS {
      *
      * ## Methods
      */
+    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
@@ -1315,6 +1316,7 @@ declare namespace CodeceptJS {
      *
      * ## Methods
      */
+    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
@@ -1989,6 +1991,7 @@ declare namespace CodeceptJS {
      * @property [host = "0.0.0.0"] - Mock server host
      * @property [httpsOpts] - key & cert values are the paths to .key and .crt files
      */
+    // @ts-ignore
     type MockServerConfig = {
         port?: number;
         host?: string;
@@ -2113,6 +2116,7 @@ declare namespace CodeceptJS {
      *
      * ## Methods
      */
+    // @ts-ignore
     class MockServer {
         /**
          * Start the mock server
@@ -3252,6 +3256,7 @@ declare namespace CodeceptJS {
      * @property [recordHar] - record HAR and will be saved to `output/har`. See more of [HAR options](https://playwright.dev/docs/api/class-browser#browser-new-context-option-record-har).
      * @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
     type PlaywrightConfig = {
         url?: string;
         browser?: 'chromium' | 'firefox' | 'webkit' | 'electron';
@@ -6779,6 +6784,7 @@ declare namespace CodeceptJS {
      * @property [chrome] - pass additional [Puppeteer run options](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#puppeteerlaunchoptions).
      * @property [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
      */
+    // @ts-ignore
     type PuppeteerConfig = {
         url: string;
         basicAuth?: any;
@@ -8721,6 +8727,7 @@ declare namespace CodeceptJS {
      * @property [onResponse] - an async function which can update response object.
      * @property [maxUploadFileSize] - set the max content file size in MB when performing api calls.
      */
+    // @ts-ignore
     type RESTConfig = {
         endpoint?: string;
         prettyPrintJson?: boolean;
@@ -8886,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
      */
@@ -9899,6 +10150,7 @@ declare namespace CodeceptJS {
      * @property [logLevel = silent] - level of logging verbosity. Default: silent. Options: trace | debug | info | warn | error | silent. More info: https://webdriver.io/docs/configuration/#loglevel
      * @property [devtoolsProtocol = false] - enable devtools protocol. Default: false. More info: https://webdriver.io/docs/automationProtocols/#devtools-protocol.
      */
+    // @ts-ignore
     type WebDriverConfig = {
         url: string;
         browser: string;
@@ -12368,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;