@uuv/playwright 3.44.0 → 3.46.0

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_command.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the command named {string}`, async function(
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a command named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("command", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_comment.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the comment named {string}`, async function(
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a comment named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("comment", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_complementary.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the complementary named {string}`, async fun
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a complementary named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("complementary", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_composite.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the composite named {string}`, async functio
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a composite named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("composite", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_contentinfo.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the contentinfo named {string}`, async funct
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a contentinfo named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("contentinfo", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_definition.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the definition named {string}`, async functi
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a definition named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("definition", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_dialog.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the dialog named {string}`, async function(t
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a dialog named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("dialog", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_directory.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the directory named {string}`, async functio
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a directory named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("directory", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_document.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the document named {string}`, async function
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a document named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("document", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_feed.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the flow named {string}`, async function(tex
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a flow named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("feed", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_figure.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the figure named {string}`, async function(t
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a figure named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("figure", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_form.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the form named {string}`, async function(tex
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a form named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("form", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_generic.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the generic named {string}`, async function(
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a generic named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("generic", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_grid.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the grid named {string}`, async function(tex
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a grid named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("grid", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_gridcell.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the grid cell named {string}`, async functio
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a grid cell named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("gridcell", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_group.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the group named {string}`, async function(te
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a group named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("group", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_heading.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the title named {string}`, async function(te
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a title named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("heading", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_img.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the image named {string}`, async function(te
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see an image named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("img", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_landmark.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the landmark named {string}`, async function
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a landmark named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("landmark", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_link.ts

@@ -101,6 +101,18 @@ When(`I enter the value {string} in the link named {string}`, async function(tex
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a link named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("link", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_listbox.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the list box named {string}`, async function
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a list box named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("listbox", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_listitem.ts

@@ -101,6 +101,18 @@ When(`I enter the value {string} in the list item named {string}`, async functio
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a list item named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("listitem", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_log.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the log named {string}`, async function(text
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a log named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("log", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_main.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the main named {string}`, async function(tex
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a main named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("main", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_mark.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the mark named {string}`, async function(tex
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a mark named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("mark", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_math.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the math named {string}`, async function(tex
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a math named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("math", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_menu.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the menu named {string}`, async function(tex
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a menu named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("menu", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_menubar.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the menubar named {string}`, async function(
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a menubar named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("menubar", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_menuitem.ts

@@ -101,6 +101,18 @@ When(`I enter the value {string} in the menuitem named {string}`, async function
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a menuitem named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("menuitem", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_menuitemcheckbox.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the menuitemcheckbox named {string}`, async
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a menuitemcheckbox named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("menuitemcheckbox", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_menuitemradio.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the menuitemradio named {string}`, async fun
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a menuitemradio named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("menuitemradio", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section
 

package/src/cucumber/step_definitions/playwright/generated/enriched/en/_en-generated-steps-definition_meter.ts

@@ -91,6 +91,18 @@ When(`I enter the value {string} in the counter named {string}`, async function(
     });
 });
 
+/**
+ * key.then.element.withRoleAndNameAndValue
+ * */
+When(`I should see a counter named {string} with value {string}`, async function(name: string, expectedValue: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("meter", { name: name, exact: true });
+        await expect(byRole).toHaveCount(1, { timeout: await getTimeout(this) });
+        await expect(byRole).toHaveValue(expectedValue, { timeout: await getTimeout(this) });
+        await deleteCookieByName(this, COOKIE_NAME.SELECTED_ELEMENT);
+    });
+});
+
 // End of Type Section
 // Begin of Content Section