ff-automationv2 2.2.0 → 2.2.2

package/dist/automation/actions/executor.js

@@ -0,0 +1,4327 @@
+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 { 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 { 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 {
+    constructor(driver, scriptDataAppender, elementGetter, platform) {
+        this.driver = driver;
+        this.scriptDataAppender = scriptDataAppender;
+        this.elementGetter = elementGetter;
+        this.platform = platform;
+    }
+    async navigate(url) {
+        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() {
+        try {
+            await goBack({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async refresh() {
+        try {
+            await pageRefresh({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async switchToFrame(driver, selector, frames, elementName, elementType) {
+        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) {
+        try {
+            await wait({
+                driver: this.driver,
+                time,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async click(pageDOM, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, value, fireflinkIndex, pageDOM, elementName, elementType) {
+        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, value, fireflinkIndex, pageDOM, elementName, elementType) {
+        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, value, fireflinkIndex, pageDOM, elementName, elementType) {
+        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, fireflinkIndex, pageDOM, elementName, elementType) {
+        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, fireflinkIndex, pageDOM, elementName, elementType) {
+        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, value, fireflinkIndex, pageDOM, elementName, elementType) {
+        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, value, fireflinkIndex, pageDOM, elementName, elementType) {
+        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, value, fireflinkIndex, pageDOM, elementName, elementType) {
+        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, value, fireflinkIndex, pageDOM, elementName, elementType) {
+        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, value, fireflinkIndex, pageDOM, elementName, elementType) {
+        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() {
+        try {
+            await maximize({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async minimize() {
+        try {
+            await minimize({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async clear(pageDOM, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector2, fireflinkIndex1, fireflinkIndex2, pageDOM, elementName1, elementName2, elementType1, elementType2) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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) {
+        try {
+            await verifyIfStatusCodeOfALinkIsStatusCode({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async verifyIfStatusCodesOfLinks(value) {
+        try {
+            await verifyIfStatusCodesOfLinks({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async verifyIfOptionWithVisibleTextIsSelected(pageDOM, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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) {
+        try {
+            await verifyPerformanceScore({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async verifyAccessibilityScore(value) {
+        try {
+            await verifyAccessibilityScore({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async verifyBestPracticesScore(value) {
+        try {
+            await verifyBestPracticesScore({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async verifySeoScore(value) {
+        try {
+            await verifySeoScore({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async verifyPwaScore(value) {
+        try {
+            await verifyPwaScore({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async verifyHexCodeForGivenXYCoordinates(value) {
+        try {
+            await verifyHexCodeForGivenXYCoordinates({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async waitTillAlertIsPresent() {
+        await waitTillAlertIsPresent({
+            driver: this.driver,
+            scriptDataAppender: this.scriptDataAppender,
+        });
+        try {
+            await waitTillAlertIsPresent({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async verifyAlertPopUpMessageContainsString(value) {
+        try {
+            await verifyAlertPopUpMessageContainsString({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async verifyTextPresentOnAlertPopup(value) {
+        try {
+            await verifyTextPresentOnAlertPopup({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async enterDataToAlert(value) {
+        try {
+            await enterDataToAlert({
+                driver: this.driver,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async clickOkOnAlertPopup() {
+        try {
+            await clickOkOnAlertPopup({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async clickCancelOnAlertPopup() {
+        try {
+            await clickCancelOnAlertPopup({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async verifyAlertPopupIsDisplayed() {
+        try {
+            await verifyAlertPopupIsDisplayed({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getTextPresentOnAlertPopup() {
+        try {
+            await getTextPresentOnAlertPopup({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async switchToDefaultContent() {
+        try {
+            await switchToDefaultContent({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getPageTitle() {
+        try {
+            await getPageTitle({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAttribute(pageDOM, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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() {
+        try {
+            await getBrowserVersion({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAllBrokenLinks() {
+        try {
+            await getAllBrokenLinks({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getHeightOfBrowserWindow() {
+        try {
+            await getHeightOfBrowserWindow({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getWidthOfBrowser() {
+        try {
+            await getWidthOfBrowser({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getXLocationOfBrowserWindow() {
+        try {
+            await getXLocationOfBrowserWindow({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getYLocationOfBrowserWindow() {
+        try {
+            await getYLocationOfBrowserWindow({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAllBrokenLinkCount() {
+        try {
+            await getAllBrokenLinkCount({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getCurrentWindowHandle() {
+        try {
+            await getCurrentWindowHandle({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAllWindowHandles() {
+        try {
+            await getAllWindowHandles({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getURLPresentInAddressBar() {
+        try {
+            await getURLPresentInAddressBar({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getHTMLCodeOfPage() {
+        try {
+            await getHTMLCodeOfPage({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getBrowserCount() {
+        try {
+            await getBrowserCount({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getImplicitTimeOut() {
+        try {
+            await getImplicitTimeOut({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getCapabilityNames() {
+        try {
+            await getCapabilityNames({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getCurrentSystemDate() {
+        try {
+            await getCurrentSystemDate({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getCurrentDayOfTheWeek() {
+        try {
+            await getCurrentDayOfTheWeek({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getCurrentSystemTime() {
+        try {
+            await getCurrentSystemTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getCurrentSecondsFromCurrentSystemTime() {
+        try {
+            await getCurrentSecondsFromCurrentSystemTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getCurrentSystemYear() {
+        try {
+            await getCurrentSystemYear({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getHourFromCurrentSystemTime() {
+        try {
+            await getHourFromCurrentSystemTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getMinuteFromCurrentSystemTime() {
+        try {
+            await getMinuteFromCurrentSystemTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getNumberOfLinksPresentInCurrentPage() {
+        try {
+            await getNumberOfLinksPresentInCurrentPage({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAllConsoleWarnings() {
+        try {
+            await getAllConsoleWarnings({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAllConsoleInformation() {
+        try {
+            await getAllConsoleInformation({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAllConsoleErrors() {
+        try {
+            await getAllConsoleErrors({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAllCookieValues() {
+        try {
+            await getAllCookieValues({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getSizeOfBrowserWindow() {
+        try {
+            await getSizeOfBrowserWindow({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getCurrentSystemMonth() {
+        try {
+            await getCurrentSystemMonth({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getCurrentSystemDay() {
+        try {
+            await getCurrentSystemDay({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAllConsoleLogs() {
+        try {
+            await getAllConsoleLogs({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getTotalNumberOfCookies() {
+        try {
+            await getTotalNumberOfCookies({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAllBrokenImages() {
+        try {
+            await getAllBrokenImages({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getAllCookieNames() {
+        try {
+            await getAllCookieNames({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getNumberOfWorkingLinksFromCurrentPage() {
+        try {
+            await getNumberOfWorkingLinksFromCurrentPage({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getNumberOfBrokenImages() {
+        try {
+            await getNumberOfBrokenImages({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getWorkingLinksFromCurrentPage() {
+        try {
+            await getWorkingLinksFromCurrentPage({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async browserWindowGetPosition() {
+        try {
+            await browserWindowGetPosition({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getClipBoardText() {
+        try {
+            await getClipBoardText({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getDriverInstance() {
+        try {
+            await getDriverInstance({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getFullPaintTime() {
+        try {
+            await getFullPaintTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getFirstContentfulPaint() {
+        try {
+            await getFirstContentfulPaint({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getLargestContentfulPaint() {
+        try {
+            await getLargestContentfulPaint({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getNetworkRouteTime() {
+        try {
+            await getNetworkRouteTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getPerformanceMetrics() {
+        try {
+            await getPerformanceMetrics({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getUserHomeDirectory() {
+        try {
+            await getUserHomeDirectory({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async getText(pageDOM, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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) {
+        try {
+            await getSingleApiStatusCode({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getSingleApiResponse(value) {
+        try {
+            await getSingleApiResponse({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getSingleApiResponseTime(value) {
+        try {
+            await getSingleApiResponseTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getCollectiveApiStatusCode(value) {
+        try {
+            await getCollectiveApiStatusCode({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getCollectiveApiResponseTime(value) {
+        try {
+            await getCollectiveApiResponseTime({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getDataFromApiResponseForJsonPath(value) {
+        try {
+            await getDataFromApiResponseForJsonPath({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getSingleApiRequestPayload(value) {
+        try {
+            await getSingleApiRequestPayload({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getValueFromLocalStorage(value) {
+        try {
+            await getValueFromLocalStorage({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getValueByCookieName(value) {
+        try {
+            await getValueByCookieName({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getValueOfSystemVariable(value) {
+        try {
+            await getValueOfSystemVariable({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getSystemProperty(value) {
+        try {
+            await getSystemProperty({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getStringDataFromLocalFile(value) {
+        try {
+            await getStringDataFromLocalFile({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async scrollPageToSpecificLocation(value) {
+        try {
+            await scrollPageToSpecificLocation({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getDateWithGivenFormat(value) {
+        try {
+            await getDateWithGivenFormat({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getTunnelIdentifier(value) {
+        try {
+            await getTunnelIdentifier({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getBestPracticesScore(value) {
+        try {
+            await getBestPracticesScore({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getPwaScore(value) {
+        try {
+            await getPwaScore({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getDataFromApiRequestHeaderForJsonPath(value) {
+        try {
+            await getDataFromApiRequestHeaderForJsonPath({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async getSeoScore(value) {
+        try {
+            await getSeoScore({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                value
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+        }
+    }
+    async VerifyAttributeValue(pageDOM, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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) {
+        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) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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) {
+        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) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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) {
+        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() {
+        try {
+            await verifyIfBrowserWindowIsClosed({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async VerifyAllBrowserWindowsClosed() {
+        try {
+            await verifyAllBrowserWindowsClosed({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+    async VerifyIfAllCookiesAreDeleted() {
+        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) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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() {
+        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() {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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) {
+        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) {
+        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) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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) {
+        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, selector, fireflinkIndex, elementName, elementType) {
+        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, selector, value, fireflinkIndex, elementName, elementType) {
+        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() {
+        try {
+            await pressEnterKey({
+                driver: this.driver,
+                scriptDataAppender: this.scriptDataAppender,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            logger.error("Error in [ActionExecutor]", error);
+            throw error;
+        }
+    }
+}