@uuv/playwright 3.41.0 → 3.42.0

package/dist/cucumber/step_definitions/playwright/core-engine.d.ts

@@ -68,15 +68,17 @@ export declare function getPageOrElement(world: World): Promise<any>;
 export declare function addCookie(world: World, cookieName: COOKIE_NAME, newCookie: CustomCookieValue): Promise<void>;
 export declare function getCookie(world: World, cookieName: COOKIE_NAME): Promise<CustomCookie>;
 export declare function deleteCookieByName(world: World, cookieName: COOKIE_NAME): Promise<void>;
-export declare function findWithRoleAndName(world: World, role: string, name: string): Promise<any>;
+export declare function findWithRoleAndName(world: World, role: string, name: string, otherRoleOptions?: {}): Promise<any>;
 export declare function withinRoleAndName(world: World, role: string, name: string): Promise<void>;
 export declare function notFoundWithRoleAndName(world: World, role: string, name: string): Promise<void>;
-export declare function findWithRoleAndNameAndContent(world: World, expectedRole: string, name: string, expectedTextContent?: string | undefined, setFocus?: boolean): Promise<any>;
+export declare function findWithRoleAndNameAndContent(world: World, expectedRole: string, name: string, expectedTextContent?: string | undefined, otherRoleOptions?: {}): Promise<any>;
 export declare function findWithRoleAndNameFocused(world: World, expectedRole: string, name: string): Promise<any>;
 export declare function findWithRoleAndNameAndChecked(world: World, expectedRole: string, name: string): Promise<any>;
 export declare function findWithRoleAndNameAndUnchecked(world: World, expectedRole: string, name: string): Promise<any>;
-export declare function findWithRoleAndNameAndContentDisable(world: World, expectedRole: string, name: string, expectedTextContent: string): Promise<void>;
-export declare function findWithRoleAndNameAndContentEnable(world: World, expectedRole: string, name: string, expectedTextContent: string): Promise<void>;
+export declare function findWithRoleAndNameAndContentDisabled(world: World, expectedRole: string, name: string, expectedTextContent: string): Promise<void>;
+export declare function findWithRoleAndNameDisabled(world: World, expectedRole: string, name: string): Promise<void>;
+export declare function findWithRoleAndNameAndContentEnabled(world: World, expectedRole: string, name: string, expectedTextContent: string): Promise<void>;
+export declare function findWithRoleAndNameEnabled(world: World, expectedRole: string, name: string): Promise<void>;
 export declare function showAttributesInLocator(element: any): Promise<void>;
 export declare function checkTextContentLocator(locator: Locator, expectedTextContent: string): Promise<void>;
 export declare function click(world: World, role: any, name: string): Promise<void>;

package/dist/cucumber/step_definitions/playwright/core-engine.js

@@ -24,8 +24,10 @@ exports.findWithRoleAndNameAndContent = findWithRoleAndNameAndContent;
 exports.findWithRoleAndNameFocused = findWithRoleAndNameFocused;
 exports.findWithRoleAndNameAndChecked = findWithRoleAndNameAndChecked;
 exports.findWithRoleAndNameAndUnchecked = findWithRoleAndNameAndUnchecked;
-exports.findWithRoleAndNameAndContentDisable = findWithRoleAndNameAndContentDisable;
-exports.findWithRoleAndNameAndContentEnable = findWithRoleAndNameAndContentEnable;
+exports.findWithRoleAndNameAndContentDisabled = findWithRoleAndNameAndContentDisabled;
+exports.findWithRoleAndNameDisabled = findWithRoleAndNameDisabled;
+exports.findWithRoleAndNameAndContentEnabled = findWithRoleAndNameAndContentEnabled;
+exports.findWithRoleAndNameEnabled = findWithRoleAndNameEnabled;
 exports.showAttributesInLocator = showAttributesInLocator;
 exports.checkTextContentLocator = checkTextContentLocator;
 exports.click = click;
@@ -181,11 +183,11 @@ async function deleteCookieByName(world, cookieName) {
         },
     ]);
 }
