ff-automationv2 2.1.3 → 2.2.0

package/src/automation/actions/executor.ts

@@ -1,75 +1,4505 @@
 import type { IActionExecutor } from "../../core/interfaces/actionInterface.js";
-import { navigate } from './navigation/navigate.js';
-import { goBack } from './navigation/goBack.js';
-import { pageRefresh } from './navigation/refresh.js';
-import { click } from './interaction/click.js';
-import { wait } from "./wait/wait.js"
-import { enterInput } from "./interaction/enterInput.js";
+import { navigate } from './interaction/navigation/navigate.js';
+import { goBack } from './interaction/navigation/goBack.js';
+import { pageRefresh } from './interaction/navigation/refresh.js';
+import { click } from './interaction/click/click.js';
+import { clickUsingJS } from "./interaction/click/clickUsingJs.js";
+import { rightClick } from './interaction/click/rightClick.js';
+import { doubleClick } from './interaction/click/doubleClick.js';
+import { waitAndClick } from './interaction/click/waitAndClick.js';
+import { clickNTimes } from './interaction/click/clickNtimes.js';
+import { wait } from "./interaction/wait/wait.js"
+import { maximize } from "./interaction/maximize/maximize.js";
+import { minimize } from "./interaction/maximize/minimize.js";
+import { enterInput } from "./interaction/enterActions/enterInput.js";
+import { enterInputUsingJs } from "./interaction/enterActions/enterusingJs.js";
+import { clear } from "./interaction/clear/clear.js"
+import { clearAndEnter } from "./interaction/clear/clearAndEnter.js";
+import { uploadFilePathUsingRobot } from "./interaction/upload/uploadfile.js";
+import { switchToParentWindow } from "./interaction/switch/switchToParentWindow.js";
+import { switchToNewTabBasedOnTitle } from "./interaction/switch/switchToNewTabBasedOnTitle.js";
+import { switchToNewWindowBasedOnTitle } from "./interaction/switch/switchToNewWindowBasedOnTitle.js";
+import { switchToNewTabBasedOnUrl } from "./interaction/switch/switchToTabBasedOnUrl.js";
+import { switchWindowBasedOnUrl } from "./interaction/switch/switchToWindowBasedOnURL.js";
+import { switchToWindowIfTitleContainsString } from "./interaction/switch/switchToWindowIfTitleContainsString.js";
+import { switchToWindowIfUrlContainsString } from "./interaction/switch/switchToWindowIfUrlContainsString.js";
+import { verifyText } from "./interaction/verify/verifytext.js";
+import { verifyPartialText } from "./interaction/verify/verifypartialtext.js";
+import { verifyElementIsDisplayed } from "./interaction/verify/VerifyElementIsDisplayed.js";
+import { verifyElementIsNotDisplayed } from "./interaction/verify/VerifyElementIsNotDisplayed.js";
+import { verifyElementIsSelected } from "./interaction/verify/VerifyElementIsSelected.js";
+import { verifyElementIsEnabled } from "./interaction/verify/VerifyElementIsEnabled.js";
+import { verifyElementIsDisabled } from "./interaction/verify/VerifyElementIsDisabled.js";
+import { verifyAttributeValue } from "./interaction/verify/VerifyAttributeValue.js";
+import { verifyPartialAttributeValue } from "./interaction/verify/VerifyPartialAttributeValue.js";
+import { verifyTagName } from "./interaction/verify/VerifyTagName.js";
+import { verifyTitleOfCurrentPage } from "./interaction/verify/VerifyTitleOfCurrentPage.js";
+import { verifyPartialTitleOfCurrentPage } from "./interaction/verify/VerifyPartialTitleOfCurrentPage.js";
+import { verifyValueOfElementIsString } from "./interaction/verify/VerifyValueOfElementIsString.js";
+import { verifyValueOfElementContainsString } from "./interaction/verify/VerifyValueOfElementContainsString.js";
+import { verifyNavigateUrl } from "./interaction/verify/VerifyNavigateURL.js";
+import { verifyValueOfElementIsCleared } from "./interaction/verify/VerifyValueOfElementIsCleared.js";
+import { verifyXLocationOfElement } from "./interaction/verify/VerifyXLocationOfElement.js";
+import { verifyYLocationOfElement } from "./interaction/verify/VerifyYLocationOfElement.js";
+import { verifyWidthOfElement } from "./interaction/verify/VerifyWidthOfElement.js";
+import { verifyHeightOfWebElement } from "./interaction/verify/VerifyHeightOfWebElement.js";
+import { verifyRadioButtonIsSelected } from "./interaction/verify/VerifyRadioButtonIsSelected.js";
+import { verifyRadioButtonIsNotSelected } from "./interaction/verify/VerifyRadioButtonIsNotSelected.js";
+import { verifyBrowserWindowHeight } from "./interaction/verify/VerifyBrowserWindowHeight.js";
+import { verifyBrowserWindowWidth } from "./interaction/verify/VerifyBrowserWindowWidth.js";
+import { verifyBrowserHtmlCodeContainsString } from "./interaction/verify/VerifyBrowserHtmlCodeContainsString.js";
+import { verifyBrowserWindowXLocation } from "./interaction/verify/VerifyBrowserWindowXLocation.js";
+import { verifyBrowserWindowYLocation } from "./interaction/verify/VerifyBrowserWindowYLocation.js";
+import { verifyIfCookieNameIsAdded } from "./interaction/verify/VerifyIfCookieNameIsAdded.js";
+import { verifyIfCookieNameIsDeleted } from "./interaction/verify/VerifyIfCookieNameIsDeleted.js";
+import { verifyIfLinkIsBroken } from "./interaction/verify/VerifyIfLinkIsBroken.js";
+import { verifyCssAttributeValue } from "./interaction/verify/VerifyCssAttributeValue.js";
+import { verifyIfVideoIsPlaying } from "./interaction/verify/VerifyIfVideoIsPlaying.js";
+import { verifyNumberOfElementsByTagName } from "./interaction/verify/VerifyNumberOfElementsByTagName.js";
+import { verifyNumberOfElementsByXpath } from "./interaction/verify/VerifyNumberOfElementsByXpath.js";
+import { verifyListBoxOptionsAreSorted } from "./interaction/verify/VerifyListBoxOptionsAreSorted.js";
+import { verifyIfOptionWithIndexIsSelectedInListBox } from "./interaction/verify/VerifyIfOptionWithIndexIsSelectedInListBox.js";
+import { verifyIfOptionWithIndexIsDeselectedInElement } from "./interaction/verify/VerifyIfOptionWithIndexIsDeselectedInElement.js";
+import { verifyAllOptionsAreSelected } from "./interaction/verify/VerifyAllOptionsAreSelected.js";
+import { verifyAllOptionsAreDeselected } from "./interaction/verify/VerifyAllOptionsAreDeSelected.js";
+import { verifyIfOptionWithValueIsSelected } from "./interaction/verify/VerifyIfOptionWithValueIsSelected.js";
+import { verifyIfOptionWithValueIsDeselected } from "./interaction/verify/VerifyIfOptionWithValueIsDeselected.js";
+import { verifyIfSpecifiedOptionIsSelected } from "./interaction/verify/VerifyIfSpecifiedOptionIsSelected.js";
+import { verifyThatSpecifiedOptionIsNotSelected } from "./interaction/verify/VerifyThatSpecifiedOptionIsNotSelected.js";
+import { verifyIfGivenOptionIsDuplicate } from "./interaction/verify/VerifyIfGivenOptionIsDuplicate.js";
+import { verifyTitleInAllPage } from "./interaction/verify/VerifyTitleInAllPage.js";
+import { verifyBrowserWindowTitleContainsString } from "./interaction/verify/VerifyBrowserWindowTitleContainsString.js";
+import { verifyBrowserWindowUrlIsString } from "./interaction/verify/VerifyBrowserWindowUrlIsString.js";
+import { verifyBrowserWindowUrlContainsExpectedUrl } from "./interaction/verify/VerifyBrowserWindowUrlContainsExpectedUrl.js";
+import { verifyCheckboxIsSelected } from "./interaction/verify/VerifyCheckBoxIsSelected.js";
+import { verifyCheckboxIsNotSelected } from "./interaction/verify/VerifyCheckBoxIsNotSelected.js";
+import { verifyLinkNavigatesToTitle } from "./interaction/verify/VerifyLinkNavigatesToTitle.js";
+import { verifyIfCookieObjectIsPresent } from "./interaction/verify/VerifyIfCookieObjectIsPresent.js";
+import { verifyIfAllCookiesAreDeleted } from "./interaction/verify/VerifyIfAllCookiesAreDeleted.js";
+import { verifyIfBrowserWindowIsClosed } from "./interaction/verify/VerifyIfBrowserWindowIsClosed.js";
+import { verifyIfXAndYCoordinateOfElement } from "./interaction/verify/VerifyIfXAndYCoordinateOfElement.js";
+import { verifyBrowserWindowTitleIsString } from "./interaction/verify/VerifyBrowserWindowTitleIsString.js";
+import { verifyIfAudioIsPlaying } from "./interaction/verify/VerifyIfAudioIsPlaying.js";
+import { verifyIfAudioIsMuted } from "./interaction/verify/VerifyIfAudioIsMuted.js";
+import { verifyIfAudioEnded } from "./interaction/verify/VerifyIfAudioEnded.js";
+import { verifyIfVideoPlayingInUnmute } from "./interaction/verify/VerifyIfVideoPlayingInUnmute.js";
+import { verifyIfAudioIsPaused } from "./interaction/verify/VerifyIfAudioIsPaused.js";
+import { verifyIfVideoPlayingInMute } from "./interaction/verify/VerifyIfVideoPlayingInMute.js";
+import { verifyIfVideoIsPaused } from "./interaction/verify/VerifyIfVideoIsPaused.js";
+import { verifyIfVideoIsMuted } from "./interaction/verify/VerifyIfVideoIsMuted.js";
+import { verifyIfVideoEnded } from "./interaction/verify/VerifyIfVideoEnded.js";
+import { verifyAllBrowserWindowsClosed } from "./interaction/verify/VerifyAllBrowserWindowsClosed.js";
+import { verifyIfLinkIsWorking } from "./interaction/verify/VerifyIfLinkIsWorking.js";
+import { verifyIfLinksAreWorking } from "./interaction/verify/VerifyIfLinksAreWorking.js";
+import { verifyIfImageIsBroken } from "./interaction/verify/VerifyIfImageIsBroken.js";
+import { verifyAllBrokenImages } from "./interaction/verify/VerifyAllBrokenImages.js";
+import { verifyIfLinksAreBroken } from "./interaction/verify/VerifyIfLinksAreBroken.js";
 import { ScriptDataAppender } from "../../fireflinkData/fireflinkScript/scriptGenrationData.js";
 import { ElementGetter } from "../../fireflinkData/fireflinkLocators/getListOfLocators.js";
