ff-automationv2 2.2.36-beta.0 → 2.2.36-beta.2

package/dist/core/main/actionHandlerFactory.js

@@ -0,0 +1,1489 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActionHandlers = createActionHandlers;
+const executor_js_1 = require("../../automation/actions/executor.js");
+const logData_js_1 = require("../../utils/logger/logData.js");
+const capability_js_1 = require("../../utils/browserCap/capability.js");
+const path_1 = __importDefault(require("path"));
+const systemCapabilities_js_1 = require("../../utils/browserCap/systemCapabilities.js");
+function createActionHandlers(context) {
+    let isAndroidInitialized = false;
+    const requireExecutor = () => {
+        if (!context.executor) {
+            throw new Error("Browser not initialized.");
+        }
+        return context.executor;
+    };
+    const withExecutor = (fn) => async (result) => {
+        try {
+            const executor = requireExecutor();
+            if (result) {
+                executor.setStepContext(result.stepIndex, result.currentStep, result.stepsInputData || context.stepsInputData, result.manualStep, result.returnTypeVariableName, result.variableName);
+            }
+            await fn(executor, result);
+        }
+        catch (error) {
+            logData_js_1.logger.error("Error in createActionHandlers", error);
+            throw error;
+        }
+    };
+    return {
+        open: async (result) => {
+            try {
+                if (context.browserOpened) {
+                    logData_js_1.logger.info("Browser already opened, skipping...");
+                    return;
+                }
+                const keywords = result?.keywords || [];
+                const pathKeyword = keywords.find((k) => k.startsWith("path:"));
+                const profileKeyword = keywords.find((k) => k.startsWith("profile:"));
+                const capsKeywords = keywords
+                    .filter((k) => k.startsWith("caps:"))
+                    .map((k) => k.replace(/^caps:/, ""));
+                let pathValue;
+                let profileValue;
+                if (pathKeyword) {
+                    const rawPath = pathKeyword.replace(/^path:/, "");
+                    const pathParts = rawPath.split(/[\\/]+/);
+                    pathValue = path_1.default.join(...pathParts);
+                }
+                if (profileKeyword) {
+                    profileValue = profileKeyword.replace(/^profile:/, "");
+                }
+                await context.session.open(pathValue, profileValue, capsKeywords);
+                context.executor = new executor_js_1.ActionExecutor(await context.session.getCurrentDriver(), context.scriptAppender, context.locator, context.activePlatform, context.adbPath);
+                const rawBrowserName = context.request.browserName.toLowerCase();
+                let resolvedBrowserName = "chrome";
+                if (rawBrowserName.includes("firefox")) {
+                    resolvedBrowserName = "firefox";
+                }
+                else if (rawBrowserName.includes("edge")) {
+                    resolvedBrowserName = "edge";
+                }
+                else if (rawBrowserName.includes("safari")) {
+                    resolvedBrowserName = "safari";
+                }
+                const capsObj = (0, capability_js_1.getCapabilities)(resolvedBrowserName, pathValue, profileValue, capsKeywords);
+                for (const value of Object.values(capsObj)) {
+                    if (value && typeof value === "object" && "prefs" in value) {
+                        const prefs = value.prefs;
+                        for (const key of systemCapabilities_js_1.systemCapability[resolvedBrowserName]) {
+                            delete prefs[key];
+                        }
+                    }
+                }
+                let exactCommands = [];
+                let exactPrefs = {};
+                if (resolvedBrowserName === "chrome") {
+                    exactCommands = capsObj["goog:chromeOptions"]?.args || [];
+                    exactPrefs = capsObj["goog:chromeOptions"]?.prefs || {};
+                }
+                else if (resolvedBrowserName === "edge") {
+                    exactCommands = capsObj["ms:edgeOptions"]?.args || [];
+                    exactPrefs = capsObj["ms:edgeOptions"]?.prefs || {};
+                }
+                else if (resolvedBrowserName === "firefox") {
+                    exactCommands = capsObj["moz:firefoxOptions"]?.args || [];
+                    exactPrefs = capsObj["moz:firefoxOptions"]?.prefs || {};
+                }
+                const prefKeys = Object.keys(exactPrefs);
+                const hasArgs = exactCommands.length > 0;
+                const hasPrefs = prefKeys.length > 0;
+                const isLinux = process.platform === 'linux';
+                if (isLinux && exactCommands.length === 1) {
+                    context.scriptAppender.add(async () => ({
+                        nlpName: "Open Browser",
+                        elementsData: [],
+                        stepInputs: []
+                    }));
+                }
+                else {
+                    if (hasArgs || hasPrefs) {
+                        context.scriptAppender.add(async () => ({
+                            nlpName: "BrowserOptionsCreateInstance",
+                            elementsData: [],
+                            stepInputs: []
+                        }));
+                        if (hasArgs) {
+                            for (const command of exactCommands) {
+                                if (process.platform === 'linux' && /--ozone-platform\b/.test(command)) {
+                                    continue;
+                                }
+                                context.scriptAppender.add(async () => ({
+                                    nlpName: "BrowserOptionsAddArguments",
+                                    elementsData: [],
+                                    stepInputs: [command]
+                                }));
+                            }
+                        }
+                        if (hasPrefs) {
+                            context.scriptAppender.add(async () => ({
+                                nlpName: "MapCreateEmptyMap",
+                                elementsData: [],
+                                stepInputs: []
+                            }));
+                            for (const key of prefKeys) {
+                                const value = exactPrefs[key];
+                                context.scriptAppender.add(async () => ({
+                                    nlpName: "MapPut",
+                                    elementsData: [],
+                                    stepInputs: [key, String(value)]
+                                }));
+                            }
+                            context.scriptAppender.add(async () => ({
+                                nlpName: "BrowserOptionsSetExperimentalOption",
+                                elementsData: [],
+                                stepInputs: ["prefs"]
+                            }));
+                        }
+                        context.scriptAppender.add(async () => ({
+                            nlpName: "OpenBrowser",
+                            elementsData: [],
+                            stepInputs: []
+                        }));
+                    }
+                    else {
+                        context.scriptAppender.add(async () => ({
+                            nlpName: "Open Browser",
+                            elementsData: [],
+                            stepInputs: []
+                        }));
+                    }
+                }
+                context.browserOpened = true;
+            }
+            catch (error) {
+                logData_js_1.logger.error("Error in createActionHandlers", error);
+                throw error;
+            }
+        },
+        switchToAndroid: async (result) => {
+            try {
+                let androidDriver;
+                try {
+                    androidDriver = await context.mobileSession.getCurrentDriver();
+                }
+                catch {
+                    if (!context.request.isCloud) {
+                        let deviceId = context.request.realDeviceId;
+                        if (!deviceId) {
+                            const { execFileSync } = await Promise.resolve().then(() => __importStar(require("child_process")));
+                            const output = execFileSync(context.adbPath, ["devices"], {
+                                encoding: "utf8",
+                            });
+                            const devices = output
+                                .split("\n")
+                                .slice(1) // Skip "List of devices attached"
+                                .map(line => line.trim())
+                                .filter(line => line.endsWith("\tdevice"));
+                            if (devices.length === 0) {
+                                throw new Error("No Android device connected.");
+                            }
+                            if (devices.length > 1) {
+                                throw new Error("Multiple Android devices connected. Please specify a realDeviceId.");
+                            }
+                            deviceId = devices[0].split("\t")[0];
+                            context.request.realDeviceId = deviceId;
+                        }
+                        logData_js_1.logger.info("Using device:", deviceId);
+                    }
+                    await context.initializeMobileDriver(result.keywords);
+                    androidDriver = await context.mobileSession.getCurrentDriver();
+                }
+                context.executor = new executor_js_1.ActionExecutor(androidDriver, context.scriptAppender, context.locator, "android", context.adbPath);
+                context.activePlatform = "android";
+                if (!isAndroidInitialized) {
+                    isAndroidInitialized = true;
+                    // context.scriptAppender.add(async () => ({
+                    //     nlpName: "CreateCapabilitiesInstance",
+                    //     elementsData: [],
+                    //     stepInputs: []
+                    // }));
+                    // context.scriptAppender.add(async () => ({
+                    //     nlpName: "MOB_OpenMobileApplication",
+                    //     elementsData: [],
+                    //     stepInputs: ["http://localhost:4723/wd/hub", "10", JSON.stringify(capability)]
+                    // }));
+                }
+            }
+            catch (error) {
+                logData_js_1.logger.error("Unable to switch to Android", error);
+                throw error;
+            }
+        },
+        switchToWeb: async () => {
+            try {
+                try {
+                    const webDriver = await context.session.getCurrentDriver();
+                    context.executor = new executor_js_1.ActionExecutor(webDriver, context.scriptAppender, context.locator, "web", context.adbPath);
+                }
+                catch {
+                    logData_js_1.logger.info("Web driver not initialized. Skipping executor creation.");
+                }
+                context.activePlatform = "web";
+            }
+            catch (error) {
+                logData_js_1.logger.error("Unable to switch to web", error);
+                throw error;
+            }
+        },
+        openApp: async (result) => {
+            try {
+                const isIOS = context.activePlatform === "ios";
+                const appPackage = result.keywords
+                    .find((item) => item.startsWith("appPackage:"))
+                    ?.substring("appPackage:".length);
+                const appActivity = result.keywords
+                    .find((item) => item.startsWith("appActivity:"))
+                    ?.substring("appActivity:".length);
+                await context.mobileSession.launchApp(appPackage, appActivity);
+                // Check whether there is any capability other than appPackage/appActivity
+                const hasAdditionalCapabilities = result.keywords.some((item) => !item.startsWith("appPackage:") &&
+                    !item.startsWith("appActivity:"));
+                if (!isIOS && hasAdditionalCapabilities) {
+                    // Create capabilities instance
+                    context.scriptAppender.add(async () => ({
+                        nlpName: "MOB_CreateCapabilitiesInstance",
+                        elementsData: [],
+                        stepInputs: []
+                    }));
+                    // Add every capability, including appPackage and appActivity
+                    for (const capability of result.keywords) {
+                        const [key, ...valueParts] = capability.split(":");
+                        const value = valueParts.join(":");
+                        context.scriptAppender.add(async () => ({
+                            nlpName: "MOB_SetCapability",
+                            elementsData: [],
+                            stepInputs: [key, value]
+                        }));
+                    }
+                    // Open mobile application
+                    context.scriptAppender.add(async () => ({
+                        nlpName: "MOB_OpenMobileApplication",
+                        elementsData: [],
+                        stepInputs: [10]
+                    }));
+                }
+                else {
+                    // Normal flow
+                    context.scriptAppender.add(async () => ({
+                        nlpName: isIOS ? "Open iOS App" : "Open Android App",
+                        elementsData: [],
+                        stepInputs: isIOS
+                            ? [
+                                context.request.realDeviceId,
+                                context.request.platformVersion,
+                                appPackage
+                            ]
+                            : [
+                                appPackage,
+                                appActivity
+                            ]
+                    }));
+                }
+            }
+            catch (error) {
+                logData_js_1.logger.error("Error in createActionHandlers", error);
+                throw error;
+            }
+        },
+        close: async () => {
+            try {
+                await context.session.close();
+                context.scriptAppender.add(async () => ({
+                    nlpName: "Close Browser",
+                    elementsData: [],
+                    stepInputs: []
+                }));
+            }
+            catch (error) {
+                logData_js_1.logger.error("Error in createActionHandlers", error);
+                throw error;
+            }
+        },
+        closeApp: async () => {
+            try {
+                await context.mobileSession.close();
+                const nlpName = context.activePlatform === "ios" ? "IOS_CloseApp" : "MOB_CloseApp";
+                context.scriptAppender.add(async () => ({
+                    nlpName: nlpName,
+                    elementsData: [],
+                    stepInputs: []
+                }));
+            }
+            catch (error) {
+                logData_js_1.logger.error("Error in createActionHandlers", error);
+                throw error;
+            }
+        },
+        navigate: async (result) => {
+            try {
+                if (!context.browserOpened) {
+                    logData_js_1.logger.info("Browser not initialized, auto-opening before navigate...");
+                    await context.session.open();
+                    context.executor = new executor_js_1.ActionExecutor(await context.session.getCurrentDriver(), context.scriptAppender, context.locator, context.activePlatform, context.adbPath);
+                    context.browserOpened = true;
+                    context.scriptAppender.add(async () => ({
+                        nlpName: "Open Browser",
+                        elementsData: [],
+                        stepInputs: []
+                    }));
+                }
+                const executor = requireExecutor();
+                await executor.navigate(result.keywords[0]);
+            }
+            catch (error) {
+                logData_js_1.logger.error("Error in navigate handler", error);
+                throw error;
+            }
+        },
+        maximize: withExecutor(async (executor) => {
+            await executor.maximize();
+        }),
+        minimize: withExecutor(async (executor) => {
+            await executor.minimize();
+        }),
+        navigateBack: withExecutor(async (executor) => {
+            await executor.goBack();
+        }),
+        refresh: withExecutor(async (executor) => {
+            await executor.refresh();
+        }),
+        Sleep: withExecutor(async (executor, result) => {
+            await executor.wait(result.value);
+        }),
+        switchToFrame: withExecutor(async (executor, result) => {
+            await executor.switchToFrame(result.selector, result.frames, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex, result.usedElementNames, result.skipRecording);
+        }),
+        Click: withExecutor(async (executor, result) => {
+            await executor.click(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        Select: withExecutor(async (executor, result) => {
+            await executor.click(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        RightClick: withExecutor(async (executor, result) => {
+            await executor.rightClick(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        DoubleClick: withExecutor(async (executor, result) => {
+            await executor.doubleClick(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        WaitAndClick: withExecutor(async (executor, result) => {
+            await executor.waitAndClick(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        ClickNTimes: withExecutor(async (executor, result) => {
+            await executor.clickNTimes(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        ClickUsingJS: withExecutor(async (executor, result) => {
+            await executor.clickUsingJS(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        SendKeys: withExecutor(async (executor, result) => {
+            await executor.enterInput(result.selector, result.value, result.fireflinkIndex, result.pageDOM, result.elementName, result.elementType, result.stepIndex, result.filteredSteps, result.variableName);
+        }),
+        EnterDataAndPressKey: withExecutor(async (executor, result) => {
+            await executor.enterInputAndPress(result.selector, result.value, result.fireflinkIndex, result.pageDOM, result.elementName, result.elementType);
+        }),
+        SendKeys_shadow: withExecutor(async (executor, result) => {
+            await executor.enterInputShadow(result.selector, result.value, result.fireflinkIndex, result.pageDOM, result.elementName, result.elementType);
+        }),
+        Click_shadow: withExecutor(async (executor, result) => {
+            await executor.clickShadowElement(result.selector, result.fireflinkIndex, result.pageDOM, result.elementName, result.elementType);
+        }),
+        GetText_shadow: withExecutor(async (executor, result) => {
+            await executor.getTextShadowElement(result.selector, result.fireflinkIndex, result.pageDOM, result.elementName, result.elementType);
+        }),
+        VerifyText_shadow: withExecutor(async (executor, result) => {
+            await executor.verifyTextShadowElement(result.selector, result.value, result.fireflinkIndex, result.pageDOM, result.elementName, result.elementType);
+        }),
+        VerifyPartialText_shadow: withExecutor(async (executor, result) => {
+            await executor.verifyPartialTextShadowElement(result.selector, result.value, result.fireflinkIndex, result.pageDOM, result.elementName, result.elementType);
+        }),
+        upload_shadow: withExecutor(async (executor, result) => {
+            await executor.uploadShadowElement(result.selector, result.value, result.fireflinkIndex, result.pageDOM, result.elementName, result.elementType);
+        }),
+        EnterInputUsingJS: withExecutor(async (executor, result) => {
+            await executor.enterInputUsingJS(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        Builtin_DragAndDropToElement: withExecutor(async (executor, result) => {
+            await executor.dragAndDropToElement(result.selector1, result.selector2, result.fireflinkIndex1, result.fireflinkIndex2, result.pageDOM, result.elementName1, result.elementName2, result.elementType1, result.elementType2);
+        }),
+        WaitAndSendKeys: withExecutor(async (executor, result) => {
+            await executor.waitAndEnter(result.selector, result.value, result.fireflinkIndex, result.pageDOM, result.elementName, result.elementType);
+        }),
+        Clear: withExecutor(async (executor, result) => {
+            await executor.clear(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        ClearThenEnterInput: withExecutor(async (executor, result) => {
+            await executor.clearAndEnter(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        upload: withExecutor(async (executor, result) => {
+            await executor.uploadFilePathUsingRobot(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        SwitchToNewTabBasedOnTitle: withExecutor(async (executor, result) => {
+            await executor.switchToNewTabBasedOnTitle(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        SwitchToNewTabBasedOnUrl: withExecutor(async (executor, result) => {
+            await executor.switchToTabBasedOnUrl(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        SwitchToNewWindowBasedOnTitle: withExecutor(async (executor, result) => {
+            await executor.switchToNewWindowBasedOnTitle(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        SwitchToNewWindowBasedOnURL: withExecutor(async (executor, result) => {
+            await executor.switchToWindowBasedOnURL(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        SwitchToParentWindow: withExecutor(async (executor, result) => {
+            await executor.switchToParentWindow(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        SwitchToWindowIfTitleContainsString: withExecutor(async (executor, result) => {
+            await executor.switchToWindowIfTitleContainsString(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        SwitchToNewWindowIfUrlContainsString: withExecutor(async (executor, result) => {
+            await executor.switchToWindowIfUrlContainsString(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyElementIsDisplayedInSpecifiedTime: withExecutor(async (executor, result) => {
+            await executor.verifyElementIsDisplayedInSpecifiedTime(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyElementIsEnabledInSpecifiedTime: withExecutor(async (executor, result) => {
+            await executor.verifyElementIsEnabledInSpecifiedTime(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyElementIsSelectedInSpecifiedTime: withExecutor(async (executor, result) => {
+            await executor.verifyElementIsSelectedInSpecifiedTime(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyText: withExecutor(async (executor, result) => {
+            await executor.verifyText(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType, result.variableName);
+        }),
+        VerifyPartialText: withExecutor(async (executor, result) => {
+            await executor.verifyPartialText(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType, result.variableName);
+        }),
+        VerifyElementIsDisplayed: withExecutor(async (executor, result) => {
+            await executor.VerifyElementIsDisplayed(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyElementIsNotDisplayed: withExecutor(async (executor, result) => {
+            await executor.VerifyElementIsNotDisplayed(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyElementIsSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyElementIsSelected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyElementIsEnabled: withExecutor(async (executor, result) => {
+            await executor.VerifyElementIsEnabled(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyElementIsDisabled: withExecutor(async (executor, result) => {
+            await executor.VerifyElementIsDisabled(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        ScrollToElement: withExecutor(async (executor, result) => {
+            await executor.scrollToElement(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        ScrollVerticallyTillElementIsVisible: withExecutor(async (executor, result) => {
+            await executor.scrollVerticallyTillElementIsVisible(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        ScrollHorizontallyTillElementIsVisible: withExecutor(async (executor, result) => {
+            await executor.scrollHorizontallyTillElementIsVisible(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyElementIsClickable: withExecutor(async (executor, result) => {
+            await executor.verifyElementIsClickable(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyElementNotContainsText: withExecutor(async (executor, result) => {
+            await executor.verifyElementNotContainsText(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfStatusCodeOfALinkIsStatusCode: withExecutor(async (executor, result) => {
+            await executor.verifyIfStatusCodeOfALinkIsStatusCode(result.value);
+        }),
+        VerifyIfStatusCodeOfAllLinksIsStatusCode: withExecutor(async (executor, result) => {
+            await executor.verifyIfStatusCodesOfLinks(result.value);
+        }),
+        VerifyIfOptionWithVisibleTextIsSelected: withExecutor(async (executor, result) => {
+            await executor.verifyIfOptionWithVisibleTextIsSelected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfOptionWithTextIsDeselected: withExecutor(async (executor, result) => {
+            await executor.verifyIfOptionWithTextIsDeselected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyPerformanceScore: withExecutor(async (executor, result) => {
+            await executor.verifyPerformanceScore(result.value);
+        }),
+        VerifyAccessibilityScore: withExecutor(async (executor, result) => {
+            await executor.verifyAccessibilityScore(result.value);
+        }),
+        VerifyBestPracticesScore: withExecutor(async (executor, result) => {
+            await executor.verifyBestPracticesScore(result.value);
+        }),
+        VerifySeoScore: withExecutor(async (executor, result) => {
+            await executor.verifySeoScore(result.value);
+        }),
+        VerifyPwaScore: withExecutor(async (executor, result) => {
+            await executor.verifyPwaScore(result.value);
+        }),
+        VerifyHexCodeForGivenXYCoordinates: withExecutor(async (executor, result) => {
+            await executor.verifyHexCodeForGivenXYCoordinates(result.value);
+        }),
+        GetPageTitle: withExecutor(async (executor) => {
+            await executor.getPageTitle();
+        }),
+        GetAttribute: withExecutor(async (executor, result) => {
+            await executor.getAttribute(result.pageDOM, result.selector, result.value, result.attributeType, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetTagName: withExecutor(async (executor, result) => {
+            await executor.getTagName(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetListBoxSize: withExecutor(async (executor, result) => {
+            await executor.getListBoxSize(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetWrappedOptionFromListBoxAsText: withExecutor(async (executor, result) => {
+            await executor.getWrappedOptionFromListBoxAsText(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetBrowserVersion: withExecutor(async (executor) => {
+            await executor.getBrowserVersion();
+        }),
+        GetAllBrokenLinks: withExecutor(async (executor) => {
+            await executor.getAllBrokenLinks();
+        }),
+        GetHeightOfBrowserWindow: withExecutor(async (executor) => {
+            await executor.getHeightOfBrowserWindow();
+        }),
+        GetWidthOfBrowser: withExecutor(async (executor) => {
+            await executor.getWidthOfBrowser();
+        }),
+        GetXLocationOfBrowserWindow: withExecutor(async (executor) => {
+            await executor.getXLocationOfBrowserWindow();
+        }),
+        GetYLocationOfBrowserWindow: withExecutor(async (executor) => {
+            await executor.getYLocationOfBrowserWindow();
+        }),
+        GetAllBrokenLinkCount: withExecutor(async (executor) => {
+            await executor.getAllBrokenLinkCount();
+        }),
+        GetCurrentWindowHandle: withExecutor(async (executor) => {
+            await executor.getCurrentWindowHandle();
+        }),
+        GetAllWindowHandles: withExecutor(async (executor) => {
+            await executor.getAllWindowHandles();
+        }),
+        GetURLPresentInAddressBar: withExecutor(async (executor) => {
+            await executor.getURLPresentInAddressBar();
+        }),
+        GetHTMLCodeOfPage: withExecutor(async (executor) => {
+            await executor.getHTMLCodeOfPage();
+        }),
+        GetBrowserCount: withExecutor(async (executor) => {
+            await executor.getBrowserCount();
+        }),
+        GetImplicitTimeOut: withExecutor(async (executor) => {
+            await executor.getImplicitTimeOut();
+        }),
+        GetCapabilityNames: withExecutor(async (executor) => {
+            await executor.getCapabilityNames();
+        }),
+        GetCurrentSystemDate: withExecutor(async (executor) => {
+            await executor.getCurrentSystemDate();
+        }),
+        GetCurrentDayOfTheWeek: withExecutor(async (executor) => {
+            await executor.getCurrentDayOfTheWeek();
+        }),
+        GetCurrentSystemTime: withExecutor(async (executor) => {
+            await executor.getCurrentSystemTime();
+        }),
+        GetCurrentSecondsFromCurrentSystemTime: withExecutor(async (executor) => {
+            await executor.getCurrentSecondsFromCurrentSystemTime();
+        }),
+        GetCurrentSystemYear: withExecutor(async (executor) => {
+            await executor.getCurrentSystemYear();
+        }),
+        GetHourFromCurrentSystemTime: withExecutor(async (executor) => {
+            await executor.getHourFromCurrentSystemTime();
+        }),
+        GetMinuteFromCurrentSystemTime: withExecutor(async (executor) => {
+            await executor.getMinuteFromCurrentSystemTime();
+        }),
+        GetNumberOfLinksPresentInCurrentPage: withExecutor(async (executor) => {
+            await executor.getNumberOfLinksPresentInCurrentPage();
+        }),
+        GetAllConsoleWarnings: withExecutor(async (executor) => {
+            await executor.getAllConsoleWarnings();
+        }),
+        GetAllConsoleInformation: withExecutor(async (executor) => {
+            await executor.getAllConsoleInformation();
+        }),
+        GetAllConsoleErrors: withExecutor(async (executor) => {
+            await executor.getAllConsoleErrors();
+        }),
+        GetAllCookieValues: withExecutor(async (executor) => {
+            await executor.getAllCookieValues();
+        }),
+        GetSizeOfBrowserWindow: withExecutor(async (executor) => {
+            await executor.getSizeOfBrowserWindow();
+        }),
+        GetCurrentSystemMonth: withExecutor(async (executor) => {
+            await executor.getCurrentSystemMonth();
+        }),
+        GetCurrentSystemDay: withExecutor(async (executor) => {
+            await executor.getCurrentSystemDay();
+        }),
+        GetAllConsoleLogs: withExecutor(async (executor) => {
+            await executor.getAllConsoleLogs();
+        }),
+        GetTotalNumberOfCookies: withExecutor(async (executor) => {
+            await executor.getTotalNumberOfCookies();
+        }),
+        GetAllBrokenImages: withExecutor(async (executor) => {
+            await executor.getAllBrokenImages();
+        }),
+        GetAllCookieNames: withExecutor(async (executor) => {
+            await executor.getAllCookieNames();
+        }),
+        GetNumberOfWorkingLinksFromCurrentPage: withExecutor(async (executor) => {
+            await executor.getNumberOfWorkingLinksFromCurrentPage();
+        }),
+        GetNumberOfBrokenImages: withExecutor(async (executor) => {
+            await executor.getNumberOfBrokenImages();
+        }),
+        GetWorkingLinksFromCurrentPage: withExecutor(async (executor) => {
+            await executor.getWorkingLinksFromCurrentPage();
+        }),
+        BrowserWindowGetPosition: withExecutor(async (executor) => {
+            await executor.browserWindowGetPosition();
+        }),
+        GetClipBoardText: withExecutor(async (executor) => {
+            await executor.getClipBoardText();
+        }),
+        GetDriverInstance: withExecutor(async (executor) => {
+            await executor.getDriverInstance();
+        }),
+        GetFullPaintTime: withExecutor(async (executor) => {
+            await executor.getFullPaintTime();
+        }),
+        GetFirstContentfulPaint: withExecutor(async (executor) => {
+            await executor.getFirstContentfulPaint();
+        }),
+        GetLargestContentfulPaint: withExecutor(async (executor) => {
+            await executor.getLargestContentfulPaint();
+        }),
+        GetNetworkRouteTime: withExecutor(async (executor) => {
+            await executor.getNetworkRouteTime();
+        }),
+        GetPerformanceMetrics: withExecutor(async (executor) => {
+            await executor.getPerformanceMetrics();
+        }),
+        GetUserHomeDirectory: withExecutor(async (executor) => {
+            await executor.getUserHomeDirectory();
+        }),
+        GetSingleApiStatusCode: withExecutor(async (executor, result) => {
+            await executor.getSingleApiStatusCode(result.value);
+        }),
+        GetSingleApiResponse: withExecutor(async (executor, result) => {
+            await executor.getSingleApiResponse(result.value);
+        }),
+        GetSingleApiResponseTime: withExecutor(async (executor, result) => {
+            await executor.getSingleApiResponseTime(result.value);
+        }),
+        GetCollectiveApiStatusCode: withExecutor(async (executor, result) => {
+            await executor.getCollectiveApiStatusCode(result.value);
+        }),
+        GetCollectiveApiResponseTime: withExecutor(async (executor, result) => {
+            await executor.getCollectiveApiResponseTime(result.value);
+        }),
+        GetDataFromApiResponseForJsonPath: withExecutor(async (executor, result) => {
+            await executor.getDataFromApiResponseForJsonPath(result.value);
+        }),
+        GetSingleApiRequestPayload: withExecutor(async (executor, result) => {
+            await executor.getSingleApiRequestPayload(result.value);
+        }),
+        GetValueFromLocalStorage: withExecutor(async (executor, result) => {
+            await executor.getValueFromLocalStorage(result.value);
+        }),
+        GetValueByCookieName: withExecutor(async (executor, result) => {
+            await executor.getValueByCookieName(result.value);
+        }),
+        GetValueOfSystemVariable: withExecutor(async (executor, result) => {
+            await executor.getValueOfSystemVariable(result.value);
+        }),
+        GetSystemProperty: withExecutor(async (executor, result) => {
+            await executor.getSystemProperty(result.value);
+        }),
+        GetStringDataFromLocalFile: withExecutor(async (executor, result) => {
+            await executor.getStringDataFromLocalFile(result.value);
+        }),
+        ScrollPageToSpecificLocation: withExecutor(async (executor, result) => {
+            await executor.scrollPageToSpecificLocation(result.value);
+        }),
+        GetDateWithGivenFormat: withExecutor(async (executor, result) => {
+            await executor.getDateWithGivenFormat(result.value);
+        }),
+        GetTunnelIdentifier: withExecutor(async (executor, result) => {
+            await executor.getTunnelIdentifier(result.value);
+        }),
+        GetBestPracticesScore: withExecutor(async (executor, result) => {
+            await executor.getBestPracticesScore(result.value);
+        }),
+        GetPwaScore: withExecutor(async (executor, result) => {
+            await executor.getPwaScore(result.value);
+        }),
+        GetDataFromApiRequestHeaderForJsonPath: withExecutor(async (executor, result) => {
+            await executor.getDataFromApiRequestHeaderForJsonPath(result.value);
+        }),
+        GetSeoScore: withExecutor(async (executor, result) => {
+            await executor.getSeoScore(result.value);
+        }),
+        WaitTillAlertIsPresent: withExecutor(async (executor) => {
+            await executor.waitTillAlertIsPresent();
+        }),
+        VerifyAlertPopUpMessageContainsString: withExecutor(async (executor, result) => {
+            await executor.verifyAlertPopUpMessageContainsString(result.value);
+        }),
+        VerifyTextPresentOnAlertPopup: withExecutor(async (executor, result) => {
+            await executor.verifyTextPresentOnAlertPopup(result.value);
+        }),
+        EnterDataToAlert: withExecutor(async (executor, result) => {
+            await executor.enterDataToAlert(result.value);
+        }),
+        ClickOkOnAlertPopup: withExecutor(async (executor) => {
+            await executor.clickOkOnAlertPopup();
+        }),
+        ClickCancelOnAlertPopup: withExecutor(async (executor) => {
+            await executor.clickCancelOnAlertPopup();
+        }),
+        VerifyAlertPopupIsDisplayed: withExecutor(async (executor, result) => {
+            await executor.verifyAlertPopupIsDisplayed(result.value);
+        }),
+        GetTextPresentOnAlertPopup: withExecutor(async (executor) => {
+            await executor.getTextPresentOnAlertPopup();
+        }),
+        switchToDefaultContent: withExecutor(async (executor) => {
+            await executor.switchToDefaultContent();
+        }),
+        GetText: withExecutor(async (executor, result) => {
+            await executor.getText(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetCssValue: withExecutor(async (executor, result) => {
+            await executor.getCssValue(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetSize: withExecutor(async (executor, result) => {
+            await executor.getSize(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyAttributeValue: withExecutor(async (executor, result) => {
+            await executor.VerifyAttributeValue(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyPartialAttributeValue: withExecutor(async (executor, result) => {
+            await executor.VerifyPartialAttributeValue(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyTagName: withExecutor(async (executor, result) => {
+            await executor.VerifyTagName(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyTitleOfCurrentPage: withExecutor(async (executor, result) => {
+            await executor.VerifyTitleOfCurrentPage(result.value);
+        }),
+        VerifyPartialTitleOfCurrentPage: withExecutor(async (executor, result) => {
+            await executor.VerifyPartialTitleOfCurrentPage(result.value);
+        }),
+        VerifyNavigateURL: withExecutor(async (executor, result) => {
+            await executor.VerifyNavigateURL(result.value);
+        }),
+        VerifyValueOfElementIsString: withExecutor(async (executor, result) => {
+            await executor.VerifyValueOfElementIsString(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyValueOfElementContainsString: withExecutor(async (executor, result) => {
+            await executor.VerifyValueOfElementContainsString(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyValueOfElementIsCleared: withExecutor(async (executor, result) => {
+            await executor.VerifyValueOfElementIsCleared(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyXLocationOfElement: withExecutor(async (executor, result) => {
+            await executor.VerifyXLocationOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyYLocationOfElement: withExecutor(async (executor, result) => {
+            await executor.VerifyYLocationOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyHeightOfWebElement: withExecutor(async (executor, result) => {
+            await executor.VerifyHeightOfWebElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyWidthOfElement: withExecutor(async (executor, result) => {
+            await executor.VerifyWidthOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyRadioButtonIsSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyRadioButtonIsSelected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyRadioButtonIsNotSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyRadioButtonIsNotSelected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyBrowserWindowWidth: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowWidth(result.value);
+        }),
+        VerifyBrowserWindowHeight: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowHeight(result.value);
+        }),
+        VerifyBrowserWindowXLocation: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowXLocation(result.value);
+        }),
+        VerifyBrowserWindowYLocation: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowYLocation(result.value);
+        }),
+        VerifyBrowserHtmlCodeContainsString: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserHtmlCodeContainsString(result.value);
+        }),
+        VerifyIfCookieNameIsAdded: withExecutor(async (executor, result) => {
+            await executor.VerifyIfCookieNameIsAdded(result.value);
+        }),
+        VerifyIfCookieNameIsDeleted: withExecutor(async (executor, result) => {
+            await executor.VerifyIfCookieNameIsDeleted(result.value);
+        }),
+        VerifyIfLinkIsBroken: withExecutor(async (executor, result) => {
+            await executor.VerifyIfLinkIsBroken(result.value);
+        }),
+        VerifyCssAttributeValue: withExecutor(async (executor, result) => {
+            await executor.VerifyCssAttributeValue(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoIsPlaying: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoIsPlaying(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyNumberOfElementsByTagName: withExecutor(async (executor, result) => {
+            await executor.VerifyNumberOfElementsByTagName(result.value);
+        }),
+        VerifyNumberOfElementsByXpath: withExecutor(async (executor, result) => {
+            await executor.VerifyNumberOfElementsByXpath(result.value);
+        }),
+        VerifyListBoxOptionsAreSorted: withExecutor(async (executor, result) => {
+            await executor.VerifyListBoxOptionsAreSorted(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfOptionWithIndexIsSelectedInListBox: withExecutor(async (executor, result) => {
+            await executor.VerifyIfOptionWithIndexIsSelectedInListBox(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfOptionWithIndexIsDeselectedInElement: withExecutor(async (executor, result) => {
+            await executor.VerifyIfOptionWithIndexIsDeselectedInElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyAllOptionsAreSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyAllOptionsAreSelected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyAllOptionsAreDeselected: withExecutor(async (executor, result) => {
+            await executor.VerifyAllOptionsAreDeselected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfOptionWithValueIsSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyIfOptionWithValueIsSelected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfOptionWithValueIsDeselected: withExecutor(async (executor, result) => {
+            await executor.VerifyIfOptionWithValueIsDeselected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfSpecifiedOptionIsSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyIfSpecifiedOptionIsSelected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyThatSpecifiedOptionIsNotSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyThatSpecifiedOptionIsNotSelected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfGivenOptionIsDuplicate: withExecutor(async (executor, result) => {
+            await executor.VerifyIfGivenOptionIsDuplicate(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyTitleInAllPage: withExecutor(async (executor, result) => {
+            await executor.VerifyTitleInAllPage(result.value);
+        }),
+        VerifyLinkNavigatesToTitle: withExecutor(async (executor, result) => {
+            await executor.VerifyLinkNavigatesToTitle(result.value);
+        }),
+        VerifyBrowserWindowTitleContainsString: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowTitleContainsString(result.value);
+        }),
+        VerifyBrowserWindowUrlIsString: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowUrlIsString(result.value);
+        }),
+        VerifyUrlIsString: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowUrlIsString(result.value);
+        }),
+        VerifyBrowserWindowUrlContainsExpectedUrl: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowUrlContainsExpectedUrl(result.value);
+        }),
+        VerifyCheckBoxIsNotSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyCheckBoxIsNotSelected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyCheckBoxIsSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyCheckBoxIsSelected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyBrowserWindowTitleIsString: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowTitleIsString(result.value);
+        }),
+        VerifyIfBrowserWindowIsClosed: withExecutor(async (executor) => {
+            await executor.VerifyIfBrowserWindowIsClosed();
+        }),
+        VerifyAllBrowserWindowsClosed: withExecutor(async (executor) => {
+            await executor.VerifyAllBrowserWindowsClosed();
+        }),
+        VerifyIfAllCookiesAreDeleted: withExecutor(async (executor) => {
+            await executor.VerifyIfAllCookiesAreDeleted();
+        }),
+        VerifyIfCookieObjectIsPresent: withExecutor(async (executor, result) => {
+            await executor.VerifyIfCookieObjectIsPresent(result.value);
+        }),
+        VerifyIfXAndYCoordinateOfElement: withExecutor(async (executor, result) => {
+            await executor.VerifyIfXAndYCoordinateOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoIsMuted: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoIsMuted(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoIsPaused: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoIsPaused(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoEnded: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoEnded(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoPlayingInMute: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoPlayingInMute(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoPlayingInUnmute: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoPlayingInUnmute(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfAudioIsPlaying: withExecutor(async (executor, result) => {
+            await executor.VerifyIfAudioIsPlaying(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfAudioIsPaused: withExecutor(async (executor, result) => {
+            await executor.VerifyIfAudioIsPaused(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfAudioIsMuted: withExecutor(async (executor, result) => {
+            await executor.VerifyIfAudioIsMuted(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfAudioEnded: withExecutor(async (executor, result) => {
+            await executor.VerifyIfAudioEnded(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfLinkIsWorking: withExecutor(async (executor, result) => {
+            await executor.VerifyIfLinkIsWorking(result.value);
+        }),
+        VerifyIfLinksAreWorking: withExecutor(async (executor, result) => {
+            await executor.VerifyIfLinksAreWorking(result.value);
+        }),
+        VerifyIfLinksAreBroken: withExecutor(async (executor, result) => {
+            await executor.VerifyIfLinksAreBroken(result.value);
+        }),
+        VerifyIfImageIsBroken: withExecutor(async (executor, result) => {
+            await executor.VerifyIfImageIsBroken(result.value);
+        }),
+        VerifyAllBrokenImages: withExecutor(async (executor) => {
+            await executor.VerifyAllBrokenImages();
+        }),
+        GetRect: withExecutor(async (executor, result) => {
+            await executor.getRect(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetLocation: withExecutor(async (executor, result) => {
+            await executor.getLocation(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetXLocationOfWebElement: withExecutor(async (executor, result) => {
+            await executor.getXLocationOfWebElement(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetYLocationOfWebElement: withExecutor(async (executor, result) => {
+            await executor.getYLocationOfWebElement(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetWidthOfWebElement: withExecutor(async (executor, result) => {
+            await executor.getWidthOfWebElement(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetHeightOfWebElement: withExecutor(async (executor, result) => {
+            await executor.getHeightOfWebElement(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetWrappedElement: withExecutor(async (executor, result) => {
+            await executor.getWrappedElement(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        //         GetTextFromListOfWebElements: withExecutor(async (executor, result) => {
+        //             await executor.getTextFromListOfWebElements(
+        //                 result.selector
+        //             );
+        //         }),
+        GetOptions: withExecutor(async (executor, result) => {
+            await executor.getOptions(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetFirstSelectedOption: withExecutor(async (executor, result) => {
+            await executor.getFirstSelectedOption(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAllSelectedOptions: withExecutor(async (executor, result) => {
+            await executor.getAllSelectedOptions(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAllTheOptionsFromListBoxAsText: withExecutor(async (executor, result) => {
+            await executor.getAllTheOptionsFromListBoxAsText(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAllTheOptionsFromListBoxAsTextInSortedOrder: withExecutor(async (executor, result) => {
+            await executor.getAllTheOptionsFromListBoxAsTextInSortedOrder(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetTheFirstSelectedOptionFromListBoxAsText: withExecutor(async (executor, result) => {
+            await executor.getTheFirstSelectedOptionFromListBoxAsText(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAllTheSelectedOptionsFromListBoxAsText: withExecutor(async (executor, result) => {
+            await executor.getAllTheSelectedOptionsFromListBoxAsText(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetScreenshot: withExecutor(async (executor, result) => {
+            await executor.getScreenshot(result.value);
+        }),
+        GetScreenshotAs: withExecutor(async (executor, result) => {
+            await executor.getScreenshotAs(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetListOfElementsFromLocatorTypeLocatorValue: withExecutor(async (executor, result) => {
+            await executor.getListOfElementsFromLocatorTypeLocatorValue(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetVideoMediaSource: withExecutor(async (executor, result) => {
+            await executor.getVideoMediaSource(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetVideoMediaLength: withExecutor(async (executor, result) => {
+            await executor.getVideoMediaLength(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetVideoCurrentSeekTime: withExecutor(async (executor, result) => {
+            await executor.getVideoCurrentSeekTime(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetVideoCurrentPlaybackRate: withExecutor(async (executor, result) => {
+            await executor.getVideoCurrentPlaybackRate(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetVideoDefaultPlaybackRate: withExecutor(async (executor, result) => {
+            await executor.getVideoDefaultPlaybackRate(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetVideoCurrentVolume: withExecutor(async (executor, result) => {
+            await executor.getVideoCurrentVolume(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetVideoDecodedByte: withExecutor(async (executor, result) => {
+            await executor.getVideoDecodedByte(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAudioMediaSource: withExecutor(async (executor, result) => {
+            await executor.getAudioMediaSource(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAudioMediaLength: withExecutor(async (executor, result) => {
+            await executor.getAudioMediaLength(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAudioCurrentSeekTime: withExecutor(async (executor, result) => {
+            await executor.getAudioCurrentSeekTime(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAudioCurrentPlaybackRate: withExecutor(async (executor, result) => {
+            await executor.getAudioCurrentPlaybackRate(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAudioDefaultPlaybackRate: withExecutor(async (executor, result) => {
+            await executor.getAudioDefaultPlaybackRate(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAudioCurrentVolume: withExecutor(async (executor, result) => {
+            await executor.getAudioCurrentVolume(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        GetAudioDecodedByte: withExecutor(async (executor, result) => {
+            await executor.getAudioDecodedByte(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        MOB_OpenNotification: withExecutor(async (executor) => {
+            await executor.OpenNotification();
+        }),
+        MOB_PressEnterKey: withExecutor(async (executor) => {
+            await executor.PressEnterKey();
+        }),
+        MOB_ResetApp: withExecutor(async (executor) => {
+            await executor.ResetApp();
+        }),
+        MOB_HideKeyboard: withExecutor(async (executor) => {
+            await executor.HideKeyboard();
+        }),
+        MOB_SetEmulatorPowerStateOff: withExecutor(async (executor) => {
+            await executor.SetEmulatorPowerStateOff();
+        }),
+        MOB_OpenChromeBrowser: withExecutor(async (executor) => {
+            await executor.OpenChromeBrowser();
+        }),
+        MOB_SetDeviceOrientationAsPortrait: withExecutor(async (executor) => {
+            await executor.SetDeviceOrientationAsPortrait();
+        }),
+        MOB_SetDeviceOrientationAsLandscape: withExecutor(async (executor) => {
+            await executor.SetDeviceOrientationAsLandscape();
+        }),
+        MOB_SetEmulatorPowerStateOn: withExecutor(async (executor) => {
+            await executor.SetEmulatorPowerStateOn();
+        }),
+        MOB_AirplaneModeSwitchOn: withExecutor(async (executor) => {
+            await executor.AirplaneModeSwitchOn();
+        }),
+        MOB_LockDevice: withExecutor(async (executor) => {
+            await executor.LockDevice();
+        }),
+        MOB_WifiSwitchOff: withExecutor(async (executor) => {
+            await executor.WifiSwitchOff();
+        }),
+        MOB_WifiSwitchOn: withExecutor(async (executor) => {
+            await executor.WifiSwitchOn();
+        }),
+        Continue: withExecutor(async (executor) => {
+            await executor.Continue();
+        }),
+        MOB_GpsSwitchOn: withExecutor(async (executor) => {
+            await executor.GpsSwitchOn();
+        }),
+        MOB_GpsSwitchOff: withExecutor(async (executor) => {
+            await executor.GpsSwitchOff();
+        }),
+        MOB_RestartCurrentDevice: withExecutor(async (executor) => {
+            await executor.RestartCurrentDevice();
+        }),
+        MOB_AirplaneModeSwitchOff: withExecutor(async (executor) => {
+            await executor.AirplaneModeSwitchOff();
+        }),
+        Break: withExecutor(async (executor) => {
+            await executor.Break();
+        }),
+        MOB_PressHomeKey: withExecutor(async (executor) => {
+            await executor.PressHomeKey();
+        }),
+        MOB_TapOnSpecifiedLocation: withExecutor(async (executor, result) => {
+            await executor.TapOnSpecifiedLocation(result.value);
+        }),
+        MOB_OpenMobileApplication: withExecutor(async (executor, result) => {
+            await executor.OpenMobileApplication(result.value);
+        }),
+        MOB_IsAppInstalled: withExecutor(async (executor, result) => {
+            await executor.IsAppInstalled(result.value);
+        }),
+        MOB_ReceiveMessageOnEmulator: withExecutor(async (executor, result) => {
+            await executor.ReceiveMessageOnEmulator(result.value);
+        }),
+        MOB_UninstallAPK: withExecutor(async (executor, result) => {
+            await executor.UninstallAPK(result.value);
+        }),
+        MOB_InstallAPK: withExecutor(async (executor, result) => {
+            await executor.InstallAPK(result.value);
+        }),
+        MOB_TerminateAppUsingAppPackage: withExecutor(async (executor, result) => {
+            await executor.TerminateAppUsingAppPackage(result.value);
+        }),
+        MOB_OpenAppWithApkFilePath: withExecutor(async (executor, result) => {
+            await executor.OpenAppWithApkFilePath(result.value);
+        }),
+        MOB_ActivateAppUsingAppPackage: withExecutor(async (executor, result) => {
+            await executor.ActivateAppUsingAppPackage(result.value);
+        }),
+        MOB_LongPress: withExecutor(async (executor, result) => {
+            await executor.LongPress(result.selector, result.value, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_PressBackKey: withExecutor(async (executor) => {
+            await executor.MOB_PressBackKey();
+        }),
+        MOB_PressBackSpaceKey: withExecutor(async (executor) => {
+            await executor.MOB_PressBackSpaceKey();
+        }),
+        MOB_PressSpaceKey: withExecutor(async (executor) => {
+            await executor.MOB_PressSpaceKey();
+        }),
+        WaitTillPresenceOfElement: withExecutor(async (executor, args) => {
+            await executor.WaitTillPresenceOfElement(args.pageDOM, args.selector, args.value, args.fireflinkIndex, args.elementName, args.elementType);
+        }),
+        WaitTillPresenceOfAllElements: withExecutor(async (executor, result) => {
+            await executor.WaitTillPresenceOfAllElements(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        WaitTillAttributeOfElementIsString: withExecutor(async (executor, result) => {
+            await executor.WaitTillAttributeOfElementIsString(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        EnterUrl: withExecutor(async (executor, result) => {
+            await executor.EnterUrl(result.value);
+        }),
+        SetClipBoardText: withExecutor(async (executor, result) => {
+            await executor.SetClipBoardText(result.value);
+        }),
+        PressAnyKeyNTimes: withExecutor(async (executor, result) => {
+            await executor.PressAnyKeyNTimes(result.value);
+        }),
+        FindElements: withExecutor(async (executor, result) => {
+            await executor.FindElements(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        MOB_FindElement: withExecutor(async (executor, result) => {
+            await executor.MOB_FindElement(result.selector, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        WaitTillElementIsClickable: withExecutor(async (executor, result) => {
+            await executor.WaitTillElementIsClickable(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        CheckIfElementIsDisplayed: withExecutor(async (executor, result) => {
+            await executor.CheckIfElementIsDisplayed(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        PressAnyKey: withExecutor(async (executor, result) => {
+            await executor.PressAnyKey(result.value);
+        }),
+        MOB_WaitTillPresenceOfElement: withExecutor(async (executor, args) => {
+            await executor.WaitTillPresenceOfElement(args.pageDOM, args.selector, args.value, args.fireflinkIndex, args.elementName, args.elementType);
+        }),
+        WaitTillElementHasText: withExecutor(async (executor, result) => {
+            await executor.WaitTillElementHasText(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        WaitTillElementContainsText: withExecutor(async (executor, result) => {
+            await executor.WaitTillElementContainsText(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        PressEnterKey: withExecutor(async (executor) => {
+            await executor.PressEnterKey();
+        }),
+        MOB_GetDeviceLocation: withExecutor(async (executor) => {
+            await executor.MOB_GetDeviceLocation();
+        }),
+        MOB_GetBatteryPercentage: withExecutor(async (executor) => {
+            await executor.MOB_GetBatteryPercentage();
+        }),
+        MOB_GetLongitude: withExecutor(async (executor) => {
+            await executor.MOB_GetLongitude();
+        }),
+        MOB_GetLatitude: withExecutor(async (executor) => {
+            await executor.MOB_GetLatitude();
+        }),
+        MOB_GetAltitude: withExecutor(async (executor) => {
+            await executor.MOB_GetAltitude();
+        }),
+        MOB_GetCurrentDeviceDate: withExecutor(async (executor) => {
+            await executor.MOB_GetCurrentDeviceDate();
+        }),
+        MOB_GetMinuteFromCurrentDeviceTime: withExecutor(async (executor) => {
+            await executor.MOB_GetMinuteFromCurrentDeviceTime();
+        }),
+        MOB_GetCurrentAppPackage: withExecutor(async (executor) => {
+            await executor.MOB_GetCurrentAppPackage();
+        }),
+        MOB_GetAllContexts: withExecutor(async (executor) => {
+            await executor.MOB_GetAllContexts();
+        }),
+        MOB_GetHourFromCurrentDeviceTime: withExecutor(async (executor) => {
+            await executor.MOB_GetHourFromCurrentDeviceTime();
+        }),
+        MOB_GetSecondFromCurrentDeviceTime: withExecutor(async (executor) => {
+            await executor.MOB_GetSecondFromCurrentDeviceTime();
+        }),
+        MOB_GetSupportedPerformanceDataTypes: withExecutor(async (executor) => {
+            await executor.MOB_GetSupportedPerformanceDataTypes();
+        }),
+        MOB_GetCurrentOrientation: withExecutor(async (executor) => {
+            await executor.MOB_GetCurrentOrientation();
+        }),
+        MOB_GetCurrentDeviceTime: withExecutor(async (executor) => {
+            await executor.MOB_GetCurrentDeviceTime();
+        }),
+        MOB_GetCurrentContext: withExecutor(async (executor) => {
+            await executor.MOB_GetCurrentContext();
+        }),
+        MOB_GetCurrentDeviceSettings: withExecutor(async (executor) => {
+            await executor.MOB_GetCurrentDeviceSettings();
+        }),
+        MOB_GetClipBoardText: withExecutor(async (executor) => {
+            await executor.MOB_GetClipBoardText();
+        }),
+        MOB_GetCurrentDeviceStatus: withExecutor(async (executor) => {
+            await executor.MOB_GetCurrentDeviceStatus();
+        }),
+        MOB_GetSizeOfScreen: withExecutor(async (executor) => {
+            await executor.MOB_GetSizeOfScreen();
+        }),
+        MOB_GetAllWindowHandles: withExecutor(async (executor) => {
+            await executor.MOB_GetAllWindowHandles();
+        }),
+        MOB_GetWidthOfScreen: withExecutor(async (executor) => {
+            await executor.MOB_GetWidthOfScreen();
+        }),
+        MOB_GetBatteryStatus: withExecutor(async (executor) => {
+            await executor.MOB_GetBatteryStatus();
+        }),
+        MOB_GetCurrentActivity: withExecutor(async (executor) => {
+            await executor.MOB_GetCurrentActivity();
+        }),
+        MOB_GetDeviceOsVersion: withExecutor(async (executor) => {
+            await executor.MOB_GetDeviceOsVersion();
+        }),
+        MOB_GetDeviceUdid: withExecutor(async (executor) => {
+            await executor.MOB_GetDeviceUdid();
+        }),
+        MOB_GetDeviceName: withExecutor(async (executor) => {
+            await executor.MOB_GetDeviceName();
+        }),
+        MOB_GetCurrentSessionId: withExecutor(async (executor) => {
+            await executor.MOB_GetCurrentSessionId();
+        }),
+        MOB_GetHeightOfScreen: withExecutor(async (executor) => {
+            await executor.MOB_GetHeightOfScreen();
+        }),
+        MOB_GetCurrentDeviceSystemBars: withExecutor(async (executor) => {
+            await executor.MOB_GetCurrentDeviceSystemBars();
+        }),
+        MOB_GetWidthOfElement: withExecutor(async (executor, result) => {
+            await executor.MOB_GetWidthOfElement(result.selector, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_GetHeightOfElement: withExecutor(async (executor, result) => {
+            await executor.MOB_GetHeightOfElement(result.selector, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_GetTextFromElementAndSetToClipBoard: withExecutor(async (executor, result) => {
+            await executor.MOB_GetTextFromElementAndSetToClipBoard(result.selector, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_GetADBLogsForGivenAppPackage: withExecutor(async (executor, result) => {
+            await executor.MOB_GetADBLogsForGivenAppPackage(result.value);
+        }),
+        MOB_VerifyIfAppIsClosed: withExecutor(async (executor, result) => {
+            await executor.MOB_VerifyIfAppIsClosed(result.value);
+        }),
+        MOB_VerifyIfAirplaneModeOn: withExecutor(async (executor) => {
+            await executor.MOB_VerifyIfAirplaneModeOn();
+        }),
+        MOB_VerifyIfGpsOn: withExecutor(async (executor) => {
+            await executor.MOB_VerifyIfGpsOn();
+        }),
+        MOB_VerifyIfGpsOff: withExecutor(async (executor) => {
+            await executor.MOB_VerifyIfGpsOff();
+        }),
+        MOB_VerifyIfAirplaneModeOff: withExecutor(async (executor) => {
+            await executor.MOB_VerifyIfAirplaneModeOff();
+        }),
+        MOB_VerifyIfDeviceIsLocked: withExecutor(async (executor) => {
+            await executor.MOB_VerifyIfDeviceIsLocked();
+        }),
+        MOB_VerifyIfWifiOn: withExecutor(async (executor) => {
+            await executor.MOB_VerifyIfWifiOn();
+        }),
+        MOB_VerifyIfDeviceIsUnlocked: withExecutor(async (executor) => {
+            await executor.MOB_VerifyIfDeviceIsUnlocked();
+        }),
+        MOB_VerifyIfWifiOff: withExecutor(async (executor) => {
+            await executor.MOB_VerifyIfWifiOff();
+        }),
+        MOB_VerifyIfKeyboardIsShown: withExecutor(async (executor) => {
+            await executor.MOB_VerifyIfKeyboardIsShown();
+        }),
+        MOB_VerifyIfKeyboardIsHidden: withExecutor(async (executor) => {
+            await executor.MOB_VerifyIfKeyboardIsHidden();
+        }),
+        MOB_VerifyBatteryLevel: withExecutor(async (executor, result) => {
+            await executor.MOB_VerifyBatteryLevel(result.value);
+        }),
+        MOB_WaitTillAllElementsAreInvisible: withExecutor(async (executor) => {
+            await executor.MOB_WaitTillAllElementsAreInvisible();
+        }),
+        MOB_WaitTillElementIsSelected: withExecutor(async (executor, result) => {
+            await executor.MOB_WaitTillElementIsSelected(result.selector, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_WaitTillElementIsEnabled: withExecutor(async (executor, result) => {
+            await executor.MOB_WaitTillElementIsEnabled(result.selector, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_WaitTillElementIsVisible: withExecutor(async (executor, result) => {
+            await executor.MOB_WaitTillElementIsVisible(result.selector, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_WaitTillStalenessOfElement: withExecutor(async (executor, result) => {
+            await executor.MOB_WaitTillStalenessOfElement(result.selector, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_WaitTillElementIsInvisible: withExecutor(async (executor, result) => {
+            await executor.MOB_WaitTillElementIsInvisible(result.selector, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_WaitTillAttributeOfElementContainsString: withExecutor(async (executor, result) => {
+            await executor.MOB_WaitTillAttributeOfElementContainsString(result.selector, result.elementName, result.attributeName, result.elementType, result.value, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_SetContext: withExecutor(async (executor, result) => {
+            await executor.MOB_SetContext(result.value);
+        }),
+        MOB_SetEmulatorPowerPercentage: withExecutor(async (executor, result) => {
+            await executor.MOB_SetEmulatorPowerPercentage(result.value);
+        }),
+        Swipe: withExecutor(async (executor, result) => {
+            await executor.swipe(result.nlpName, result.value, result.direction);
+        }),
+        SwipeUp: withExecutor(async (executor, result) => {
+            await executor.swipe(result.nlpName, result.value, result.direction);
+        }),
+        SwipeDown: withExecutor(async (executor, result) => {
+            await executor.swipe(result.nlpName, result.value, result.direction);
+        }),
+        SwipeLeft: withExecutor(async (executor, result) => {
+            await executor.swipe(result.nlpName, result.value, result.direction);
+        }),
+        SwipeRight: withExecutor(async (executor, result) => {
+            await executor.swipe(result.nlpName, result.value, result.direction);
+        }),
+        MOB_SwipeToElement: withExecutor(async (executor, result) => {
+            await executor.swipeToElement(result.value, result.elementName, result.elementType, result.numOfScrolls);
+        }),
+        MOB_SwipeUpToElement: withExecutor(async (executor, result) => {
+            await executor.swipeUpToElement(result.value, result.elementName, result.elementType, result.numOfScrolls);
+        }),
+        MOB_SwipeDownToElement: withExecutor(async (executor, result) => {
+            await executor.swipeDownToElement(result.value, result.elementName, result.elementType, result.numOfScrolls);
+        }),
+        MOB_SwipeLeftToElement: withExecutor(async (executor, result) => {
+            await executor.swipeLeftToElement(result.value, result.elementName, result.elementType, result.numOfScrolls);
+        }),
+        MOB_SwipeRightToElement: withExecutor(async (executor, result) => {
+            await executor.swipeRightToElement(result.value, result.elementName, result.elementType, result.numOfScrolls);
+        }),
+        MOB_SwipeNTimes: withExecutor(async (executor, result) => {
+            await executor.swipeNTimes(result.numOfScrolls, result.direction);
+        }),
+        MOB_SwipeSlider: withExecutor(async (executor, result) => {
+            await executor.swipeSlider(result.parentXpath || result.xpath || result.selector, result.targetXpath || result.xpath || result.selector, result.direction, result.elementName, result.elementType, result.parentIndex, result.targetIndex, result.pageDOM);
+        }),
+        MOB_SwipeDirectionNTimes: withExecutor(async (executor, result) => {
+            await executor.swipeDirectionNTimes(result.numOfScrolls, result.direction);
+        }),
+        MOB_SwipeToElementForMWeb: withExecutor(async (executor, result) => {
+            await executor.swipeToElementForMWeb(result.value, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex, result.numOfScrolls);
+        }),
+        MOB_SwipeUsingReferenceElement: withExecutor(async (executor, result) => {
+            await executor.swipeUsingReferenceElement(result.value, result.elementName, result.elementType, result.numOfScrolls, result.direction, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_EnterInputIntoElementFromClipBoard: withExecutor(async (executor, result) => {
+            await executor.MOB_EnterInputIntoElementFromClipBoard(result.selector, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_CheckIfAppIsClosed: withExecutor(async (executor) => {
+            await executor.MOB_CheckIfAppIsClosed();
+        }),
+        MOB_RunAppInBackground: withExecutor(async (executor, result) => {
+            await executor.MOB_RunAppInBackground(result.value);
+        }),
+        MOB_PinchInByPercent: withExecutor(async (executor, result) => {
+            await executor.MOB_PinchInByPercent(result.selector, result.value, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_PinchOutByPercent: withExecutor(async (executor, result) => {
+            await executor.MOB_PinchOutByPercent(result.selector, result.value, result.elementName, result.elementType, result.pageDOM, result.fireflinkIndex);
+        }),
+        MOB_DoubleTapAtSpecifiedLocation: withExecutor(async (executor, result) => {
+            await executor.MOB_DoubleTapAtSpecifiedLocation(result.value, result.elementName, result.elementType);
+        }),
+        MouseHover: withExecutor(async (executor, result) => {
+            await executor.mouseHover(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        PressAndHoldLeftMouseButton: withExecutor(async (executor, result) => {
+            await executor.pressAndHoldLeftMouseButton(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        ReleaseLeftMouseButton: withExecutor(async (executor, result) => {
+            await executor.ReleaseLeftMouseButton(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        MouseClickOnCurrentCursorPoint: withExecutor(async (executor) => {
+            await executor.MouseClickOnCurrentCursorPoint();
+        }),
+        MouseDoubleClickAtCursorPoint: withExecutor(async (executor) => {
+            await executor.MouseDoubleClickAtCursorPoint();
+        }),
+        MouseClickOnCurrentCursorPointNTimes: withExecutor(async (executor, result) => {
+            await executor.MouseClickOnCurrentCursorPointNTimes(result.value);
+        }),
+        getOtp: withExecutor(async (executor, result) => {
+            await executor.getOtp(result.selector, result.timeFrom, result.waitTime, result.activity, result.isTerminated, result.otpExtractor, result.returnTypeVariableName);
+        }),
+        VerifyPDF: withExecutor(async (executor, result) => {
+            const expectedText = result?.value ?? "";
+            const isDownload = result?.isDownload ?? true;
+            const filePath = result?.path ?? null;
+            await executor.verifyPDF(expectedText, isDownload, filePath);
+        }),
+        arithmetic: withExecutor(async (executor, result) => {
+            await executor.arithmetic(result);
+        })
+    };
+}