ff-automationv2 2.1.3 → 2.2.0

package/src/core/main/actionHandlerFactory.ts

@@ -1,86 +1,1561 @@
 import { ExecutionContext } from "../main/executionContext.js";
 import { ActionExecutor } from "../../automation/actions/executor.js";
+import { logger } from "../../utils/logger/logData.js"
+
+
+type ActionHandler = (result?: any) => Promise<void>;
 
 export function createActionHandlers(
     context: ExecutionContext,
-    pageLoad: number,
-    implicit: number
-): Record<string, (result: any) => Promise<void>> {
+): Record<string, ActionHandler> {
 
-    return {
+    const requireExecutor = (): ActionExecutor => {
+        if (!context.executor) {
+            throw new Error("Browser not initialized.");
+        }
+        return context.executor;
+    };
+
+    const withExecutor =
+        (fn: (executor: ActionExecutor, result?: any) => Promise<void>): ActionHandler =>
+            async (result?: any) => {
+                try {
+                    const executor = requireExecutor();
+                    await fn(executor, result);
+                }
+                catch (error) {
+                    logger.error("Error in createActionHandlers", error)
+                    throw error
+                }
+            };
 
+    return {
         open: async () => {
-            await context.session.open({
-                browserName: "chrome",
-                pageLoad,
-                implicit
-            });
-
-            context.executor = new ActionExecutor(
-                await context.session.getCurrentBrowser(),
-                context.scriptAppender,
-                context.locator,
-                context.request.platform
-            );
-
-            context.scriptAppender.add({
-                nlpName: "OpenBrowser",
-                elementsData: [],
-                stepInputs: []
-            });
-        },
+            try {
+                await context.session.open();
+                context.executor = new ActionExecutor(
+                    await context.session.getCurrentDriver(),
+                    context.scriptAppender,
+                    context.locator,
+                    context.request.platform
+                );
 
-        navigate: async (result: any) => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
+                context.scriptAppender.add(async () => ({
+                    nlpName: "OpenBrowser",
+                    elementsData: [],
+                    stepInputs: []
+                }));
             }
+            catch (error) {
 
-            await context.executor.navigate(result.response.keywords[0]);
-        },
-        goBack: async () => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
+                logger.error("Error in createActionHandlers", error)
+
+                throw error;
             }
-            await context.executor.goBack();
         },
-        refresh: async () => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
+        openApp: async (result) => {
+            try {
+                await context.androidSession.open({
+                    capabilities: {
+                        platformName: "Android",
+                        "appium:platformVersion": context.request.platform_version,
+                        "appium:deviceName": "AndroidDevice",
+                        "appium:udid": context.request.realDeviceId,
+                        "appium:automationName": "UiAutomator2",
+                        "appium:ignoreHiddenApiPolicyError": true,
+                        "appium:shouldUseCompactResponses": true,
+                        "appium:ignoreUnimportantViews": false,
+                        "appium:disableAndroidWatcher": true,
+                        "appium:disableWindowAnimation": true,
+                        "appium:uiautomator2ServerLaunchTimeout": 60000,
+                        "appium:uiautomator2ServerReadTimeout": 60000,
+                        "appium:waitForIdleTimeout": 60000,
+                        "appium:waitForIdlePollingInterval": 60000,
+                        "appium:waitForSelectorTimeout": 60000,
+                    },
+                    keywords: result.keywords
+                })
+
+                context.executor = new ActionExecutor(
+                    await context.androidSession.getCurrentDriver(),
+                    context.scriptAppender,
+                    context.locator,
+                    context.request.platform
+                );
+
+                context.scriptAppender.add(async () => ({
+                    nlpName: "Open Android App",
+                    elementsData: [],
+                    stepInputs: [result.keywords[0], result.keywords[1]]
+                }));
+            }
+            catch (error) {
+
+                logger.error("Error in createActionHandlers", error)
+
+                throw error;
             }
-            await context.executor.refresh();
         },
-        wait: async (result: any) => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
+
+        close: async () => {
+            try {
+                await context.session.close();
+                context.scriptAppender.add(async () => ({
+                    nlpName: "CloseBrowser",
+                    elementsData: [],
+                    stepInputs: []
+                }));
+            }
+            catch (error) {
+                logger.error("Error in createActionHandlers", error)
+
+                throw error;
             }
-            await context.executor.wait(result.value);
         },
-        click: async (result: any) => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
+
+        closeApp: async () => {
+            try {
+                await context.androidSession.close();
+                context.scriptAppender.add(async () => ({
+                    nlpName: "CloseApp",
+                    elementsData: [],
+                    stepInputs: []
+                }));
+            }
+            catch (error) {
+                logger.error("Error in createActionHandlers", error)
+
+                throw error;
             }
-            await context.executor.click(
+        },
+
+        navigate: withExecutor(async (executor, result) => {
+            await executor.navigate(result.keywords[0]);
+
+        }),
+
+        maximize: withExecutor(async (executor) => {
+            await executor.maximize();
+        }),
+        minimize: withExecutor(async (executor) => {
+            await executor.minimize();
+        }),
+
+        goBack: 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.driver,
+                result.selector,
+                result.frames,
+                result.elementName,
+                result.elementType
+            );
+        }),
+
+        Click: 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
+            );
+        }),
+        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
+            );
+        }),
 