+import { scrollToElement } from "./interaction/scroll/scrollToElement.js";
+import { scrollVerticallyTillElementIsVisible } from "./interaction/scroll/scrollVerticallyTillElementIsVisible.js";
+import { scrollHorizontallyTillElementIsVisible } from "./interaction/scroll/scrollHorizontallyTillElementIsVisible.js";
+import { verifyElementIsClickable } from "./interaction/verify/VerifyElementIsClickable.js";
+import { verifyElementNotContainsText } from "./interaction/verify/VerifyElementNotContainsText.js";
+import { waitTillAlertIsPresent } from "./interaction/alert/waitTillAlertIsPresent.js";
+import { verifyAlertPopUpMessageContainsString } from "./interaction/alert/verifyAlertPopUpMessageContainsString.js";
+import { verifyTextPresentOnAlertPopup } from "./interaction/alert/verifyTextPresentOnAlertPopup.js";
+import { enterDataToAlert } from "./interaction/alert/enterDataToAlert.js";
+import { clickOkOnAlertPopup } from "./interaction/alert/clickOkOnAlertPopup.js";
+import { clickCancelOnAlertPopup } from "./interaction/alert/clickCancelOnAlertPopup.js";
+import { verifyAlertPopupIsDisplayed } from "./interaction/alert/verifyAlertPopupIsDisplayed.js";
+import { getTextPresentOnAlertPopup } from "./interaction/alert/getTextPresentOnAlertPopup.js";
+import { getPageTitle } from "./interaction/get/getPageTitle.js";
+import { getAttribute } from "./interaction/get/getAttribute.js";
+import { getTagName } from "./interaction/get/getTagName.js";
+import { getListBoxSize } from "./interaction/get/getListBoxSize.js";
+import { getWrappedOptionFromListBoxAsText } from "./interaction/get/getWrappedOptionFromListBoxAsText.js";
+import { getBrowserVersion } from "./interaction/get/getBrowserVersion.js";
+import { getAllBrokenLinks } from "./interaction/get/getAllBrokenLinks.js";
+import { getHeightOfBrowserWindow } from "./interaction/get/getHeightOfBrowserWindow.js";
+import { getWidthOfBrowser } from "./interaction/get/getWidthOfBrowser.js";
+import { getXLocationOfBrowserWindow } from "./interaction/get/getXLocationOfBrowserWindow.js";
+import { getYLocationOfBrowserWindow } from "./interaction/get/getYLocationOfBrowserWindow.js";
+import { getAllBrokenLinkCount } from "./interaction/get/getAllBrokenLinkCount.js";
+import { getCurrentWindowHandle } from "./interaction/get/getCurrentWindowHandle.js";
+import { getAllWindowHandles } from "./interaction/get/getAllWindowHandles.js";
+import { getURLPresentInAddressBar } from "./interaction/get/getURLPresentInAddressBar.js";
+import { getHTMLCodeOfPage } from "./interaction/get/getHTMLCodeOfPage.js";
+import { getBrowserCount } from "./interaction/get/getBrowserCount.js";
+import { getImplicitTimeOut } from "./interaction/get/getImplicitTimeOut.js";
+import { getCapabilityNames } from "./interaction/get/getCapabilityNames.js";
+import { getCurrentSystemDate } from "./interaction/get/getCurrentSystemDate.js";
+import { getCurrentDayOfTheWeek } from "./interaction/get/getCurrentDayOfTheWeek.js";
+import { getCurrentSystemTime } from "./interaction/get/getCurrentSystemTime.js";
+import { getCurrentSystemYear } from "./interaction/get/getCurrentSystemYear.js";
+import { getCurrentSecondsFromCurrentSystemTime } from "./interaction/get/getCurrentSecondsFromCurrentSystemTime.js";
+import { getHourFromCurrentSystemTime } from "./interaction/get/getHourFromCurrentSystemTime.js";
+import { getMinuteFromCurrentSystemTime } from "./interaction/get/getMinuteFromCurrentSystemTime.js";
+import { getNumberOfLinksPresentInCurrentPage } from "./interaction/get/getNumberOfLinksPresentInCurrentPage.js";
+import { getAllConsoleWarnings } from "./interaction/get/getAllConsoleWarnings.js";
+import { getAllConsoleInformation } from "./interaction/get/getAllConsoleInformation.js";
+import { getAllConsoleErrors } from "./interaction/get/getAllConsoleErrors.js";
+import { getAllCookieValues } from "./interaction/get/getAllCookieValues.js";
+import { getSizeOfBrowserWindow } from "./interaction/get/getSizeOfBrowserWindow.js";
+import { getCurrentSystemMonth } from "./interaction/get/getCurrentSystemMonth.js";
+import { getCurrentSystemDay } from "./interaction/get/getCurrentSystemDay.js";
+import { getAllConsoleLogs } from "./interaction/get/getAllConsoleLogs.js";
+import { getTotalNumberOfCookies } from "./interaction/get/getTotalNumberOfCookies.js";
+import { getAllBrokenImages } from "./interaction/get/getAllBrokenImages.js";
+import { getAllCookieNames } from "./interaction/get/getAllCookieNames.js";
+import { getNumberOfWorkingLinksFromCurrentPage } from "./interaction/get/getNumberOfWorkingLinksFromCurrentPage.js";
+import { getNumberOfBrokenImages } from "./interaction/get/getNumberOfBrokenImages.js";
+import { getWorkingLinksFromCurrentPage } from "./interaction/get/getWorkingLinksFromCurrentPage.js";
+import { browserWindowGetPosition } from "./interaction/get/browserWindowGetPosition.js";
+import { getClipBoardText } from "./interaction/get/getClipBoardText.js";
+import { getDriverInstance } from "./interaction/get/getDriverInstance.js";
+import { getFullPaintTime } from "./interaction/get/getFullPaintTime.js";
+import { getFirstContentfulPaint } from "./interaction/get/getFirstContentfulPaint.js";
+import { getLargestContentfulPaint } from "./interaction/get/getLargestContentfulPaint.js";
+import { getNetworkRouteTime } from "./interaction/get/getNetworkRouteTime.js";
+import { getPerformanceMetrics } from "./interaction/get/getPerformanceMetrics.js";
+import { getUserHomeDirectory } from "./interaction/get/getUserHomeDirectory.js";
+import { getCssValue } from "./interaction/get/getCssValue.js";
+import { getText } from "./interaction/get/getText.js";
+import { getSize } from "./interaction/get/getSize.js";
+import { getRect } from "./interaction/get/getRect.js";
+import { getLocation } from "./interaction/get/getLocation.js";
+import { getXLocationOfWebElement } from "./interaction/get/getXLocationOfWebElement.js";
+import { getYLocationOfWebElement } from "./interaction/get/getYLocationOfWebElement.js";
+import { getWidthOfWebElement } from "./interaction/get/getWidthOfWebElement.js";
+import { getHeightOfWebElement } from "./interaction/get/getHeightOfWebElement.js";
+import { getWrappedElement } from "./interaction/get/getWrappedElement.js";
+import { getOptions } from "./interaction/get/getOptions.js";
+import { getFirstSelectedOption } from "./interaction/get/getFirstSelectedOption.js";
+import { getAllSelectedOptions } from "./interaction/get/getAllSelectedOptions.js";
+import { getAllTheOptionsFromListBoxAsText } from "./interaction/get/getAllTheOptionsFromListBoxAsText.js";
+import { getAllTheOptionsFromListBoxAsTextInSortedOrder } from "./interaction/get/getAllTheOptionsFromListBoxAsTextInSortedOrder.js";
+import { getTheFirstSelectedOptionFromListBoxAsText } from "./interaction/get/getTheFirstSelectedOptionFromListBoxAsText.js";
+import { getAllTheSelectedOptionsFromListBoxAsText } from "./interaction/get/getAllTheSelectedOptionsFromListBoxAsText.js";
+import { getScreenshot } from "./interaction/get/getScreenshot.js";
+import { getScreenshotAs } from "./interaction/get/getScreenshotAs.js";
+import { getListOfElementsFromLocatorTypeLocatorValue } from "./interaction/get/getListOfElementsFromLocatorTypeLocatorValue.js";
+import { getVideoMediaSource } from "./interaction/get/getVideoMediaSource.js";
+import { getVideoDecodedByte } from "./interaction/get/getVideoDecodedByte.js";
+import { getVideoDefaultPlaybackRate } from "./interaction/get/getVideoDefaultPlaybackRate.js";
+import { getVideoWidth } from "./interaction/get/getVideoWidth.js";
+import { getVideoHeight } from "./interaction/get/getVideoHeight.js";
+import { getVideoCurrentPlaybackRate } from "./interaction/get/getVideoCurrentPlaybackRate.js";
+import { getVideoCurrentSeekTime } from "./interaction/get/getVideoCurrentSeekTime.js";
+import { getVideoCurrentVolume } from "./interaction/get/getVideoCurrentVolume.js";
+import { getVideoMediaLength } from "./interaction/get/getVideoMediaLength.js";
+import { getVideoDimension } from "./interaction/get/getVideoDimension.js";
+import { getAudioMediaSource } from "./interaction/get/getAudioMediaSource.js";
+import { getAudioMediaLength } from "./interaction/get/getAudioMediaLength.js";
+import { getAudioDefaultPlaybackRate } from "./interaction/get/getAudioDefaultPlaybackRate.js";
+import { getAudioCurrentPlaybackRate } from "./interaction/get/getAudioCurrentPlaybackRate.js";
+import { getAudioCurrentSeekTime } from "./interaction/get/getAudioCurrentSeekTime.js";
+import { getAudioCurrentVolume } from "./interaction/get/getAudioCurrentVolume.js";
+import { getAudioDimension } from "./interaction/get/getAudioDimension.js";
+import { getAudioDecodedByte } from "./interaction/get/getAudioDecodedByte.js";
+import { getAudioWidth } from "./interaction/get/getAudioWidth.js";
+import { getAudioHeight } from "./interaction/get/getAudioHeight.js";
+import { logger } from "../../utils/logger/logData.js";
+import { getSingleApiStatusCode } from "./interaction/get/getSingleApiStatusCode.js";
+import { getSingleApiResponse } from "./interaction/get/getSingleApiResponse.js";
+import { getSingleApiResponseTime } from "./interaction/get/getSingleApiResponseTime.js";
+import { getCollectiveApiStatusCode } from "./interaction/get/getCollectiveApiStatusCode.js";
+import { getCollectiveApiResponseTime } from "./interaction/get/getCollectiveApiResponseTime.js";
+import { getDataFromApiResponseForJsonPath } from "./interaction/get/getDataFromApiResponseForJsonPath.js";
+import { getSingleApiRequestPayload } from "./interaction/get/getSingleApiRequestPayload.js";
+import { getValueFromLocalStorage } from "./interaction/get/getValueFromLocalStorage.js";
+import { getValueByCookieName } from "./interaction/get/getValueByCookieName.js";
+import { getValueOfSystemVariable } from "./interaction/get/getValueOfSystemVariable.js";
+import { getSystemProperty } from "./interaction/get/getSystemProperty.js";
+import { getStringDataFromLocalFile } from "./interaction/get/getStringDataFromLocalFile.js";
+import { scrollPageToSpecificLocation } from "./interaction/scroll/scrollPageToSpecificLocation.js";
+import { getDateWithGivenFormat } from "./interaction/get/getDateWithGivenFormat.js";
+import { getTunnelIdentifier } from "./interaction/get/getTunnelIdentifier.js";
+import { getBestPracticesScore } from "./interaction/get/getBestPracticesScore.js";
+import { getPwaScore } from "./interaction/get/getPwaScore.js";
+import { getDataFromApiRequestHeaderForJsonPath } from "./interaction/get/getDataFromApiRequestHeaderForJsonPath.js";
+import { getSeoScore } from "./interaction/get/getSeoScore.js";
+import { findElementUsingFF } from "../../utils/iframesExtraction/findElementUsingFF.js";
+import { switchToDefaultContent } from "./interaction/iframe/switchToDefaultContent.js";
+import { FrameMeta } from "../../utils/iframesExtraction/iframeInterface.js";
+import { enterInputShadow } from "./interaction/shadowDom/shadowDomEnter.js";
+import { clickShadowElement } from "./interaction/shadowDom/shadowDomClick.js";
+import { getTextShadowElement } from "./interaction/shadowDom/shadowDomGetText.js";
+import { verifyTextShadowElement } from "./interaction/shadowDom/shadowDomVerifyText.js";
+import { verifyPartialTextShadowElement } from "./interaction/shadowDom/shadowDomVerifyPartialText.js";
+import { uploadFileShadowElement } from "./interaction/shadowDom/shadowDomUpload.js";
+import { waitAndEnter } from "./interaction/enterActions/waitAndEnter.js";
+import { dragAndDropToElement } from "./interaction/dragAndDrop/dragAndDrop.js";
+import { enterInputAndPress } from "./interaction/enterActions/enterInputAndPress.js";
+import { verifyIfStatusCodeOfALinkIsStatusCode } from "./interaction/verify/VerifyIfStatusCodeOfALinkIsStatusCode.js";
+import { verifyIfStatusCodesOfLinks } from "./interaction/verify/VerifyIfStatusCodesOfLinks.js";
+import { verifyIfOptionWithVisibleTextIsSelected } from "./interaction/verify/VerifyIfOptionWithVisibleTextIsSelected.js";
+import { verifyIfOptionWithTextIsDeselected } from "./interaction/verify/VerifyIfOptionWithTextIsDeselected.js";
+import { verifyPerformanceScore } from "./interaction/verify/VerifyPerformanceScore.js";
+import { verifyAccessibilityScore } from "./interaction/verify/VerifyAccessibilityScore.js";
+import { verifyBestPracticesScore } from "./interaction/verify/VerifyBestPracticesScore.js";
+import { verifySeoScore } from "./interaction/verify/VerifySeoScore.js";
+import { verifyPwaScore } from "./interaction/verify/VerifyPwaScore.js";
+import { verifyHexCodeForGivenXYCoordinates } from "./interaction/verify/VerifyHexCodeForGivenXYCoordinates.js";
+import { pressBackKey } from "./interaction/press/mobPressBackKey.js";
+import { waitTillPresenceOfElement } from "./interaction/wait/waitTillPresenceOfElement.js";
+import { waitTillPresenceOfAllElements } from "./interaction/wait/waitTillPresenceOfAllElements.js";
+import { waitTillAttributeOfElementIsString } from "./interaction/wait/waitTillAttributeOfElementIsString.js";
+import { enterUrl } from "./interaction/enterActions/enterUrl.js";
+import { setClipBoardText } from "./interaction/set/setClipBoardText.js";
+import { pressAnyKeyNTimes } from "./interaction/press/pressAnyKeyNTimes.js";
+import { findElements } from "./interaction/find/findElements.js";
+import { waitTillElementIsClickable } from "./interaction/wait/waitTillElementIsClickable.js";
+import { checkIfElementIsDisplayed } from "./interaction/verify/checkIfElementIsDisplayed.js";
+import { pressAnyKey } from "./interaction/press/pressAnyKey.js";
+import { waitTillElementHasText } from "./interaction/wait/waitTillElementHasText.js";
+import { waitTillElementContainsText } from "./interaction/wait/waitTillElementContainsText.js";
+import { pressEnterKey } from "./interaction/press/pressEnterKey.js";
 export class ActionExecutor implements IActionExecutor {
-    constructor(private readonly browser: WebdriverIO.Browser,
+    constructor(private readonly driver: WebdriverIO.Browser,
         private scriptDataAppender: ScriptDataAppender,
         private elementGetter: ElementGetter,
         private platform: string) { }
 
-
-
     async navigate(url: string): Promise<void> {
-        await navigate({
-            driver: this.browser,
-            url,
-            scriptDataAppender: this.scriptDataAppender
-        });
+        try {
+            await navigate({
+                driver: this.driver,
+                url,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
     }
 
     async goBack(): Promise<void> {
-        await goBack({
-            driver: this.browser,
-            scriptDataAppender: this.scriptDataAppender
-        });
+        try {
+            await goBack({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
     }
 
     async refresh(): Promise<void> {
-        await pageRefresh({
-            driver: this.browser,
-            scriptDataAppender: this.scriptDataAppender
-        });
+        try {
+            await pageRefresh({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
     }
+    async switchToFrame(driver: WebdriverIO.Browser, selector: string, frames: FrameMeta[], elementName: string, elementType: string): Promise<void> {
+        try {
+            await findElementUsingFF({
+                driver: this.driver,
+                selector,
+                frames,
+                scriptDataAppender: this.scriptDataAppender,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
 
+            throw error;
+        }
+    }
 
     async wait(time: string): Promise<void> {
-        await wait({
-            driver: this.browser,
-            time,
-            scriptDataAppender: this.scriptDataAppender
-        });
+        try {
+            await wait({
+                driver: this.driver,
+                time,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
     }
     async click(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
-        await click({
-            driver: this.browser,
-            selector,
-            scriptDataAppender: this.scriptDataAppender,
-            elementGetter: this.elementGetter,
-            fireflinkIndex,
-            pageDOM,
-            elementName,
-            elementType,
-            platform: this.platform
-        });
+        try {
+            await click({
+                driver: this.driver,
+                selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async clickUsingJS(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await clickUsingJS({
+                driver: this.driver,
+                selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async rightClick(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await rightClick({
+                driver: this.driver,
+                selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+
+        }
+    }
+    async doubleClick(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await doubleClick({
+                driver: this.driver,
+                selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async waitAndClick(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await waitAndClick({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+
+        }
+    }
+    async clickNTimes(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await clickNTimes({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
     }
     async enterInput(selector: string, value: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
-        await enterInput({
-            driver: this.browser,
-            selector: selector,
-            value,
+        try {
+            await enterInput({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async enterInputShadow(selector: string, value: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await enterInputShadow({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async enterInputAndPress(selector: string, value: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await enterInputAndPress({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async clickShadowElement(selector: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await clickShadowElement({
+                driver: this.driver,
+                selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async getTextShadowElement(selector: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getTextShadowElement({
+                driver: this.driver,
+                selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async verifyTextShadowElement(selector: string, value: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyTextShadowElement({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async verifyPartialTextShadowElement(selector: string, value: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyPartialTextShadowElement({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async uploadShadowElement(selector: string, value: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await uploadFileShadowElement({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async enterInputUsingJS(selector: string, value: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await enterInputUsingJs({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async waitAndEnter(selector: string, value: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await waitAndEnter({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async maximize(): Promise<void> {
+        try {
+            await maximize({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async minimize(): Promise<void> {
+        try {
+            await minimize({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async clear(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await clear({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async clearAndEnter(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await clearAndEnter({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async dragAndDropToElement(selector1: string, selector2: string, fireflinkIndex1: string, fireflinkIndex2: string, pageDOM: string, elementName1: string, elementName2: string, elementType1: string, elementType2: string): Promise<void> {
+        try {
+            await dragAndDropToElement({
+                driver: this.driver,
+                selector1,
+                selector2,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex1,
+                fireflinkIndex2,
+                pageDOM,
+                elementName1,
+                elementName2,
+                elementType1,
+                elementType2,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async switchToNewTabBasedOnTitle(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await switchToNewTabBasedOnTitle({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async switchToTabBasedOnUrl(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await switchToNewTabBasedOnUrl({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async switchToNewWindowBasedOnTitle(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await switchToNewWindowBasedOnTitle({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async switchToWindowBasedOnURL(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await switchWindowBasedOnUrl({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async switchToParentWindow(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await switchToParentWindow({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async switchToWindowIfTitleContainsString(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await switchToWindowIfTitleContainsString({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async switchToWindowIfUrlContainsString(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await switchToWindowIfUrlContainsString({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async uploadFilePathUsingRobot(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await uploadFilePathUsingRobot({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async verifyText(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyText({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async verifyPartialText(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyPartialText({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyElementIsDisplayed(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyElementIsDisplayed({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyElementIsNotDisplayed(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyElementIsNotDisplayed({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyElementIsSelected(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyElementIsSelected({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyElementIsEnabled(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyElementIsEnabled({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyElementIsDisabled(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyElementIsDisabled({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+
+    }
+    async scrollToElement(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await scrollToElement({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async scrollVerticallyTillElementIsVisible(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await scrollVerticallyTillElementIsVisible({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async scrollHorizontallyTillElementIsVisible(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await scrollHorizontallyTillElementIsVisible({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async verifyElementIsClickable(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyElementIsClickable({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async verifyElementNotContainsText(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyElementNotContainsText({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async verifyIfStatusCodeOfALinkIsStatusCode(value: string): Promise<void> {
+        try {
+            await verifyIfStatusCodeOfALinkIsStatusCode({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+
+    async verifyIfStatusCodesOfLinks(value: string): Promise<void> {
+        try {
+            await verifyIfStatusCodesOfLinks({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+
+    async verifyIfOptionWithVisibleTextIsSelected(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfOptionWithVisibleTextIsSelected({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+
+    async verifyIfOptionWithTextIsDeselected(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfOptionWithTextIsDeselected({
+                driver: this.driver,
+                selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+
+    async verifyPerformanceScore(value: string): Promise<void> {
+        try {
+            await verifyPerformanceScore({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+
+    async verifyAccessibilityScore(value: string): Promise<void> {
+        try {
+            await verifyAccessibilityScore({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+
+    async verifyBestPracticesScore(value: string): Promise<void> {
+        try {
+            await verifyBestPracticesScore({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+
+    async verifySeoScore(value: string): Promise<void> {
+        try {
+            await verifySeoScore({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+
+    async verifyPwaScore(value: string): Promise<void> {
+        try {
+            await verifyPwaScore({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+
+    async verifyHexCodeForGivenXYCoordinates(value: string): Promise<void> {
+        try {
+            await verifyHexCodeForGivenXYCoordinates({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+
+            throw error;
+        }
+    }
+    async waitTillAlertIsPresent(): Promise<void> {
+        await waitTillAlertIsPresent({
+            driver: this.driver,
             scriptDataAppender: this.scriptDataAppender,
-            elementGetter: this.elementGetter,
-            fireflinkIndex,
-            pageDOM,
-            elementName,
-            elementType,
-            platform: this.platform
         });
+        try {
+            await waitTillAlertIsPresent({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async verifyAlertPopUpMessageContainsString(value: string): Promise<void> {
+        try {
+            await verifyAlertPopUpMessageContainsString({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async verifyTextPresentOnAlertPopup(value: string): Promise<void> {
+        try {
+            await verifyTextPresentOnAlertPopup({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async enterDataToAlert(value: string): Promise<void> {
+        try {
+            await enterDataToAlert({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+
+    async clickOkOnAlertPopup(): Promise<void> {
+        try {
+            await clickOkOnAlertPopup({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async clickCancelOnAlertPopup(): Promise<void> {
+        try {
+            await clickCancelOnAlertPopup({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async verifyAlertPopupIsDisplayed(): Promise<void> {
+        try {
+            await verifyAlertPopupIsDisplayed({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getTextPresentOnAlertPopup(): Promise<void> {
+        try {
+            await getTextPresentOnAlertPopup({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async switchToDefaultContent(): Promise<void> {
+        try {
+            await switchToDefaultContent({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+
+
+    async getPageTitle(): Promise<void> {
+        try {
+            await getPageTitle({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAttribute(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAttribute({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getTagName(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getTagName({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getListBoxSize(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getListBoxSize({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getWrappedOptionFromListBoxAsText(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getWrappedOptionFromListBoxAsText({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getBrowserVersion(): Promise<void> {
+        try {
+            await getBrowserVersion({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllBrokenLinks(): Promise<void> {
+        try {
+            await getAllBrokenLinks({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getHeightOfBrowserWindow(): Promise<void> {
+        try {
+            await getHeightOfBrowserWindow({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getWidthOfBrowser(): Promise<void> {
+        try {
+            await getWidthOfBrowser({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getXLocationOfBrowserWindow(): Promise<void> {
+        try {
+            await getXLocationOfBrowserWindow({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getYLocationOfBrowserWindow(): Promise<void> {
+        try {
+            await getYLocationOfBrowserWindow({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllBrokenLinkCount(): Promise<void> {
+        try {
+            await getAllBrokenLinkCount({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getCurrentWindowHandle(): Promise<void> {
+        try {
+            await getCurrentWindowHandle({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllWindowHandles(): Promise<void> {
+        try {
+            await getAllWindowHandles({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getURLPresentInAddressBar(): Promise<void> {
+        try {
+            await getURLPresentInAddressBar({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getHTMLCodeOfPage(): Promise<void> {
+        try {
+            await getHTMLCodeOfPage({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getBrowserCount(): Promise<void> {
+        try {
+            await getBrowserCount({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getImplicitTimeOut(): Promise<void> {
+        try {
+            await getImplicitTimeOut({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getCapabilityNames(): Promise<void> {
+        try {
+            await getCapabilityNames({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getCurrentSystemDate(): Promise<void> {
+        try {
+            await getCurrentSystemDate({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getCurrentDayOfTheWeek(): Promise<void> {
+        try {
+            await getCurrentDayOfTheWeek({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getCurrentSystemTime(): Promise<void> {
+        try {
+            await getCurrentSystemTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getCurrentSecondsFromCurrentSystemTime(): Promise<void> {
+        try {
+            await getCurrentSecondsFromCurrentSystemTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getCurrentSystemYear(): Promise<void> {
+        try {
+            await getCurrentSystemYear({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getHourFromCurrentSystemTime(): Promise<void> {
+        try {
+            await getHourFromCurrentSystemTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getMinuteFromCurrentSystemTime(): Promise<void> {
+        try {
+            await getMinuteFromCurrentSystemTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getNumberOfLinksPresentInCurrentPage(): Promise<void> {
+        try {
+            await getNumberOfLinksPresentInCurrentPage({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllConsoleWarnings(): Promise<void> {
+        try {
+            await getAllConsoleWarnings({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllConsoleInformation(): Promise<void> {
+        try {
+            await getAllConsoleInformation({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllConsoleErrors(): Promise<void> {
+        try {
+            await getAllConsoleErrors({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllCookieValues(): Promise<void> {
+        try {
+            await getAllCookieValues({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getSizeOfBrowserWindow(): Promise<void> {
+        try {
+            await getSizeOfBrowserWindow({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getCurrentSystemMonth(): Promise<void> {
+        try {
+            await getCurrentSystemMonth({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getCurrentSystemDay(): Promise<void> {
+        try {
+            await getCurrentSystemDay({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllConsoleLogs(): Promise<void> {
+        try {
+            await getAllConsoleLogs({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getTotalNumberOfCookies(): Promise<void> {
+        try {
+            await getTotalNumberOfCookies({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllBrokenImages(): Promise<void> {
+        try {
+            await getAllBrokenImages({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllCookieNames(): Promise<void> {
+        try {
+            await getAllCookieNames({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getNumberOfWorkingLinksFromCurrentPage(): Promise<void> {
+        try {
+            await getNumberOfWorkingLinksFromCurrentPage({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getNumberOfBrokenImages(): Promise<void> {
+        try {
+            await getNumberOfBrokenImages({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getWorkingLinksFromCurrentPage(): Promise<void> {
+        try {
+            await getWorkingLinksFromCurrentPage({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async browserWindowGetPosition(): Promise<void> {
+        try {
+            await browserWindowGetPosition({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getClipBoardText(): Promise<void> {
+        try {
+            await getClipBoardText({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getDriverInstance(): Promise<void> {
+        try {
+            await getDriverInstance({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
     }
+
+    async getFullPaintTime(): Promise<void> {
+        try {
+            await getFullPaintTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getFirstContentfulPaint(): Promise<void> {
+        try {
+            await getFirstContentfulPaint({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getLargestContentfulPaint(): Promise<void> {
+        try {
+            await getLargestContentfulPaint({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getNetworkRouteTime(): Promise<void> {
+        try {
+            await getNetworkRouteTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getPerformanceMetrics(): Promise<void> {
+        try {
+            await getPerformanceMetrics({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getUserHomeDirectory(): Promise<void> {
+        try {
+            await getUserHomeDirectory({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getText(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getText({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getCssValue(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getCssValue({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                value,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getSize(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getSize({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getRect(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getRect({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getLocation(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getLocation({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getXLocationOfWebElement(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getXLocationOfWebElement({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getYLocationOfWebElement(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getYLocationOfWebElement({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getWidthOfWebElement(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getWidthOfWebElement({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getHeightOfWebElement(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getHeightOfWebElement({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getWrappedElement(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getWrappedElement({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getOptions(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getOptions({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getFirstSelectedOption(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getFirstSelectedOption({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllSelectedOptions(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAllSelectedOptions({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllTheOptionsFromListBoxAsText(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAllTheOptionsFromListBoxAsText({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllTheOptionsFromListBoxAsTextInSortedOrder(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAllTheOptionsFromListBoxAsTextInSortedOrder({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getTheFirstSelectedOptionFromListBoxAsText(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getTheFirstSelectedOptionFromListBoxAsText({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAllTheSelectedOptionsFromListBoxAsText(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAllTheSelectedOptionsFromListBoxAsText({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getScreenshot(value: string): Promise<void> {
+        try {
+            await getScreenshot({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform,
+                value,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getScreenshotAs(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getScreenshotAs({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getListOfElementsFromLocatorTypeLocatorValue(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getListOfElementsFromLocatorTypeLocatorValue({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getVideoMediaSource(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getVideoMediaSource({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getVideoMediaLength(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getVideoMediaLength({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getVideoCurrentSeekTime(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getVideoCurrentSeekTime({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getVideoCurrentPlaybackRate(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getVideoCurrentPlaybackRate({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getVideoDefaultPlaybackRate(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getVideoDefaultPlaybackRate({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getVideoCurrentVolume(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getVideoCurrentVolume({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getVideoWidth(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getVideoWidth({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getVideoHeight(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getVideoHeight({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getVideoDimension(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getVideoDimension({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getVideoDecodedByte(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getVideoDecodedByte({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAudioMediaSource(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAudioMediaSource({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAudioMediaLength(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAudioMediaLength({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAudioCurrentSeekTime(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAudioCurrentSeekTime({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAudioCurrentPlaybackRate(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAudioCurrentPlaybackRate({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAudioDefaultPlaybackRate(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAudioDefaultPlaybackRate({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAudioCurrentVolume(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAudioCurrentVolume({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAudioWidth(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAudioWidth({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAudioHeight(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAudioHeight({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAudioDimension(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAudioDimension({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getAudioDecodedByte(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await getAudioDecodedByte({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
+    async getSingleApiStatusCode(value: string): Promise<void> {
+        try {
+            await getSingleApiStatusCode({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getSingleApiResponse(value: string): Promise<void> {
+        try {
+            await getSingleApiResponse({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getSingleApiResponseTime(value: string): Promise<void> {
+        try {
+            await getSingleApiResponseTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getCollectiveApiStatusCode(value: string): Promise<void> {
+        try {
+            await getCollectiveApiStatusCode({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getCollectiveApiResponseTime(value: string): Promise<void> {
+        try {
+            await getCollectiveApiResponseTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getDataFromApiResponseForJsonPath(value: string): Promise<void> {
+        try {
+            await getDataFromApiResponseForJsonPath({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getSingleApiRequestPayload(value: string): Promise<void> {
+        try {
+            await getSingleApiRequestPayload({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getValueFromLocalStorage(value: string): Promise<void> {
+        try {
+            await getValueFromLocalStorage({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getValueByCookieName(value: string): Promise<void> {
+        try {
+            await getValueByCookieName({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getValueOfSystemVariable(value: string): Promise<void> {
+        try {
+            await getValueOfSystemVariable({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getSystemProperty(value: string): Promise<void> {
+        try {
+            await getSystemProperty({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getStringDataFromLocalFile(value: string): Promise<void> {
+        try {
+            await getStringDataFromLocalFile({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async scrollPageToSpecificLocation(value: string): Promise<void> {
+        try {
+            await scrollPageToSpecificLocation({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getDateWithGivenFormat(value: string): Promise<void> {
+        try {
+            await getDateWithGivenFormat({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getTunnelIdentifier(value: string): Promise<void> {
+        try {
+            await getTunnelIdentifier({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getBestPracticesScore(value: string): Promise<void> {
+        try {
+            await getBestPracticesScore({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getPwaScore(value: string): Promise<void> {
+        try {
+            await getPwaScore({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getDataFromApiRequestHeaderForJsonPath(value: string): Promise<void> {
+        try {
+            await getDataFromApiRequestHeaderForJsonPath({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async getSeoScore(value: string): Promise<void> {
+        try {
+            await getSeoScore({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+        }
+    }
+
+    async VerifyAttributeValue(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyAttributeValue({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+
+    }
+    async VerifyPartialAttributeValue(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyPartialAttributeValue({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyTagName(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyTagName({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyTitleOfCurrentPage(value: string): Promise<void> {
+        try {
+            await verifyTitleOfCurrentPage({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyPartialTitleOfCurrentPage(value: string): Promise<void> {
+        try {
+            await verifyPartialTitleOfCurrentPage({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyValueOfElementIsString(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyValueOfElementIsString({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyValueOfElementContainsString(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyValueOfElementContainsString({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyNavigateURL(value: string): Promise<void> {
+        try {
+            await verifyNavigateUrl({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyValueOfElementIsCleared(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyValueOfElementIsCleared({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyXLocationOfElement(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyXLocationOfElement({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyYLocationOfElement(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyYLocationOfElement({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyWidthOfElement(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyWidthOfElement({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyHeightOfWebElement(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyHeightOfWebElement({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyRadioButtonIsNotSelected(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyRadioButtonIsNotSelected({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyRadioButtonIsSelected(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyRadioButtonIsSelected({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyBrowserWindowHeight(value: string): Promise<void> {
+        try {
+            await verifyBrowserWindowHeight({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyBrowserWindowWidth(value: string): Promise<void> {
+        try {
+            await verifyBrowserWindowWidth({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyBrowserHtmlCodeContainsString(value: string): Promise<void> {
+        try {
+            await verifyBrowserHtmlCodeContainsString({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyBrowserWindowXLocation(value: string): Promise<void> {
+        try {
+            await verifyBrowserWindowXLocation({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyBrowserWindowYLocation(value: string): Promise<void> {
+        try {
+            await verifyBrowserWindowYLocation({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfCookieNameIsAdded(value: string): Promise<void> {
+        try {
+            await verifyIfCookieNameIsAdded({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfCookieNameIsDeleted(value: string): Promise<void> {
+        try {
+            await verifyIfCookieNameIsDeleted({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfLinkIsBroken(value: string): Promise<void> {
+        try {
+            await verifyIfLinkIsBroken({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyCssAttributeValue(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyCssAttributeValue({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfVideoIsPlaying(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfVideoIsPlaying({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyNumberOfElementsByTagName(value: string): Promise<void> {
+        try {
+            await verifyNumberOfElementsByTagName({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyNumberOfElementsByXpath(value: string): Promise<void> {
+        try {
+            await verifyNumberOfElementsByXpath({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyListBoxOptionsAreSorted(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyListBoxOptionsAreSorted({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfOptionWithIndexIsSelectedInListBox(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfOptionWithIndexIsSelectedInListBox({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfOptionWithIndexIsDeselectedInElement(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfOptionWithIndexIsDeselectedInElement({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyAllOptionsAreSelected(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyAllOptionsAreSelected({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyAllOptionsAreDeselected(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyAllOptionsAreDeselected({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfOptionWithValueIsSelected(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfOptionWithValueIsSelected({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfOptionWithValueIsDeselected(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfOptionWithValueIsDeselected({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfSpecifiedOptionIsSelected(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfSpecifiedOptionIsSelected({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyThatSpecifiedOptionIsNotSelected(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyThatSpecifiedOptionIsNotSelected({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfGivenOptionIsDuplicate(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfGivenOptionIsDuplicate({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyTitleInAllPage(value: string): Promise<void> {
+        try {
+            await verifyTitleInAllPage({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyLinkNavigatesToTitle(value: string): Promise<void> {
+        try {
+            await verifyLinkNavigatesToTitle({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyBrowserWindowTitleContainsString(value: string): Promise<void> {
+        try {
+            await verifyBrowserWindowTitleContainsString({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyBrowserWindowUrlIsString(value: string): Promise<void> {
+        try {
+            await verifyBrowserWindowUrlIsString({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyBrowserWindowUrlContainsExpectedUrl(value: string): Promise<void> {
+        try {
+            await verifyBrowserWindowUrlContainsExpectedUrl({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyCheckBoxIsNotSelected(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyCheckboxIsNotSelected({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyCheckBoxIsSelected(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyCheckboxIsSelected({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyBrowserWindowTitleIsString(value: string): Promise<void> {
+        try {
+            await verifyBrowserWindowTitleIsString({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfBrowserWindowIsClosed(): Promise<void> {
+        try {
+            await verifyIfBrowserWindowIsClosed({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyAllBrowserWindowsClosed(): Promise<void> {
+        try {
+            await verifyAllBrowserWindowsClosed({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfAllCookiesAreDeleted(): Promise<void> {
+        try {
+            await verifyIfAllCookiesAreDeleted({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfCookieObjectIsPresent(value: string): Promise<void> {
+        try {
+            await verifyIfCookieObjectIsPresent({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfXAndYCoordinateOfElement(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfXAndYCoordinateOfElement({
+                driver: this.driver,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfVideoIsMuted(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfVideoIsMuted({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfVideoIsPaused(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfVideoIsPaused({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfVideoEnded(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfVideoEnded({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfVideoPlayingInUnmute(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfVideoPlayingInUnmute({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfVideoPlayingInMute(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfVideoPlayingInMute({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfAudioIsPlaying(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfAudioIsPlaying({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfAudioIsPaused(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfAudioIsPaused({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfAudioIsMuted(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfAudioIsMuted({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfAudioEnded(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await verifyIfAudioEnded({
+                driver: this.driver,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfLinkIsWorking(value: string): Promise<void> {
+        try {
+            await verifyIfLinkIsWorking({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfLinksAreWorking(value: string): Promise<void> {
+        try {
+            await verifyIfLinksAreWorking({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfLinksAreBroken(value: string): Promise<void> {
+        try {
+            await verifyIfLinksAreBroken({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyIfImageIsBroken(value: string): Promise<void> {
+        try {
+            await verifyIfImageIsBroken({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async VerifyAllBrokenImages(): Promise<void> {
+        try {
+            await verifyAllBrokenImages({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async MOB_PressBackKey(): Promise<void> {
+        try {
+            await pressBackKey({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async WaitTillPresenceOfElement(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await waitTillPresenceOfElement({
+                driver: this.driver,
+                pageDOM,
+                selector,
+                fireflinkIndex,
+                elementName,
+                elementType,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform,
+                elementGetter: this.elementGetter
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async WaitTillPresenceOfAllElements(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await waitTillPresenceOfAllElements({
+                driver: this.driver,
+                pageDOM,
+                selector,
+                value,
+                fireflinkIndex,
+                elementName,
+                elementType,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform,
+                elementGetter: this.elementGetter
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async WaitTillAttributeOfElementIsString(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await waitTillAttributeOfElementIsString({
+                driver: this.driver,
+                pageDOM,
+                selector,
+                value,
+                fireflinkIndex,
+                elementName,
+                elementType,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform,
+                elementGetter: this.elementGetter
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async EnterUrl(value: string): Promise<void> {
+        try {
+            await enterUrl({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async SetClipBoardText(value: string): Promise<void> {
+        try {
+            await setClipBoardText({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async PressAnyKeyNTimes(value: string): Promise<void> {
+        try {
+            await pressAnyKeyNTimes({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async FindElements(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await findElements({
+                driver: this.driver,
+                pageDOM,
+                selector,
+                value,
+                fireflinkIndex,
+                elementName,
+                elementType,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform,
+                elementGetter: this.elementGetter
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async WaitTillElementIsClickable(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await waitTillElementIsClickable({
+                driver: this.driver,
+                pageDOM,
+                selector,
+                fireflinkIndex,
+                elementName,
+                elementType,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform,
+                elementGetter: this.elementGetter
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async CheckIfElementIsDisplayed(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await checkIfElementIsDisplayed({
+                driver: this.driver,
+                pageDOM,
+                selector,
+                value,
+                fireflinkIndex,
+                elementName,
+                elementType,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform,
+                elementGetter: this.elementGetter
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async PressAnyKey(value: string): Promise<void> {
+        try {
+            await pressAnyKey({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async WaitTillElementHasText(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await waitTillElementHasText({
+                driver: this.driver,
+                pageDOM,
+                selector,
+                fireflinkIndex,
+                elementName,
+                elementType,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform,
+                elementGetter: this.elementGetter
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async WaitTillElementContainsText(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
+        try {
+            await waitTillElementContainsText({
+                driver: this.driver,
+                pageDOM,
+                selector,
+                value,
+                fireflinkIndex,
+                elementName,
+                elementType,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform,
+                elementGetter: this.elementGetter
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+    async PressEnterKey(): Promise<void> {
+        try {
+            await pressEnterKey({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error)
+            throw error;
+        }
+    }
+
 }