-async function findWithRoleAndName(world, role, name) {
-    await findWithRoleAndNameAndContent(world, role, name);
+async function findWithRoleAndName(world, role, name, otherRoleOptions = {}) {
+    await findWithRoleAndNameAndContent(world, role, name, undefined, otherRoleOptions);
 }
 async function withinRoleAndName(world, role, name) {
-    await findWithRoleAndNameAndContent(world, role, name, undefined, true);
+    await findWithRoleAndNameAndContent(world, role, name, undefined);
     await addCookie(world, COOKIE_NAME.SELECTED_ELEMENT, new SelectedElementCookie(FILTER_TYPE.SELECTOR, `role=${role}[name="${name}"]`));
 }
 async function notFoundWithRoleAndName(world, role, name) {
@@ -195,10 +197,10 @@ async function notFoundWithRoleAndName(world, role, name) {
         exact: true
     })).toHaveCount(0, { timeout: await getTimeout(world) }));
 }
-async function findWithRoleAndNameAndContent(world, expectedRole, name, expectedTextContent = undefined, setFocus = false) {
+async function findWithRoleAndNameAndContent(world, expectedRole, name, expectedTextContent = undefined, otherRoleOptions = {}) {
     expectedRole = encodeURIComponent(expectedRole);
     await getPageOrElement(world).then(async (element) => {
-        const byRole = await element.getByRole(expectedRole, { name: name, exact: true });
+        const byRole = await element.getByRole(expectedRole, { name: name, exact: true, ...otherRoleOptions });
         await (0, test_1.expect)(byRole).toHaveCount(1, { timeout: await getTimeout(world) });
         if (expectedTextContent !== undefined) {
             await checkTextContentLocator(byRole, expectedTextContent);
@@ -231,7 +233,7 @@ async function findWithRoleAndNameAndUnchecked(world, expectedRole, name) {
         await (0, test_1.expect)(byRole).not.toBeChecked();
     });
 }
-async function findWithRoleAndNameAndContentDisable(world, expectedRole, name, expectedTextContent) {
+async function findWithRoleAndNameAndContentDisabled(world, expectedRole, name, expectedTextContent) {
     expectedRole = encodeURIComponent(expectedRole);
     await getPageOrElement(world).then(async (element) => {
         const byRole = await element.getByRole(expectedRole, { name: name, exact: true });
@@ -240,7 +242,15 @@ async function findWithRoleAndNameAndContentDisable(world, expectedRole, name, e
         await (0, test_1.expect)(byRole).toBeDisabled();
     });
 }
-async function findWithRoleAndNameAndContentEnable(world, expectedRole, name, expectedTextContent) {
+async function findWithRoleAndNameDisabled(world, expectedRole, name) {
+    expectedRole = encodeURIComponent(expectedRole);
+    await getPageOrElement(world).then(async (element) => {
+        const byRole = await element.getByRole(expectedRole, { name: name, exact: true });
+        await (0, test_1.expect)(byRole).toHaveCount(1, { timeout: await getTimeout(world) });
+        await (0, test_1.expect)(byRole).toBeDisabled();
+    });
+}
+async function findWithRoleAndNameAndContentEnabled(world, expectedRole, name, expectedTextContent) {
     expectedRole = encodeURIComponent(expectedRole);
     await getPageOrElement(world).then(async (element) => {
         const byRole = element.getByRole(expectedRole, { name: name, exact: true });
@@ -249,6 +259,14 @@ async function findWithRoleAndNameAndContentEnable(world, expectedRole, name, ex
         await (0, test_1.expect)(byRole).toBeEnabled();
     });
 }
+async function findWithRoleAndNameEnabled(world, expectedRole, name) {
+    expectedRole = encodeURIComponent(expectedRole);
+    await getPageOrElement(world).then(async (element) => {
+        const byRole = element.getByRole(expectedRole, { name: name, exact: true });
+        await (0, test_1.expect)(byRole).toHaveCount(1, { timeout: await getTimeout(world) });
+        await (0, test_1.expect)(byRole).toBeEnabled();
+    });
+}
 async function showAttributesInLocator(element) {
     const attributes = await element.evaluateHandle((aElement) => {
         const attributeNames = aElement.getAttributeNames();

package/dist/cucumber/step_definitions/playwright/generated/_en-generated-cucumber-steps-definition.js

@@ -357,13 +357,13 @@ function getConfigDir() {
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see an element with role {string} and name {string} and content {string} disabled`, async function (expectedRole, name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, expectedRole, name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, expectedRole, name, expectedTextContent);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
-(0, world_1.Then)(`I should see an element with role {string} and name {string} and content {string} not disabled`, async function (expectedRole, name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, expectedRole, name, expectedTextContent);
+(0, world_1.Then)(`I should see an element with role {string} and name {string} and content {string} enabled`, async function (expectedRole, name, expectedTextContent) {
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, expectedRole, name, expectedTextContent);
 });
 /**
  * Checks that an Html element exists with the specified aria-label attribute
@@ -492,6 +492,12 @@ function getConfigDir() {
         await expectTableToHaveContent(element, expectedElementsOfList, "cell");
     });
 });
+/**
+ * Checks that an Html element exists with [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types) `heading`, the specified [name](https://russmaxdesign.github.io/html-elements-names/) and title level
+ * */
+(0, world_1.Then)(`I should see a title named {string} with level {int}`, async function (name, level) {
+    await (0, core_engine_1.findWithRoleAndName)(this, "heading", name, { level });
+});
 function removeHeaderSeparatorLine(pExpectedElementsOfList) {
     const expectedElementsOfList = pExpectedElementsOfList.raw();
     if (expectedElementsOfList.length > 1) {

package/dist/cucumber/step_definitions/playwright/generated/_fr-generated-cucumber-steps-definition.js

@@ -356,14 +356,14 @@ function getConfigDir() {
 /**
  * Vérifie qu'un élément Html existe avec le [rôle accessible](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), le [nom accessible](https://russmaxdesign.github.io/html-elements-names/) et le contenu spécifiés, et avec l'attribut disabled à true
  * */
-(0, world_1.Then)(`je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string} inactif`, async function (expectedRole, name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, expectedRole, name, expectedTextContent);
+(0, world_1.Then)(`je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string} désactivé`, async function (expectedRole, name, expectedTextContent) {
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, expectedRole, name, expectedTextContent);
 });
 /**
  * Vérifie qu'un élément Html existe avec le [rôle accessible](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), le [nom accessible](https://russmaxdesign.github.io/html-elements-names/) et le contenu spécifiés et avec l'attribut disabled à false
  * */
-(0, world_1.Then)(`je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string} actif`, async function (expectedRole, name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, expectedRole, name, expectedTextContent);
+(0, world_1.Then)(`je dois voir un élément avec le rôle {string} et le nom {string} et pour contenu {string} activé`, async function (expectedRole, name, expectedTextContent) {
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, expectedRole, name, expectedTextContent);
 });
 /**
  * Vérifie qu'un élément Html existe avec l'attribut aria-label spécifié
@@ -492,6 +492,12 @@ function getConfigDir() {
         await expectTableToHaveContent(element, expectedElementsOfList, "cell");
     });
 });
+/**
+ * Vérifie l'existence d'un élément Html ayant le rôle `heading`, le [nom accessible](https://russmaxdesign.github.io/html-elements-names/) et le niveau spécifiés
+ * */
+(0, world_1.Then)(`je dois voir un titre nommé {string} avec le niveau {int}`, async function (name, level) {
+    await (0, core_engine_1.findWithRoleAndName)(this, "heading", name, { level });
+});
 function removeHeaderSeparatorLine(pExpectedElementsOfList) {
     const expectedElementsOfList = pExpectedElementsOfList.raw();
     if (expectedElementsOfList.length > 1) {

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_alert.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see an alert named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "alert", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "alert", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see an alert named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "alert", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see an alert named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "alert", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "alert", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see an alert named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "alert", name);
 });
 // End of Content Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_alertdialog.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see an alert dialog named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "alertdialog", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "alertdialog", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see an alert dialog named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "alertdialog", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see an alert dialog named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "alertdialog", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "alertdialog", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see an alert dialog named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "alertdialog", name);
 });
 // End of Content Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_application.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see an application named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "application", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "application", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see an application named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "application", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see an application named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "application", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "application", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see an application named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "application", name);
 });
 // End of Content Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_article.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see an article named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "article", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "article", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see an article named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "article", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see an article named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "article", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "article", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see an article named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "article", name);
 });
 // End of Content Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_banner.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see a banner named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "banner", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "banner", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see a banner named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "banner", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see a banner named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "banner", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "banner", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see a banner named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "banner", name);
 });
 // End of Content Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_button.js

@@ -81,13 +81,25 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see a button named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "button", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "button", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see a button named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "button", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see a button named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "button", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "button", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see a button named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "button", name);
 });
 // End of Content Section
 // Begin of Keyboard Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_cell.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see a cell named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "cell", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "cell", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see a cell named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "cell", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see a cell named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "cell", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "cell", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see a cell named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "cell", name);
 });
 // End of Content Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_checkbox.js

@@ -81,13 +81,25 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see a checkbox named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "checkbox", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "checkbox", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see a checkbox named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "checkbox", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see a checkbox named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "checkbox", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "checkbox", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see a checkbox named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "checkbox", name);
 });
 // End of Content Section
 // Begin of Keyboard Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_columnheader.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see a column header named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "columnheader", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "columnheader", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see a column header named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "columnheader", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see a column header named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "columnheader", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "columnheader", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see a column header named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "columnheader", name);
 });
 // End of Content Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_combobox.js

@@ -38,6 +38,14 @@ const test_1 = require("@playwright/test");
     await (0, core_engine_1.notFoundWithRoleAndName)(this, "combobox", name);
 });
 // End of General Section
+// Begin of Click Section
+/**
+ * Triggers a click on the element with role $roleId and the specified name
+ * */
+(0, world_1.When)(`I click on combo box named {string}`, async function (name) {
+    await (0, core_engine_1.click)(this, "combobox", name);
+});
+// End of Click Section
 // Begin of Type Section
 /**
  * Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)
@@ -73,13 +81,25 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see a combo box named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "combobox", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "combobox", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see a combo box named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "combobox", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see a combo box named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "combobox", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "combobox", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see a combo box named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "combobox", name);
 });
 // End of Content Section
 // Begin of Keyboard Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_command.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see a command named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "command", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "command", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see a command named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "command", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see a command named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "command", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "command", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see a command named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "command", name);
 });
 // End of Content Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_comment.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see a comment named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "comment", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "comment", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see a comment named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "comment", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see a comment named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "comment", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "comment", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see a comment named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "comment", name);
 });
 // End of Content Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_complementary.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see a complementary named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "complementary", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "complementary", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see a complementary named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "complementary", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see a complementary named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "complementary", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "complementary", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see a complementary named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "complementary", name);
 });
 // End of Content Section

package/dist/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_composite.js

@@ -73,12 +73,24 @@ const test_1 = require("@playwright/test");
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to true
  * */
 (0, world_1.Then)(`I should see a composite named {string} and containing {string} disabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentDisable)(this, "composite", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentDisabled)(this, "composite", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to true
+ * */
+(0, world_1.Then)(`I should see a composite named {string} disabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameDisabled)(this, "composite", name);
 });
 /**
  * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/) and content, and with the disabled attribute set to false
  * */
 (0, world_1.Then)(`I should see a composite named {string} and containing {string} enabled`, async function (name, expectedTextContent) {
-    await (0, core_engine_1.findWithRoleAndNameAndContentEnable)(this, "composite", name, expectedTextContent);
+    await (0, core_engine_1.findWithRoleAndNameAndContentEnabled)(this, "composite", name, expectedTextContent);
+});
+/**
+ * Checks that an Html element exists with the specified [accessible role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles#aria_role_types), [name](https://russmaxdesign.github.io/html-elements-names/), and with the disabled attribute set to false
+ * */
+(0, world_1.Then)(`I should see a composite named {string} enabled`, async function (name) {
+    await (0, core_engine_1.findWithRoleAndNameEnabled)(this, "composite", name);
 });
 // End of Content Section