-        enter: async (result: any) => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
-            }
-            await context.executor.enterInput(
+        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
+            );
+        }),
 
-    };
-}
+        VerifyText: withExecutor(async (executor, result) => {
+            await executor.verifyText(
+                result.pageDOM,
+                result.selector,
+                result.value,
+                result.fireflinkIndex,
+                result.elementName,
+                result.elementType
+            );
+        }),
+        VerifyPartialText: withExecutor(async (executor, result) => {
+            await executor.verifyPartialText(
+                result.pageDOM,
+                result.selector,
+                result.value,
+                result.fireflinkIndex,
+                result.elementName,
+                result.elementType
+            );
+        }),
+        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);
+        }),
+
+        VerifyIfStatusCodesOfLinks: 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.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) => {
+            await executor.verifyAlertPopupIsDisplayed();
+        }),
+
+        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
+            );
+        }),
+        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
+            );
+        }),
+
+        GetVideoWidth: withExecutor(async (executor, result) => {
+            await executor.getVideoWidth(
+                result.pageDOM,
+                result.selector,
+                result.fireflinkIndex,
+                result.elementName,
+                result.elementType
+            );
+        }),
+
+        GetVideoHeight: withExecutor(async (executor, result) => {
+            await executor.getVideoHeight(
+                result.pageDOM,
+                result.selector,
+                result.fireflinkIndex,
+                result.elementName,
+                result.elementType
+            );
+        }),
+
+        GetVideoDimension: withExecutor(async (executor, result) => {
+            await executor.getVideoDimension(
+                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
+            );
+        }),
+
+        GetAudioWidth: withExecutor(async (executor, result) => {
+            await executor.getAudioWidth(
+                result.pageDOM,
+                result.selector,
+                result.fireflinkIndex,
+                result.elementName,
+                result.elementType
+            );
+        }),
+
+        GetAudioHeight: withExecutor(async (executor, result) => {
+            await executor.getAudioHeight(
+                result.pageDOM,
+                result.selector,
+                result.fireflinkIndex,
+                result.elementName,
+                result.elementType
+            );
+        }),
+
+        GetAudioDimension: withExecutor(async (executor, result) => {
+            await executor.getAudioDimension(
+                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
+            );
+        }),
+        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
+            );
+        }),
+        VerifyWidthOfElement: withExecutor(async (executor, result) => {
+            await executor.VerifyWidthOfElement(
+                result.pageDOM,
+                result.selector,
+                result.value,
+                result.fireflinkIndex,
+                result.elementName,
+                result.elementType
+            );
+        }),
+        VerifyIfXAndYCoordinateOfElement: withExecutor(async (executor, result) => {
+            await executor.VerifyIfXAndYCoordinateOfElement(
+                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
+            );
+        }),
+        VerifyAttributeValue: withExecutor(async (executor, result) => {
+            await executor.VerifyAttributeValue(
+                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
+            );
+        }),
+        MOB_PressBackKey: withExecutor(async (executor) => {
+            await executor.MOB_PressBackKey();
+        }),
+
+        WaitTillPresenceOfElement: withExecutor(async (executor, result) => {
+            await executor.WaitTillPresenceOfElement(
+                result.pageDOM,
+                result.selector,
+                result.fireflinkIndex,
+                result.elementName,
+                result.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
+            );
+        }),
+        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
+            );
+        }),
+        WaitTillElementHasText: withExecutor(async (executor, result) => {
+            await executor.WaitTillElementHasText(
+                result.pageDOM,
+                result.selector,
+                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();
+        }),
+    }
+}