@uuv/playwright 1.15.0 → 2.0.0

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) cell named {string}`, async function (this: World, name: string) {
+When(`within a cell named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "cell", name);
 });
 
-Then(`I should see a(n) cell named {string}`, async function (this: World, name: string)  {
+Then(`I should see a cell named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "cell", name);
 });
 
 Then(
-    `I should not see a(n) cell named {string}`,
+    `I should not see a cell named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "cell", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the cell named {string}`, async function(t
 
 
 Then(
-    `I should see a(n) cell named {string} and containing {string}`,
+    `I should see a cell named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "cell", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) cell named {string} and containing {string} disabled`,
+    `I should see a cell named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "cell", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) cell named {string} and containing {string} enabled`,
+    `I should see a cell named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "cell", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) checkbox named {string}`, async function (this: World, name: string) {
+When(`within a checkbox named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "checkbox", name);
 });
 
-Then(`I should see a(n) checkbox named {string}`, async function (this: World, name: string)  {
+Then(`I should see a checkbox named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "checkbox", name);
 });
 
 Then(
-    `I should not see a(n) checkbox named {string}`,
+    `I should not see a checkbox named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "checkbox", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the checkbox named {string}`, async functi
 
 
 Then(
-    `I should see a(n) checkbox named {string} and containing {string}`,
+    `I should see a checkbox named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "checkbox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) checkbox named {string} and containing {string} disabled`,
+    `I should see a checkbox named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "checkbox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) checkbox named {string} and containing {string} enabled`,
+    `I should see a checkbox named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "checkbox", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) column header named {string}`, async function (this: World, name: string) {
+When(`within a column header named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "columnheader", name);
 });
 
-Then(`I should see a(n) column header named {string}`, async function (this: World, name: string)  {
+Then(`I should see a column header named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "columnheader", name);
 });
 
 Then(
-    `I should not see a(n) column header named {string}`,
+    `I should not see a column header named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "columnheader", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the column header named {string}`, async f
 
 
 Then(
-    `I should see a(n) column header named {string} and containing {string}`,
+    `I should see a column header named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "columnheader", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) column header named {string} and containing {string} disabled`,
+    `I should see a column header named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "columnheader", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) column header named {string} and containing {string} enabled`,
+    `I should see a column header named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "columnheader", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) combo box named {string}`, async function (this: World, name: string) {
+When(`within a combo box named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "combobox", name);
 });
 
-Then(`I should see a(n) combo box named {string}`, async function (this: World, name: string)  {
+Then(`I should see a combo box named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "combobox", name);
 });
 
 Then(
-    `I should not see a(n) combo box named {string}`,
+    `I should not see a combo box named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "combobox", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the combo box named {string}`, async funct
 
 
 Then(
-    `I should see a(n) combo box named {string} and containing {string}`,
+    `I should see a combo box named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "combobox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) combo box named {string} and containing {string} disabled`,
+    `I should see a combo box named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "combobox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) combo box named {string} and containing {string} enabled`,
+    `I should see a combo box named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "combobox", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) command named {string}`, async function (this: World, name: string) {
+When(`within a command named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "command", name);
 });
 
-Then(`I should see a(n) command named {string}`, async function (this: World, name: string)  {
+Then(`I should see a command named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "command", name);
 });
 
 Then(
-    `I should not see a(n) command named {string}`,
+    `I should not see a command named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "command", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the command named {string}`, async functio
 
 
 Then(
-    `I should see a(n) command named {string} and containing {string}`,
+    `I should see a command named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "command", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) command named {string} and containing {string} disabled`,
+    `I should see a command named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "command", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) command named {string} and containing {string} enabled`,
+    `I should see a command named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "command", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) comment named {string}`, async function (this: World, name: string) {
+When(`within a comment named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "comment", name);
 });
 
-Then(`I should see a(n) comment named {string}`, async function (this: World, name: string)  {
+Then(`I should see a comment named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "comment", name);
 });
 
 Then(
-    `I should not see a(n) comment named {string}`,
+    `I should not see a comment named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "comment", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the comment named {string}`, async functio
 
 
 Then(
-    `I should see a(n) comment named {string} and containing {string}`,
+    `I should see a comment named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "comment", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) comment named {string} and containing {string} disabled`,
+    `I should see a comment named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "comment", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) comment named {string} and containing {string} enabled`,
+    `I should see a comment named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "comment", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) complementary named {string}`, async function (this: World, name: string) {
+When(`within a complementary named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "complementary", name);
 });
 
-Then(`I should see a(n) complementary named {string}`, async function (this: World, name: string)  {
+Then(`I should see a complementary named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "complementary", name);
 });
 
 Then(
-    `I should not see a(n) complementary named {string}`,
+    `I should not see a complementary named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "complementary", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the complementary named {string}`, async f
 
 
 Then(
-    `I should see a(n) complementary named {string} and containing {string}`,
+    `I should see a complementary named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "complementary", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) complementary named {string} and containing {string} disabled`,
+    `I should see a complementary named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "complementary", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) complementary named {string} and containing {string} enabled`,
+    `I should see a complementary named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "complementary", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) composite named {string}`, async function (this: World, name: string) {
+When(`within a composite named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "composite", name);
 });
 
-Then(`I should see a(n) composite named {string}`, async function (this: World, name: string)  {
+Then(`I should see a composite named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "composite", name);
 });
 
 Then(
-    `I should not see a(n) composite named {string}`,
+    `I should not see a composite named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "composite", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the composite named {string}`, async funct
 
 
 Then(
-    `I should see a(n) composite named {string} and containing {string}`,
+    `I should see a composite named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "composite", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) composite named {string} and containing {string} disabled`,
+    `I should see a composite named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "composite", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) composite named {string} and containing {string} enabled`,
+    `I should see a composite named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "composite", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) contentinfo named {string}`, async function (this: World, name: string) {
+When(`within a contentinfo named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "contentinfo", name);
 });
 
-Then(`I should see a(n) contentinfo named {string}`, async function (this: World, name: string)  {
+Then(`I should see a contentinfo named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "contentinfo", name);
 });
 
 Then(
-    `I should not see a(n) contentinfo named {string}`,
+    `I should not see a contentinfo named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "contentinfo", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the contentinfo named {string}`, async fun
 
 
 Then(
-    `I should see a(n) contentinfo named {string} and containing {string}`,
+    `I should see a contentinfo named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "contentinfo", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) contentinfo named {string} and containing {string} disabled`,
+    `I should see a contentinfo named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "contentinfo", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) contentinfo named {string} and containing {string} enabled`,
+    `I should see a contentinfo named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "contentinfo", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) definition named {string}`, async function (this: World, name: string) {
+When(`within a definition named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "definition", name);
 });
 
-Then(`I should see a(n) definition named {string}`, async function (this: World, name: string)  {
+Then(`I should see a definition named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "definition", name);
 });
 
 Then(
-    `I should not see a(n) definition named {string}`,
+    `I should not see a definition named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "definition", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the definition named {string}`, async func
 
 
 Then(
-    `I should see a(n) definition named {string} and containing {string}`,
+    `I should see a definition named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "definition", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) definition named {string} and containing {string} disabled`,
+    `I should see a definition named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "definition", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) definition named {string} and containing {string} enabled`,
+    `I should see a definition named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "definition", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) dialog named {string}`, async function (this: World, name: string) {
+When(`within a dialog named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "dialog", name);
 });
 
-Then(`I should see a(n) dialog named {string}`, async function (this: World, name: string)  {
+Then(`I should see a dialog named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "dialog", name);
 });
 
 Then(
-    `I should not see a(n) dialog named {string}`,
+    `I should not see a dialog named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "dialog", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the dialog named {string}`, async function
 
 
 Then(
-    `I should see a(n) dialog named {string} and containing {string}`,
+    `I should see a dialog named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "dialog", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) dialog named {string} and containing {string} disabled`,
+    `I should see a dialog named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "dialog", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) dialog named {string} and containing {string} enabled`,
+    `I should see a dialog named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "dialog", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) directory named {string}`, async function (this: World, name: string) {
+When(`within a directory named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "directory", name);
 });
 
-Then(`I should see a(n) directory named {string}`, async function (this: World, name: string)  {
+Then(`I should see a directory named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "directory", name);
 });
 
 Then(
-    `I should not see a(n) directory named {string}`,
+    `I should not see a directory named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "directory", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the directory named {string}`, async funct
 
 
 Then(
-    `I should see a(n) directory named {string} and containing {string}`,
+    `I should see a directory named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "directory", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) directory named {string} and containing {string} disabled`,
+    `I should see a directory named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "directory", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) directory named {string} and containing {string} enabled`,
+    `I should see a directory named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "directory", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) document named {string}`, async function (this: World, name: string) {
+When(`within a document named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "document", name);
 });
 
-Then(`I should see a(n) document named {string}`, async function (this: World, name: string)  {
+Then(`I should see a document named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "document", name);
 });
 
 Then(
-    `I should not see a(n) document named {string}`,
+    `I should not see a document named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "document", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the document named {string}`, async functi
 
 
 Then(
-    `I should see a(n) document named {string} and containing {string}`,
+    `I should see a document named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "document", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) document named {string} and containing {string} disabled`,
+    `I should see a document named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "document", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) document named {string} and containing {string} enabled`,
+    `I should see a document named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "document", name, expectedTextContent);
     }

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

@@ -31,16 +31,16 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`Within a(n) flow named {string}`, async function (this: World, name: string) {
+When(`within a flow named {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "feed", name);
 });
 
-Then(`I should see a(n) flow named {string}`, async function (this: World, name: string)  {
+Then(`I should see a flow named {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "feed", name);
 });
 
 Then(
-    `I should not see a(n) flow named {string}`,
+    `I should not see a flow named {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "feed", name);
     }
@@ -57,21 +57,21 @@ When(`I type the sentence {string} in the flow named {string}`, async function(t
 
 
 Then(
-    `I should see a(n) flow named {string} and containing {string}`,
+    `I should see a flow named {string} and containing {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "feed", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) flow named {string} and containing {string} disabled`,
+    `I should see a flow named {string} and containing {string} disabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "feed", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) flow named {string} and containing {string} enabled`,
+    `I should see a flow named {string} and containing {string} enabled`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "feed", name, expectedTextContent);
     }