@uuv/playwright 1.14.3 → 1.16.0

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_note.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de note nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de l'note nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "note", name);
 });
 
-Then(`je dois voir un(e) note nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une note nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "note", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) note nommé(e) {string}`,
+    `je ne dois pas voir une note nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "note", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans l'note nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("note", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) note nommé(e) {string} et contenant {string}`,
+    `je dois voir une note nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "note", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) note nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une note nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "note", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) note nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une note nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "note", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_option.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de option nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de l'option nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "option", name);
 });
 
-Then(`je dois voir un(e) option nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une option nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "option", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) option nommé(e) {string}`,
+    `je ne dois pas voir une option nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "option", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans l'option nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("option", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) option nommé(e) {string} et contenant {string}`,
+    `je dois voir une option nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "option", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) option nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une option nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "option", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) option nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une option nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "option", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_presentation.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de présentation nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la présentation nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "presentation", name);
 });
 
-Then(`je dois voir un(e) présentation nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une présentation nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "presentation", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) présentation nommé(e) {string}`,
+    `je ne dois pas voir une présentation nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "presentation", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans la présentation nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("presentation", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) présentation nommé(e) {string} et contenant {string}`,
+    `je dois voir une présentation nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "presentation", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) présentation nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une présentation nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "presentation", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) présentation nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une présentation nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "presentation", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_progressbar.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de barre de progression nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la barre de progression nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "progressbar", name);
 });
 
-Then(`je dois voir un(e) barre de progression nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une barre de progression nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "progressbar", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) barre de progression nommé(e) {string}`,
+    `je ne dois pas voir une barre de progression nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "progressbar", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans la barre de progression nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("progressbar", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) barre de progression nommé(e) {string} et contenant {string}`,
+    `je dois voir une barre de progression nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "progressbar", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) barre de progression nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une barre de progression nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "progressbar", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) barre de progression nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une barre de progression nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "progressbar", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_radio.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de radio nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur du bouton radio nommé {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "radio", name);
 });
 
-Then(`je dois voir un(e) radio nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir un bouton radio nommé {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "radio", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) radio nommé(e) {string}`,
+    `je ne dois pas voir un bouton radio nommé {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "radio", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans le bouton radio nommé {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("radio", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) radio nommé(e) {string} et contenant {string}`,
+    `je dois voir un bouton radio nommé {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "radio", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) radio nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir un bouton radio nommé {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "radio", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) radio nommé(e) {string} et contenant {string} actif`,
+    `je dois voir un bouton radio nommé {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "radio", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_radiogroup.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de groupe de radios nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur du groupe de boutons radios nommé {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "radiogroup", name);
 });
 
-Then(`je dois voir un(e) groupe de radios nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir un groupe de boutons radios nommé {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "radiogroup", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) groupe de radios nommé(e) {string}`,
+    `je ne dois pas voir un groupe de boutons radios nommé {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "radiogroup", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans le groupe de boutons radios nommé {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("radiogroup", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) groupe de radios nommé(e) {string} et contenant {string}`,
+    `je dois voir un groupe de boutons radios nommé {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "radiogroup", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) groupe de radios nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir un groupe de boutons radios nommé {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "radiogroup", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) groupe de radios nommé(e) {string} et contenant {string} actif`,
+    `je dois voir un groupe de boutons radios nommé {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "radiogroup", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_range.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de plage nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la plage nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "range", name);
 });
 
-Then(`je dois voir un(e) plage nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une plage nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "range", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) plage nommé(e) {string}`,
+    `je ne dois pas voir une plage nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "range", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans la plage nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("range", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) plage nommé(e) {string} et contenant {string}`,
+    `je dois voir une plage nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "range", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) plage nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une plage nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "range", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) plage nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une plage nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "range", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_region.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de région nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la région nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "region", name);
 });
 
-Then(`je dois voir un(e) région nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une région nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "region", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) région nommé(e) {string}`,
+    `je ne dois pas voir une région nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "region", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans la région nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("region", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) région nommé(e) {string} et contenant {string}`,
+    `je dois voir une région nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "region", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) région nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une région nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "region", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) région nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une région nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "region", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_roletype.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de type de rôle nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur du type de rôle nommé {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "roletype", name);
 });
 
-Then(`je dois voir un(e) type de rôle nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir un type de rôle nommé {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "roletype", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) type de rôle nommé(e) {string}`,
+    `je ne dois pas voir un type de rôle nommé {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "roletype", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans le type de rôle nommé {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("roletype", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) type de rôle nommé(e) {string} et contenant {string}`,
+    `je dois voir un type de rôle nommé {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "roletype", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) type de rôle nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir un type de rôle nommé {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "roletype", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) type de rôle nommé(e) {string} et contenant {string} actif`,
+    `je dois voir un type de rôle nommé {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "roletype", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_row.ts

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 import { World } from "../../../../../preprocessor/run/world";
+import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de rangée nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la rangée nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "row", name);
 });
 
-Then(`je dois voir un(e) rangée nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une rangée nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "row", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) rangée nommé(e) {string}`,
+    `je ne dois pas voir une rangée nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "row", name);
     }
 );
 
+When(`je saisie le(s) mot(s) {string} dans la rangée nommée {string}`, async function(this: World, textToType: string, name: string) {
+    await getPageOrElement(this).then(async (element) => {
+        const byRole = await element.getByRole("row", { name: name, includeHidden: true, exact: true });
+        await expect(byRole).toHaveCount(1);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 Then(
-    `je dois voir un(e) rangée nommé(e) {string} et contenant {string}`,
+    `je dois voir une rangée nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "row", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) rangée nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une rangée nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "row", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) rangée nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une rangée nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "row", name, expectedTextContent);
     }