@playq/core 0.2.77

package/dist/helper/actions/comm/utilityActions.js

@@ -0,0 +1,351 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptPassword = encryptPassword;
+exports.encryptText = encryptText;
+exports.encryptPasswordAndStore = encryptPasswordAndStore;
+exports.encryptTextAndStore = encryptTextAndStore;
+exports.decrypt = decrypt;
+exports.getRandomFromList = getRandomFromList;
+exports.removeLeadingZeroFromMonthAndDate = removeLeadingZeroFromMonthAndDate;
+exports.writeJsonToFile = writeJsonToFile;
+exports.toDollarAmount = toDollarAmount;
+exports.generateTotpTokenToVariable = generateTotpTokenToVariable;
+exports.wait = wait;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const allure = __importStar(require("allure-js-commons"));
+const global_1 = require("../../../global");
+const crypto = __importStar(require("../../util/utilities/cryptoUtil"));
+const totpHelper_1 = require("../../util/totp/totpHelper");
+function isPlaywrightRunner() { return process.env.TEST_RUNNER === 'playwright'; }
+const __allureAny_comm = allure;
+if (typeof __allureAny_comm.step !== 'function') {
+    __allureAny_comm.step = async (_name, fn) => await fn();
+}
+/**
+ * Comm: Encrypt-Password -text: {param} -options: {param}
+ *
+ * Encrypts the given text as a password and returns it with a "pwd." prefix.
+ *
+ * @param encryptText - The text to encrypt.
+ * @param options - Optional string or object of additional options (parsed if string).
+ * @returns A string prefixed with "pwd." followed by the encrypted value.
+ *
+ * @throws Error if `encryptText` is not a non-empty string.
+ *
+ */
+async function encryptPassword(encryptText, options) {
+    const options_json = typeof options === 'string' ? global_1.vars.parseLooseJson(options) : (options || {});
+    if (typeof encryptText !== 'string' || encryptText.length === 0) {
+        throw new Error('❌ encryptPassword: encryptText must be a non-empty string.');
+    }
+    const doEncrypt = async () => {
+        const encryptedText = crypto.encrypt(encryptText);
+        console.log('🔐 Encrypted Password:', 'pwd.' + encryptedText);
+        return 'pwd.' + encryptedText;
+    };
+    if (isPlaywrightRunner()) {
+        return await __allureAny_comm.step(`Comm: Encrypt-Password -text: [redacted] -options: ${JSON.stringify(options_json)}`, async () => await doEncrypt());
+    }
+    return await doEncrypt();
+}
+/**
+ * Comm: Encrypt-Text -text: {param} -options: {param}
+ *
+ * Encrypts the given text and returns it with an "enc." prefix.
+ *
+ * @param encryptText - The text to encrypt.
+ * @param options - Optional string or object of additional options (parsed if string).
+ * @returns A string prefixed with "enc." followed by the encrypted value.
+ *
+ * @throws Error if `encryptText` is not a non-empty string.
+ *
+ */
+async function encryptText(encryptText, options) {
+    const options_json = typeof options === 'string' ? global_1.vars.parseLooseJson(options) : (options || {});
+    if (typeof encryptText !== 'string' || encryptText.length === 0) {
+        throw new Error('❌ encryptText: encryptText must be a non-empty string.');
+    }
+    const doEncrypt = async () => {
+        const encryptedText = crypto.encrypt(encryptText);
+        console.log('🔐 Encrypted Text:', 'enc.' + encryptedText);
+        return 'enc.' + encryptedText;
+    };
+    if (isPlaywrightRunner()) {
+        return await __allureAny_comm.step(`Comm: Encrypt-Text -text: [redacted] -options: ${JSON.stringify(options_json)}`, async () => await doEncrypt());
+    }
+    return await doEncrypt();
+}
+/**
+ * Comm: Encrypt-Password -text: {param} and store in -variable: {param} -options: {param}
+ *
+ * Encrypts the given password, prefixes it with "pwd.", and stores it in a variable.
+ *
+ * @param encryptText - The plain text password to encrypt.
+ * @param varNameToStore - The name of the variable to store the encrypted password.
+ * @param options - Optional string or object of additional options (parsed if string).
+ *
+ * @throws Error if `encryptText` or `varNameToStore` are not non-empty strings.
+ *
+ */
+async function encryptPasswordAndStore(encryptText, varNameToStore, options) {
+    const options_json = typeof options === 'string' ? global_1.vars.parseLooseJson(options) : (options || {});
+    if (typeof encryptText !== 'string' || encryptText.length === 0) {
+        throw new Error('❌ encryptPasswordAndStore: encryptText must be a non-empty string.');
+    }
+    if (typeof varNameToStore !== 'string' || varNameToStore.trim().length === 0) {
+        throw new Error('❌ encryptPasswordAndStore: varNameToStore must be a non-empty string.');
+    }
+    const doEncryptAndStore = async () => {
+        const encryptedText = crypto.encrypt(encryptText);
+        console.log('🔐 Encrypted Text:', 'pwd.' + encryptedText);
+        global_1.vars.setValue(varNameToStore, 'pwd.' + encryptedText);
+        await global_1.comm.attachLog(`✅ Encrypted password stored in "${varNameToStore}"`, 'text/plain');
+    };
+    if (isPlaywrightRunner()) {
+        await __allureAny_comm.step(`Comm: Encrypt-Password and store -variable: ${varNameToStore} -options: ${JSON.stringify(options_json)}`, async () => await doEncryptAndStore());
+    }
+    else {
+        await doEncryptAndStore();
+    }
+}
+/**
+ * Comm: Encrypt -text: {param} and store in -variable: {param} -options: {param}
+ *
+ * Encrypts the given text, prefixes it with "enc.", and stores it in a variable.
+ *
+ * @param encryptText - The text to encrypt.
+ * @param varNameToStore - The variable name to store the encrypted text.
+ * @param options - Optional string or object of additional options (parsed if string).
+ *
+ * @throws Error if `encryptText` or `varNameToStore` are not non-empty strings.
+ *
+ */
+async function encryptTextAndStore(encryptText, varNameToStore, options) {
+    const options_json = typeof options === 'string' ? global_1.vars.parseLooseJson(options) : (options || {});
+    if (typeof encryptText !== 'string' || encryptText.length === 0) {
+        throw new Error('❌ encryptTextAndStore: encryptText must be a non-empty string.');
+    }
+    if (typeof varNameToStore !== 'string' || varNameToStore.trim().length === 0) {
+        throw new Error('❌ encryptTextAndStore: varNameToStore must be a non-empty string.');
+    }
+    const doEncryptAndStore = async () => {
+        const encryptedText = crypto.encrypt(encryptText);
+        console.log('🔐 Encrypted Text:', 'enc.' + encryptedText);
+        global_1.vars.setValue(varNameToStore, 'enc.' + encryptedText);
+        await global_1.comm.attachLog(`✅ Encrypted text stored in "${varNameToStore}"`, 'text/plain');
+    };
+    if (isPlaywrightRunner()) {
+        await __allureAny_comm.step(`Comm: Encrypt-Text and store -variable: ${varNameToStore} -options: ${JSON.stringify(options_json)}`, async () => await doEncryptAndStore());
+    }
+    else {
+        await doEncryptAndStore();
+    }
+}
+/**
+ * Comm: Decrypt -text: {param} and store in -variable: {param} -options: {param}
+ *
+ * Decrypts the given encrypted text and stores the result in a variable.
+ *
+ * @param encryptedText - The encrypted value to decrypt.
+ * @param varName - The variable name to store the decrypted result.
+ * @param options - Optional string or object of additional options (parsed if string).
+ *
+ * @throws Error if `encryptedText` or `varName` are not non-empty strings.
+ *
+ */
+async function decrypt(encryptedText, varName, options) {
+    const options_json = typeof options === 'string' ? global_1.vars.parseLooseJson(options) : (options || {});
+    if (typeof encryptedText !== 'string' || encryptedText.length === 0) {
+        throw new Error('❌ decrypt: encryptedText must be a non-empty string.');
+    }
+    if (typeof varName !== 'string' || varName.trim().length === 0) {
+        throw new Error('❌ decrypt: varName must be a non-empty string.');
+    }
+    const doDecryptAndStore = async () => {
+        const decryptedText = crypto.decrypt(encryptedText);
+        global_1.vars.setValue(varName, decryptedText);
+        await global_1.comm.attachLog(`✅ Decrypted value stored in "${varName}"`, 'text/plain');
+    };
+    if (isPlaywrightRunner()) {
+        await __allureAny_comm.step(`Comm: Decrypt -text: [redacted] and store in -variable: ${varName} -options: ${JSON.stringify(options_json)}`, async () => await doDecryptAndStore());
+    }
+    else {
+        await doDecryptAndStore();
+    }
+}
+/**
+ * Comm: Get-Random-From-List -arrayList: {param}
+ *
+ * Selects and returns a random item from a given non-empty array.
+ *
+ * @template T
+ * @param list - The array to select a random item from.
+ * @returns A randomly selected item from the array.
+ *
+ * @throws Error if the list is not a non-empty array.
+ *
+ */
+async function getRandomFromList(list) {
+    if (!Array.isArray(list) || list.length === 0) {
+        throw new Error("⚠️ getRandomFromList: list must be a non-empty array.");
+    }
+    const index = Math.floor(Math.random() * list.length);
+    return list[index];
+}
+/**
+ * Comm: Remove-Leading-Zero-From-Date -text: {param}
+ *
+ * Removes leading zeros from both the day and month in a date string of format DD/MM/YYYY.
+ * Example: '03/07/2025' => '3/7/2025'
+ * @param dateStr - The date string in DD/MM/YYYY format
+ * @returns The date string with leading zeros removed from day and month
+ *
+ * @throws Error if `dateStr` is not a non-empty string.
+ */
+async function removeLeadingZeroFromMonthAndDate(dateStr) {
+    if (typeof dateStr !== 'string' || dateStr.length === 0) {
+        throw new Error('❌ removeLeadingZeroFromMonthAndDate: dateStr must be a non-empty string.');
+    }
+    return dateStr.replace(/\b0(\d)/g, "$1");
+}
+/**
+ * Comm: Write-JSON-To-File -filePath: {param} -data: {param} -options: {param}
+ *
+ * Writes JSON data to a file with options to override, append, or wrap in array.
+ *
+ * @param filePath - The destination file path.
+ * @param data - The JSON data to write (object or array).
+ * @param options - { override, append, toArray }
+ *
+ * @throws Error if `filePath` is empty, if append mode file content is not a JSON array, or if both `override` and `append` are false.
+ */
+async function writeJsonToFile(filePath, data, options = { override: true, append: false, toArray: false }) {
+    const defaultOptions = { override: true, append: false, toArray: false };
+    const opts = { ...defaultOptions, ...options };
+    if (typeof filePath !== 'string' || filePath.trim().length === 0) {
+        throw new Error('❌ writeJsonToFile: filePath must be a non-empty string.');
+    }
+    const absPath = path.resolve(filePath);
+    if (opts.append) {
+        // Only works if file contains an array
+        let arr = [];
+        if (fs.existsSync(absPath)) {
+            const fileContent = fs.readFileSync(absPath, 'utf-8');
+            try {
+                arr = JSON.parse(fileContent);
+                if (!Array.isArray(arr))
+                    throw new Error('File does not contain a JSON array.');
+            }
+            catch {
+                throw new Error('File is not a valid JSON array.');
+            }
+        }
+        arr.push(data);
+        fs.writeFileSync(absPath, JSON.stringify(arr, null, 2), 'utf-8');
+        await global_1.comm.attachLog(`✅ JSON appended to file: ${absPath}`, 'text/plain');
+    }
+    else if (opts.override) {
+        // Overwrite or create new file
+        let out = data;
+        if (opts.toArray) {
+            out = Array.isArray(data) ? data : [data];
+        }
+        fs.writeFileSync(absPath, JSON.stringify(out, null, 2), 'utf-8');
+        await global_1.comm.attachLog(`✅ JSON written to file: ${absPath}`, 'text/plain');
+    }
+    else {
+        throw new Error('Either override or append must be true.');
+    }
+}
+/**
+ * Ensures the value is formatted as a currency string: $<amount>.00
+ * @param value - The input value (number or string)
+ * @returns {string} - Formatted as $<amount>.00
+ */
+function toDollarAmount(value) {
+    // Remove any non-numeric except dot
+    let num = typeof value === 'number'
+        ? value
+        : parseFloat(String(value).replace(/[^0-9.]/g, ''));
+    if (isNaN(num))
+        num = 0;
+    return `$${num.toFixed(2)}`;
+}
+/**
+ * Comm: Generate TOTP Token to variable -varName: {param} -options: {param}
+ *
+ * Generates a TOTP (Time-based One-Time Password) token using the provided secret and stores it in a variable.
+ *
+ * @param varName - The name of the variable to store the generated TOTP token.
+ * @param options - Optional string or object containing:
+ *   - secret: [string] The TOTP secret key (default: process.env.PLAYQ_TOTP_SECRET_KEY).
+ *
+ * @example
+ * Comm: Generate TOTP Token to variable -varName: "var.otp" -options: '{"secret":"MYSECRET"}'
+ */
+async function generateTotpTokenToVariable(varName, options) {
+    const options_json = typeof options === "string" ? global_1.vars.parseLooseJson(options) : options || {};
+    const { secret, step = 30, digits = 6, algorithm = "SHA-1" } = options_json;
+    if (isPlaywrightRunner()) {
+        await __allureAny_comm.step(`Comm: Generate TOTP Token to variable -varName: ${varName} -options: ${JSON.stringify(options_json)}`, async () => {
+            await doGenerateTotpTokenToVariable();
+        });
+    }
+    else {
+        await doGenerateTotpTokenToVariable();
+    }
+    async function doGenerateTotpTokenToVariable() {
+        let secretKey = process.env.PLAYQ_TOTP_SECRET_KEY || secret;
+        if (!secretKey) {
+            throw new Error('❌ PLAYQ_TOTP_SECRET_KEY not found in environment variables or in options');
+        }
+        if (secretKey.startsWith("enc.")) {
+            secretKey = global_1.vars.replaceVariables(`#{${secretKey}}`);
+        }
+        const totpHelper = new totpHelper_1.TOTPHelper(secretKey);
+        // Generate and return token
+        const token = totpHelper.generateToken();
+        global_1.vars.setValue(varName, token);
+    }
+}
+/**
+ * Alias: wait
+ * Wrapper to maintain compatibility for step names mapping.
+ */
+async function wait(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/helper/actions/commActions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file commActions.ts
+ *
+ * Communication actions gateway for logging, attachments, and utilities.
+ * Exposes a stable public surface while implementations live under ./comm/*.
+ *
+ * Key Features:
+ * - Allure-friendly logging and attachment helpers
+ * - Error context utilities for diagnostics
+ * - Backward-compatible re-exports via gateway
+ *
+ * Authors: Renish Kozhithottathil [Lead Automation Principal, NCS]
+ * Version: v1.0.0
+ *
+ * Note: This file adheres to the PlayQ Enterprise Automation Standards.
+ */
+export * from './comm/commonActions';
+export * from './comm/utilityActions';

package/dist/helper/actions/commActions.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @file commActions.ts
+ *
+ * Communication actions gateway for logging, attachments, and utilities.
+ * Exposes a stable public surface while implementations live under ./comm/*.
+ *
+ * Key Features:
+ * - Allure-friendly logging and attachment helpers
+ * - Error context utilities for diagnostics
+ * - Backward-compatible re-exports via gateway
+ *
+ * Authors: Renish Kozhithottathil [Lead Automation Principal, NCS]
+ * Version: v1.0.0
+ *
+ * Note: This file adheres to the PlayQ Enterprise Automation Standards.
+ */
+__exportStar(require("./comm/commonActions"), exports);
+__exportStar(require("./comm/utilityActions"), exports);

package/dist/helper/actions/commStepDefs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/actions/commStepDefs.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cucumber_1 = require("@cucumber/cucumber");
+const global_1 = require("../../global");
+// commonActions.ts
+(0, cucumber_1.Given)("Comm: Wait for milliseconds -seconds: {param}", async function (seconds) {
+    await global_1.comm.waitInMilliSeconds(parseInt(seconds));
+});
+(0, cucumber_1.Given)("Comm: Comment -text: {param}", async function (comment) {
+    await global_1.comm.comment(comment);
+});
+(0, cucumber_1.Given)("Comm: Encrypt password -text: {param} -options: {param}", async function (encryptedText, options) {
+    await global_1.comm.encryptPassword(encryptedText, options);
+});
+(0, cucumber_1.Given)("Comm: Encrypt text -text: {param} -options: {param}", async function (encryptedText, options) {
+    await global_1.comm.encryptText(encryptedText, options);
+});
+(0, cucumber_1.Given)("Comm: Encrypt password -text: {param} and store in -variable: {param} -options: {param}", async function (textToEncrypt, varToStore, options) {
+    await global_1.comm.encryptPasswordAndStore(textToEncrypt, varToStore, options);
+});
+(0, cucumber_1.Given)("Comm: Encrypt text -text: {param} and store in -variable: {param} -options: {param}", async function (textToEncrypt, varToStore, options) {
+    console.log('Text to encrypt:', textToEncrypt);
+    await global_1.comm.encryptTextAndStore(textToEncrypt, varToStore, options);
+});
+(0, cucumber_1.Given)("Comm: Decrypt -text: {param} and store in -variable: {param} -options: {param}", async function (encryptedText, varName, options) {
+    await global_1.comm.decrypt(encryptedText, varName, options);
+});
+(0, cucumber_1.Given)("Comm: Get random from list -arrayList: {param}", async function (list) {
+    const arrayList = JSON.parse(list);
+    await global_1.comm.getRandomFromList(arrayList);
+});
+(0, cucumber_1.Given)("Comm: Remove leading zero from date -text: {param}", async function (dateText) {
+    await global_1.comm.removeLeadingZeroFromMonthAndDate(dateText);
+});
+(0, cucumber_1.Given)("Comm: Write JSON to file -filePath: {param} -data: {param} -options: {param}", async function (filePath, data, options) {
+    await global_1.comm.writeJsonToFile(filePath, data, options);
+});
+(0, cucumber_1.Given)("Comm: Attach log -message: {param} -mimeType: {param} -msgType: {param}", async function (message, mimeType, msgType) {
+    await global_1.comm.attachLog(message, mimeType, msgType);
+});
+(0, cucumber_1.Given)("Comm: Store -value: {param} in -variable: {param} -options: {param}", async function (value, varName, options) {
+    await global_1.comm.storeValue(value, varName, options);
+});
+// utilityActions.ts
+(0, cucumber_1.Given)("Comm: To Dollar Amount -value: {param}", async function (value) {
+    const formatted = await global_1.comm.toDollarAmount(Number(value));
+    await global_1.comm.attachLog(`Formatted dollars: ${formatted}`, 'text/plain', 'COMM');
+});
+// TOTP token generation
+(0, cucumber_1.Given)("Comm: Generate TOTP Token to variable -varName: {param} -options: {param}", async function (varName, options) {
+    await global_1.comm.generateTotpTokenToVariable(varName, options);
+});
+// utilityActions.ts (alias wait)
+(0, cucumber_1.Given)("Comm: Wait -ms: {param}", async function (ms) {
+    const value = parseInt(String(ms));
+    await global_1.comm.wait(value);
+});

package/dist/helper/actions/stepGroupStepDefs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/actions/stepGroupStepDefs.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cucumber_1 = require("@cucumber/cucumber");
+(0, cucumber_1.Given)("Step Group: {param} {param}", async function (stepGroupName, stepGroupDesc) {
+    console.error(`❌ Step Group not available: ${stepGroupName} | ${stepGroupDesc}`);
+});
+(0, cucumber_1.Given)("- Step Group - START: {param} Desc: {param}", async function (stepGroupName, stepGroupDesc) {
+    console.log(`-> Step Group [START]: ${stepGroupName} | ${stepGroupDesc}`);
+});
+(0, cucumber_1.Given)("- Step Group - END: {string}", async function (stepGroupName) {
+    console.log(`-> Step Group [END]: ${stepGroupName}`);
+});
+(0, cucumber_1.Given)("Step Group: tests", async function (stepGroupName, stepGroupDesc) {
+    console.error(`❌ Step Group not available: ${stepGroupName} | ${stepGroupDesc}`);
+});

package/dist/helper/actions/web/alertActions.d.ts

@@ -0,0 +1,61 @@
+import { Page } from "@playwright/test";
+/**
+ * Web: Accept Alert -options: {param}
+ *
+ * Waits for a browser alert and accepts it. Attaches the alert text and optionally captures a screenshot.
+ *
+ * @param page - Playwright Page instance
+ * @param options - Optional JSON string or object:
+ *  - actionTimeout: [number] Timeout to wait for alert (default: config or 10000)
+ *  - screenshot: [boolean] Capture screenshot after handling the alert (default: false)
+ *  - screenshotText: [string] Description for screenshot (default: "")
+ *  - screenshotFullPage: [boolean] Full page screenshot (default: true)
+ * @throws Error if page is not initialized or alert does not appear within timeout
+ */
+export declare function acceptAlert(page: Page, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Web: Dismiss Alert -options: {param}
+ *
+ * Waits for a browser alert and dismisses it. Attaches the alert text and optionally captures a screenshot.
+ *
+ * @param page - Playwright Page instance
+ * @param options - Optional JSON string or object:
+ *  - actionTimeout: [number] Timeout to wait for alert (default: config or 10000)
+ *  - screenshot: [boolean] Capture screenshot after handling the alert (default: false)
+ *  - screenshotText: [string] Description for screenshot (default: "")
+ *  - screenshotFullPage: [boolean] Full page screenshot (default: true)
+ * @throws Error if page is not initialized or alert does not appear within timeout
+ */
+export declare function dismissAlert(page: Page, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Web: Fill Alert -text: {param} -options: {param}
+ *
+ * Waits for a prompt alert and fills it with the provided text. Attaches the alert text and optionally captures a screenshot.
+ *
+ * @param page - Playwright Page instance
+ * @param text - Text to send to alert prompt
+ * @param options - Optional JSON string or object:
+ *  - actionTimeout: [number] Timeout to wait for alert (default: config or 10000)
+ *  - screenshot: [boolean] Capture screenshot after handling the alert (default: false)
+ *  - screenshotText: [string] Description for screenshot (default: "")
+ *  - screenshotFullPage: [boolean] Full page screenshot (default: true)
+ * @throws Error if page is not initialized or alert does not appear within timeout
+ */
+export declare function fillAlert(page: Page, text: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Web: See Alert Text -expected: {param} -options: {param}
+ *
+ * Verifies the next alert message matches the expected text. Supports partial match and case-insensitive comparison.
+ *
+ * @param page - Playwright Page instance
+ * @param expected - Expected alert text
+ * @param options - Optional JSON string or object:
+ *  - actionTimeout: [number] Timeout to wait for alert (default: config or 10000)
+ *  - partialMatch: [boolean] If true, checks substring instead of exact match (default: false)
+ *  - ignoreCase: [boolean] Case-insensitive comparison (default: false)
+ *  - assert: [boolean] If false, logs failure but does not throw (default: true)
+ *  - screenshot: [boolean] Capture screenshot after verification (default: false)
+ *  - screenshotText: [string] Description for screenshot (default: "")
+ *  - screenshotFullPage: [boolean] Full page screenshot (default: true)
+ */
+export declare function seeAlertText(page: Page, expected: string, options?: string | Record<string, any>): Promise<void>;