d5-testing-library 2.0.0-alpha.0 → 2.0.0-alpha.2

package/dist/cjs/d5-testing-library.cjs

@@ -59,84 +59,41 @@ var init_config = __esm({
   }
 });
 
-// src/utils/fixElementStaleError.ts
-function fixElementStaleError(by, driver) {
-  const maxCount = 3;
-  let err;
-  const call = async (times) => {
-    if (times > maxCount) throw err;
-    try {
-      let el = await driver.findElement(by);
-      await el.getAttribute("class");
-      return el;
-    } catch (e) {
-      err = e;
-      if (e instanceof Error && e.message.toLowerCase().includes("stale element")) {
-        return call(times + 1);
-      }
-    }
-    if (err) throw err;
-  };
-  return call(0);
-}
-async function staleElementAction(action) {
-  const maxCount = 3;
-  let err;
-  const call = async (times) => {
-    if (times > maxCount) throw err;
-    try {
-      await action();
-    } catch (e) {
-      err = e;
-      if (e instanceof Error && e.message.toLowerCase().includes("stale element")) {
-        await call(times + 1);
-      }
-    }
-    if (err) throw err;
-  };
-  await call(0);
-}
-var init_fixElementStaleError = __esm({
-  "src/utils/fixElementStaleError.ts"() {
-    "use strict";
-  }
-});
-
 // src/pageObjects/AbstractElement.ts
-var import_selenium_webdriver, AbstractElement;
+var AbstractElement;
 var init_AbstractElement = __esm({
   "src/pageObjects/AbstractElement.ts"() {
     "use strict";
-    import_selenium_webdriver = require("selenium-webdriver");
-    init_fixElementStaleError();
     AbstractElement = class {
-      driver;
-      elementCssSelector;
-      constructor(driver, elementCssSelector) {
-        this.driver = driver;
+      constructor(page, elementCssSelector) {
+        this.page = page;
         this.elementCssSelector = elementCssSelector;
       }
+      elementCssSelector;
       getFullCssSelector() {
         return this.elementCssSelector;
       }
       joinRelativeCssSelectors(selectors) {
         return selectors.join(" ");
       }
-      getElement() {
-        return fixElementStaleError(import_selenium_webdriver.By.css(this.getFullCssSelector()), this.driver);
+      getLocator() {
+        return this.page.locator(`css=${this.getFullCssSelector()}`);
       }
       async getAttribute(attr) {
-        const element = await this.getElement();
-        return await element.getAttribute(attr);
+        const locator = this.getLocator();
+        if (await locator.isVisible()) {
+          return locator.getAttribute(attr);
+        }
+        return "";
       }
-      async getClasses() {
-        return await this.getAttribute("class");
+      getClasses() {
+        return this.getAttribute("class");
       }
-      async getDataTestId() {
-        return await this.getAttribute("data-testid");
+      getDataTestId() {
+        return this.getAttribute("data-testid");
       }
-      async getDataDateMode() {
-        return await this.getAttribute("data-datemode");
+      getDataDateMode() {
+        return this.getAttribute("data-datemode");
       }
     };
   }
@@ -147,15 +104,12 @@ var AbstractPage;
 var init_AbstractPage = __esm({
   "src/pageObjects/pages/AbstractPage.ts"() {
     "use strict";
-    init_config();
     init_AbstractElement();
     AbstractPage = class extends AbstractElement {
       url;
-      host;
-      constructor(driver) {
-        super(driver);
-        this.host = config().auth.host;
-        this.url = this.host + this.prependHash(this.path);
+      constructor(page) {
+        super(page);
+        this.url = this.prependHash(this.path);
       }
       prependHash(urlPath) {
         if (!urlPath.startsWith("/#")) {
@@ -164,7 +118,7 @@ var init_AbstractPage = __esm({
         return urlPath;
       }
       async goToUrl(url) {
-        await this.driver.get(url);
+        await this.page.goto(url);
       }
       get path() {
         return "/#";
@@ -173,115 +127,99 @@ var init_AbstractPage = __esm({
         await this.goToUrl(this.url);
       }
       async reloadPage() {
-        await this.driver.navigate().refresh();
+        await this.page.reload();
       }
     };
   }
 });
 
-// src/utils/wait.ts
-async function wait(condition, driver, errorMessage, timeout) {
-  await driver.wait(condition, timeout ?? config().timeout, errorMessage);
-}
-function safeWait(condition, driver, errorMessage, timeout) {
-  return wait(async () => {
-    try {
-      return await condition(driver);
-    } catch {
-      return false;
-    }
-  }, driver, errorMessage, timeout);
-}
-var init_wait = __esm({
-  "src/utils/wait.ts"() {
-    "use strict";
-    init_config();
-  }
-});
-
-// src/utils/waitElementIsVisible.ts
-async function waitElementIsVisible({
-  timeout,
-  errorMessage,
-  driver,
-  ...rest
-}) {
-  await safeWait(async () => {
-    const searchedElement = "by" in rest ? await fixElementStaleError(rest.by, driver) : rest.element;
-    return await searchedElement.isDisplayed();
-  }, driver, errorMessage ?? "Element is not visible", timeout ?? config().timeout);
-}
-var waitElementIsVisible_default;
-var init_waitElementIsVisible = __esm({
-  "src/utils/waitElementIsVisible.ts"() {
-    "use strict";
-    init_config();
-    init_wait();
-    init_fixElementStaleError();
-    waitElementIsVisible_default = waitElementIsVisible;
-  }
-});
-
-// src/utils/actions.ts
-var click, contextMenu;
-var init_actions = __esm({
-  "src/utils/actions.ts"() {
+// src/pageObjects/pages/LoginPage.ts
+var LOGIN_PATH, LoginPage;
+var init_LoginPage = __esm({
+  "src/pageObjects/pages/LoginPage.ts"() {
     "use strict";
-    click = async (webElement, driver) => {
-      if (!await webElement.isDisplayed()) {
-        await driver.executeScript("arguments[0].scrollIntoView(true);", webElement);
+    init_AbstractPage();
+    LOGIN_PATH = "/login";
+    LoginPage = class extends AbstractPage {
+      async locate() {
+        await super.locate();
+        await this.page.getByTestId("loginField").waitFor({ state: "visible" });
       }
-      const actions = driver.actions({ async: true });
-      await actions.move({ origin: webElement }).click().perform();
-    };
-    contextMenu = async (webElement, driver) => {
-      if (!await webElement.isDisplayed()) {
-        await driver.executeScript("arguments[0].scrollIntoView(true);", webElement);
+      get path() {
+        return LOGIN_PATH;
+      }
+      enterUsername(username) {
+        return this.page.getByTestId("loginField").fill(username);
+      }
+      enterPassword(password) {
+        return this.page.getByTestId("passwordField").fill(password);
+      }
+      async clickLoginButton() {
+        await this.page.getByTestId("loginButton").click();
+      }
+      async loginWith(username, password) {
+        await this.enterUsername(username);
+        await this.enterPassword(password);
+        await this.clickLoginButton();
       }
-      const actions = driver.actions({ async: true });
-      await actions.move({ origin: webElement }).contextClick().perform();
     };
   }
 });
 
 // src/utils/locators.ts
-var import_selenium_webdriver2, byTestIdCssSelector, byTestId, readonlyLocator, disabledLocator;
+var byTestIdCssSelector, byTestId, readonlyLocator, disabledLocator;
 var init_locators = __esm({
   "src/utils/locators.ts"() {
     "use strict";
-    import_selenium_webdriver2 = require("selenium-webdriver");
     byTestIdCssSelector = (testId, element = "div") => {
       return `${element}[data-testid="${testId}"]`;
     };
     byTestId = (testId, element = "div") => {
-      return import_selenium_webdriver2.By.css(byTestIdCssSelector(testId, element));
+      return byTestIdCssSelector(testId, element);
     };
     readonlyLocator = "readonly";
     disabledLocator = "disabled";
   }
 });
 
-// src/utils/waitElementIsClickable.ts
-async function waitElementIsClickable({
+// src/utils/waitElementIsVisible.ts
+async function waitElementIsVisible({
   timeout,
-  errorMessage,
-  driver,
-  ...rest
+  locator
 }) {
-  await safeWait(async () => {
-    const searchedElement = "by" in rest ? await fixElementStaleError(rest.by, driver) : rest.element;
-    const isDisabled = await searchedElement.getCssValue("pointer-events") === "none";
-    return await searchedElement.isDisplayed() && !isDisabled;
-  }, driver, errorMessage, timeout ?? config().timeout);
+  try {
+    await locator.waitFor({ state: "visible", timeout });
+  } catch {
+    throw new Error("Element is not visible");
+  }
 }
-var waitElementIsClickable_default;
-var init_waitElementIsClickable = __esm({
-  "src/utils/waitElementIsClickable.ts"() {
+var waitElementIsVisible_default;
+var init_waitElementIsVisible = __esm({
+  "src/utils/waitElementIsVisible.ts"() {
+    "use strict";
+    waitElementIsVisible_default = waitElementIsVisible;
+  }
+});
+
+// src/utils/wait.ts
+async function wait(condition, page, errorMessage, timeout = 3e4) {
+  const start = Date.now();
+  while (true) {
+    try {
+      const result = await condition();
+      if (result) return;
+    } catch {
+    }
+    if (Date.now() - start > timeout) {
+      const msg = errorMessage || `Timeout waiting for condition after ${timeout}ms`;
+      throw new Error(msg);
+    }
+    await page.waitForTimeout(100);
+  }
+}
+var init_wait = __esm({
+  "src/utils/wait.ts"() {
     "use strict";
-    init_config();
-    init_wait();
-    init_fixElementStaleError();
-    waitElementIsClickable_default = waitElementIsClickable;
   }
 });
 
@@ -293,9 +231,8 @@ var init_AbstractElementWithParent = __esm({
     init_AbstractElement();
     init_locators();
     AbstractElementWithParent = class extends AbstractElement {
-      parentCssSelector;
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(driver, elementCssSelector);
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(page, elementCssSelector);
         this.parentCssSelector = parentCssSelector;
       }
       getFullCssSelector() {
@@ -308,59 +245,92 @@ var init_AbstractElementWithParent = __esm({
         return `${this.parentCssSelector} ${this.elementCssSelector}`;
       }
       async isReadonly() {
-        const classSting = await this.getClasses();
-        return classSting.includes(readonlyLocator);
+        const classString = await this.getClasses();
+        return classString.includes(readonlyLocator);
       }
       async isDisabled() {
-        const classSting = await this.getClasses();
-        return classSting.includes(disabledLocator);
+        const classString = await this.getClasses();
+        return classString.includes(disabledLocator);
       }
     };
   }
 });
 
-// src/pageObjects/elements/Editors/ClearStrategy/InputClearStrategy.ts
-var InputClearStrategy;
-var init_InputClearStrategy = __esm({
-  "src/pageObjects/elements/Editors/ClearStrategy/InputClearStrategy.ts"() {
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanelHeader.ts
+var SubsystemsPanelHeader;
+var init_SubsystemsPanelHeader = __esm({
+  "src/pageObjects/elements/SubsystemsPanel/SubsystemsPanelHeader.ts"() {
     "use strict";
-    InputClearStrategy = class {
-      async clear(editor) {
-        const inputEl = await editor.getInputElement();
-        await inputEl.clear();
+    init_AbstractElementWithParent();
+    SubsystemsPanelHeader = class extends AbstractElementWithParent {
+      async title() {
+        return this.page.locator(this.getFullCssSelector());
+      }
+    };
+  }
+});
+
+// src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts
+var DX_TEXTEDITOR_EMPTY, DX_CLEAR_BUTTON_AREA, ClearButtonStrategy;
+var init_ClearButtonStrategy = __esm({
+  "src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts"() {
+    "use strict";
+    DX_TEXTEDITOR_EMPTY = "dx-texteditor-empty";
+    DX_CLEAR_BUTTON_AREA = ".dx-clear-button-area .dx-icon-clear";
+    ClearButtonStrategy = class {
+      editorContainerSelector;
+      page;
+      constructor(editorContainerSelector, page) {
+        this.editorContainerSelector = editorContainerSelector;
+        this.page = page;
+      }
+      get editorContainer() {
+        return this.page.locator(this.editorContainerSelector);
+      }
+      async isEmptyEditorField() {
+        const classAttribute = await this.editorContainer.getAttribute("class");
+        return Boolean(classAttribute?.includes(DX_TEXTEDITOR_EMPTY));
+      }
+      async clear() {
+        if (await this.isEmptyEditorField()) {
+          return;
+        }
+        const clearButton = this.editorContainer.locator(`${DX_CLEAR_BUTTON_AREA}`);
+        if (await clearButton.isHidden()) {
+          return;
+        }
+        await clearButton.click();
       }
     };
   }
 });
 
 // src/pageObjects/elements/Editors/AbstractEditor.ts
-var import_selenium_webdriver7, AbstractDXEditorWithInput;
+var AbstractDXEditorWithInput;
 var init_AbstractEditor = __esm({
   "src/pageObjects/elements/Editors/AbstractEditor.ts"() {
     "use strict";
-    import_selenium_webdriver7 = require("selenium-webdriver");
-    init_actions();
-    init_InputClearStrategy();
     init_AbstractElementWithParent();
+    init_ClearButtonStrategy();
     AbstractDXEditorWithInput = class extends AbstractElementWithParent {
-      clearStrategy = new InputClearStrategy();
+      clearStrategy = new ClearButtonStrategy(this.getFullCssSelector(), this.page);
       setClearStrategy(strategy) {
         this.clearStrategy = strategy;
       }
       getInputCssSelector() {
         return `${this.getFullCssSelector()} .dx-texteditor-input`;
       }
-      async getInputElement() {
-        return this.driver.findElement(import_selenium_webdriver7.By.css(this.getInputCssSelector()));
+      getInputLocator() {
+        return this.page.locator(this.getInputCssSelector());
       }
-      async getInputValue() {
-        const inputEl = await this.getInputElement();
-        return inputEl.getAttribute("value");
+      getInputValue() {
+        return this.getInputLocator().inputValue();
       }
       async setInputValue(value) {
-        const inputEl = await this.getInputElement();
-        await click(inputEl, this.driver);
-        await inputEl.sendKeys(value, import_selenium_webdriver7.Key.ENTER);
+        const input = this.getInputLocator();
+        await input.click();
+        await input.fill(value + "");
+        await input.press("Enter");
       }
       async clear() {
         await this.clearStrategy.clear(this);
@@ -375,11 +345,11 @@ var init_TextEditor = __esm({
   "src/pageObjects/elements/Editors/TextEditor.ts"() {
     "use strict";
     init_AbstractEditor();
-    init_InputClearStrategy();
+    init_ClearButtonStrategy();
     TextEditor = class extends AbstractDXEditorWithInput {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
-        this.setClearStrategy(new InputClearStrategy());
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), page));
       }
       async getValue() {
         const value = await super.getInputValue();
@@ -398,11 +368,11 @@ var init_NumberEditor = __esm({
   "src/pageObjects/elements/Editors/NumberEditor.ts"() {
     "use strict";
     init_AbstractEditor();
-    init_InputClearStrategy();
+    init_ClearButtonStrategy();
     NumberEditor = class extends AbstractDXEditorWithInput {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
-        this.setClearStrategy(new InputClearStrategy());
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), page));
       }
       async getValue() {
         const value = await super.getInputValue();
@@ -445,8 +415,8 @@ var init_AbstractFormElement = __esm({
     "use strict";
     init_AbstractElementWithParent();
     AbstractFormElement = class extends AbstractElementWithParent {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
       }
     };
   }
@@ -457,7 +427,6 @@ var CheckBox;
 var init_CheckBox = __esm({
   "src/pageObjects/elements/Editors/CheckBox.ts"() {
     "use strict";
-    init_actions();
     init_AbstractElementWithParent();
     CheckBox = class extends AbstractElementWithParent {
       async getValue() {
@@ -467,10 +436,10 @@ var init_CheckBox = __esm({
         return null;
       }
       async setValue(value) {
-        const inputEl = await this.getElement();
+        const inputEl = this.getLocator();
         const currentValue = await this.getValue();
         if (currentValue !== value) {
-          await click(inputEl, this.driver);
+          await inputEl.click();
         }
       }
     };
@@ -490,105 +459,122 @@ var init_xpathHelper = __esm({
   }
 });
 
-// src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts
-var import_selenium_webdriver8, DX_TEXTEDITOR_EMPTY, DX_CLEAR_BUTTON_AREA, ClearButtonStrategy;
-var init_ClearButtonStrategy = __esm({
-  "src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts"() {
-    "use strict";
-    import_selenium_webdriver8 = require("selenium-webdriver");
-    init_actions();
-    DX_TEXTEDITOR_EMPTY = "dx-texteditor-empty";
-    DX_CLEAR_BUTTON_AREA = "dx-clear-button-area";
-    ClearButtonStrategy = class {
-      editorContainerClass;
-      _driver;
-      constructor(editorContainerClass, driver) {
-        this.editorContainerClass = editorContainerClass;
-        this._driver = driver;
-      }
-      async isEmptyEditorField() {
-        const editorContainer = await this._driver.findElement(import_selenium_webdriver8.By.css(this.editorContainerClass));
-        const classAttribute = await editorContainer.getAttribute("class");
-        return classAttribute.includes(DX_TEXTEDITOR_EMPTY);
-      }
-      async clear() {
-        if (await this.isEmptyEditorField()) {
-          throw new Error("This field is already empty");
-        }
-        const clearBtnSelector = `${this.editorContainerClass} .${DX_CLEAR_BUTTON_AREA}`;
-        const clearBtn = await this._driver.findElement(import_selenium_webdriver8.By.css(clearBtnSelector));
-        await click(clearBtn, this._driver);
-      }
-    };
-  }
-});
-
-// src/utils/withCustomTimeouts.ts
-async function withCustomTimeouts({ driver, timeout, callback }) {
-  const { implicit: defaultTimeout } = await driver.manage().getTimeouts();
-  try {
-    await driver.manage().setTimeouts({ implicit: timeout ?? defaultTimeout });
-    return await callback();
-  } finally {
-    await driver.manage().setTimeouts({ implicit: defaultTimeout });
+// src/utils/typesUtil.ts
+function isEmptyValue(value) {
+  switch (true) {
+    case !isDefined(value):
+    case value === "":
+    case (isArray(value) && !value.length):
+    case (isObject(value) && isEmptyObject(value)):
+      return true;
   }
+  return false;
 }
-var withCustomTimeouts_default;
-var init_withCustomTimeouts = __esm({
-  "src/utils/withCustomTimeouts.ts"() {
+var types, isObject, isEmptyObject, type, isNull, isArray, isDefined, isString, isDate, isArrayOfDates, isUndefined;
+var init_typesUtil = __esm({
+  "src/utils/typesUtil.ts"() {
     "use strict";
-    withCustomTimeouts_default = withCustomTimeouts;
+    types = {
+      "[object Array]": "array",
+      "[object Date]": "date",
+      "[object Object]": "object",
+      "[object String]": "string",
+      "[object Null]": "null"
+    };
+    isObject = function(value) {
+      return type(value) === "object" && !isNull(value) && !isArray(value) && !isDate(value);
+    };
+    isEmptyObject = function(object) {
+      return !Object.keys(object).length;
+    };
+    type = function(object) {
+      const typeOfObject = Object.prototype.toString.call(object);
+      return typeof object === "object" ? types[typeOfObject] || "object" : typeof object;
+    };
+    isNull = function(value) {
+      return type(value) === "null";
+    };
+    isArray = function(value) {
+      return type(value) === "array";
+    };
+    isDefined = function(value) {
+      return value !== null && !isUndefined(value);
+    };
+    isString = function(object) {
+      return typeof object === "string";
+    };
+    isDate = function(object) {
+      return type(object) === "date";
+    };
+    isArrayOfDates = function(array) {
+      return isArray(array) && array.every(isDate);
+    };
+    isUndefined = (val) => val === void 0;
   }
 });
 
 // src/pageObjects/elements/Editors/SelectBoxEditor.ts
-var import_selenium_webdriver9, SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS, combinedValueXpath, dropDownOptionClick, SelectBoxEditor;
+var SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS, combinedValueXpath, dropDownOptionClick, SelectBoxEditor;
 var init_SelectBoxEditor = __esm({
   "src/pageObjects/elements/Editors/SelectBoxEditor.ts"() {
     "use strict";
     init_AbstractEditor();
-    import_selenium_webdriver9 = require("selenium-webdriver");
-    init_xpathHelper();
-    init_actions();
     init_ClearButtonStrategy();
-    init_withCustomTimeouts();
+    init_xpathHelper();
+    init_src();
+    init_typesUtil();
     SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS = "d5-multi-select-item";
     combinedValueXpath = (value) => `//body/div[@id="root"]/div[contains(@class, "dx-overlay-wrapper")]//${XPathHelper.getClassAndValueXpath(SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS, value)}`;
-    dropDownOptionClick = async (optionValue, driver, delay = true) => {
-      let err = null;
-      try {
-        await withCustomTimeouts_default({
-          driver,
-          timeout: delay ? void 0 : 200,
-          callback: async () => {
-            let optElement = await driver.findElement(import_selenium_webdriver9.By.xpath(combinedValueXpath(optionValue)));
-            await click(optElement, driver);
-          }
-        });
-      } catch (e) {
-        err = new Error(`Item not found: "${optionValue}"`);
+    dropDownOptionClick = async (optionValue, page, delay = true) => {
+      const locator = page.locator(`xpath=${combinedValueXpath(optionValue)}`);
+      if (delay) {
+        try {
+          await locator.waitFor({ state: "visible", timeout: 5e3 });
+        } catch {
+          throw new Error(`Item not found: "${optionValue}"`);
+        }
+      } else {
+        if (await locator.count() === 0) {
+          throw new Error(`Item not found: "${optionValue}"`);
+        }
       }
-      if (err)
-        throw err;
+      await locator.click();
     };
     SelectBoxEditor = class extends AbstractDXEditorWithInput {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
-        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), this.driver));
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), page));
+      }
+      getInputLocator() {
+        return this.page.locator(`${this.getFullCssSelector()} .dx-texteditor-input`);
       }
       async setSelectInputValue(value) {
-        const inputEl = await this.getInputElement();
-        await click(inputEl, this.driver);
+        const inputEl = this.getInputLocator();
+        await inputEl.click();
         try {
-          await dropDownOptionClick(value, this.driver, false);
+          await inputEl.fill(value);
+          await inputEl.press("Enter");
+          await dropDownOptionClick(value, this.page, false);
         } catch {
-          await inputEl.sendKeys(value, import_selenium_webdriver9.Key.ENTER);
-          await dropDownOptionClick(value, this.driver);
+          await dropDownOptionClick(value, this.page);
         }
       }
+      getHiddenInputValue() {
+        const hiddenInput = this.page.locator(this.getFullCssSelector() + " .dx-dropdowneditor-input-wrapper input[type=hidden]");
+        return hiddenInput.getAttribute("value");
+      }
       async getValue() {
-        const value = await super.getInputValue();
-        return value == "" ? null : value;
+        let result = null;
+        await wait(async () => {
+          const hiddenValue = await this.getHiddenInputValue();
+          if (!isEmptyValue(hiddenValue)) {
+            const value = await super.getInputValue();
+            result = value;
+            return !isEmptyValue(value);
+          }
+          return true;
+        }, this.page);
+        return result === "" ? null : result;
       }
       setValue(value) {
         return this.setSelectInputValue(value);
@@ -602,7 +588,6 @@ var SwitchEditor;
 var init_SwitchEditor = __esm({
   "src/pageObjects/elements/Editors/SwitchEditor.ts"() {
     "use strict";
-    init_actions();
     init_AbstractElementWithParent();
     init_wait();
     SwitchEditor = class extends AbstractElementWithParent {
@@ -616,141 +601,139 @@ var init_SwitchEditor = __esm({
         if (value !== 0 && value !== 1) {
           value = value ? 1 : 0;
         }
-        const inputEl = await this.getElement();
+        const inputEl = this.getLocator();
         const currentValue = await this.getValue();
         if (currentValue === value) {
           return;
         }
-        await click(inputEl, this.driver);
-        await safeWait(async () => {
+        await inputEl.click();
+        await wait(async () => {
           const updatedValue = await this.getValue();
           return updatedValue !== currentValue;
-        }, this.driver);
+        }, this.page);
       }
     };
   }
 });
 
 // src/pageObjects/elements/Editors/TagBox.ts
-var import_selenium_webdriver10, TAGS_SELECTOR, DX_TAG_CONTAINER, DX_TEXTEDITOR_EMPTY2, BTN_OK_SELECTOR, getSelectedOptionXpath, TagBox;
+var TAGS_SELECTOR, DX_TAG_CONTAINER, DX_TEXTEDITOR_EMPTY2, BTN_OK_SELECTOR, TagBox;
 var init_TagBox = __esm({
   "src/pageObjects/elements/Editors/TagBox.ts"() {
     "use strict";
     init_AbstractEditor();
-    import_selenium_webdriver10 = require("selenium-webdriver");
-    init_actions();
+    init_ClearButtonStrategy();
     init_locators();
     init_SelectBoxEditor();
-    init_ClearButtonStrategy();
-    init_fixElementStaleError();
     init_wait();
     TAGS_SELECTOR = ".dx-tag .tag-text";
     DX_TAG_CONTAINER = "dx-tag-container";
     DX_TEXTEDITOR_EMPTY2 = "dx-texteditor-empty";
     BTN_OK_SELECTOR = ".dx-tagbox-popup-wrapper .dx-popup-bottom .dx-button.dx-popup-done";
-    getSelectedOptionXpath = (value) => `//body/div[@id="root"]/div[contains(@class, "dx-overlay-wrapper")]//div[contains(@class, 'dx-list-item') and @aria-selected="true"]//div[contains(., "${value}")]`;
     TagBox = class extends AbstractDXEditorWithInput {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
-        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), this.driver));
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), page));
+      }
+      getInputLocator() {
+        return this.page.locator(`${this.getFullCssSelector()} .dx-texteditor-input`);
       }
       async setTagBoxInputValue(values) {
         const lastElement = values[values.length - 1];
-        const inputEl = await this.getInputElement();
-        await inputEl.click();
+        const input = this.getInputLocator();
+        await input.click();
         for (const value of values) {
-          await this.selectOption(inputEl, value, lastElement);
+          await this.selectOption(input, value, lastElement);
         }
         await this.confirmSelection();
       }
       async waitOptionSelection(value) {
-        await safeWait(
-          async () => {
-            const elements = await this.driver.findElements(import_selenium_webdriver10.By.xpath(getSelectedOptionXpath(value)));
-            if (elements.length === 0) return false;
-            return await elements[0].isDisplayed();
-          },
-          this.driver
-        );
+        const option = this.page.locator(`.dx-overlay-wrapper .dx-list-item[aria-selected="true"] >> text=${value}`);
+        await option.waitFor({ state: "visible", timeout: 5e3 });
       }
-      async selectOption(inputEl, value, lastElement) {
+      async selectOption(input, value, lastElement) {
         try {
-          await dropDownOptionClick(value, this.driver, false);
+          await dropDownOptionClick(value, this.page, false);
         } catch {
-          await inputEl.sendKeys(value);
-          await dropDownOptionClick(value, this.driver);
+          await input.fill(value);
+          await dropDownOptionClick(value, this.page, true);
         }
         await this.waitOptionSelection(value);
         if (value !== lastElement) {
-          await inputEl.clear();
+          await input.fill("");
         }
       }
       async confirmSelection() {
-        const btnOk = await fixElementStaleError(import_selenium_webdriver10.By.css(BTN_OK_SELECTOR), this.driver);
-        await click(btnOk, this.driver);
+        const btnOk = this.page.locator(BTN_OK_SELECTOR);
+        await btnOk.click();
       }
       async getTagBoxInputValue() {
-        if (await this.isTagBoxEmpty()) {
-          return [];
-        }
-        const tags = await this.driver.findElements(
-          import_selenium_webdriver10.By.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${TAGS_SELECTOR}`)
+        if (await this.isTagBoxEmpty()) return [];
+        let count = 0;
+        let tags = null;
+        await wait(
+          async () => {
+            tags = this.page.locator(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${TAGS_SELECTOR}`);
+            count = await tags.count();
+            return count > 0;
+          },
+          this.page
         );
         const values = [];
-        for (const tag of tags) {
-          values.push(await tag.getAttribute("textContent"));
+        if (tags) {
+          for (let i = 0; i < count; i++) {
+            const tag = tags.nth(i);
+            const text = await tag.innerText();
+            if (text) values.push(text.trim());
+          }
         }
         return values;
       }
       async isTagBoxEmpty() {
-        const classAttribute = await this.getClasses();
-        return classAttribute.includes(DX_TEXTEDITOR_EMPTY2);
+        const classAttr = await this.getClasses();
+        return classAttr.includes(DX_TEXTEDITOR_EMPTY2);
       }
       async getValue() {
         const value = await this.getTagBoxInputValue();
         return value.length ? value : null;
       }
       async setValue(values) {
-        if (!Array.isArray(values)) {
-          throw new Error("The provided value is not an array");
-        }
+        if (!Array.isArray(values)) throw new Error("The provided value is not an array");
         await this.setTagBoxInputValue(values);
       }
       async remove(itemText) {
         const tagValues = await this.getValue();
-        const tagExists = tagValues.includes(itemText);
-        if (!tagExists) {
+        if (!tagValues.includes(itemText)) {
           throw new Error(`The tag with the text: ${itemText} was not found`);
         }
         const clearBtnTestId = byTestIdCssSelector(`clear-button-${itemText}`);
-        const clearBtn = await this.driver.findElement(
-          import_selenium_webdriver10.By.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${clearBtnTestId}`)
-        );
-        await click(clearBtn, this.driver);
+        const clearBtn = this.page.locator(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${clearBtnTestId}`);
+        await clearBtn.click();
       }
     };
   }
 });
 
 // src/pageObjects/elements/Editors/ButtonGroup.ts
-var import_selenium_webdriver11, ITEM_CLASS, SELECTED_CLASS, ButtonGroup;
+var ITEM_CLASS, SELECTED_CLASS, ButtonGroup;
 var init_ButtonGroup = __esm({
   "src/pageObjects/elements/Editors/ButtonGroup.ts"() {
     "use strict";
-    init_actions();
-    import_selenium_webdriver11 = require("selenium-webdriver");
     init_AbstractElementWithParent();
     ITEM_CLASS = "dx-buttongroup-item";
     SELECTED_CLASS = "dx-state-selected";
     ButtonGroup = class extends AbstractElementWithParent {
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+      }
       getItems() {
-        return this.driver.findElements(import_selenium_webdriver11.By.css(`${this.getFullCssSelector()} .${ITEM_CLASS}`));
+        return this.page.locator(`${this.getFullCssSelector()} .${ITEM_CLASS}`).all();
       }
-      getDataValue(el) {
-        return el.getAttribute("data-value");
+      async getDataValue(el) {
+        return await el.getAttribute("data-value");
       }
       async getValue() {
-        const selectedEl = await this.driver.findElement(import_selenium_webdriver11.By.css(`${this.getFullCssSelector()} .${ITEM_CLASS}.${SELECTED_CLASS}`));
+        const selectedEl = this.page.locator(`${this.getFullCssSelector()} .${ITEM_CLASS}.${SELECTED_CLASS}`);
         return this.getDataValue(selectedEl);
       }
       async setValue(value) {
@@ -764,7 +747,7 @@ var init_ButtonGroup = __esm({
           }
         }
         if (!buttonEl) throw new Error(`Cannot find item in button group with text: ${value}`);
-        await click(buttonEl, this.driver);
+        await buttonEl.click();
       }
     };
   }
@@ -838,14 +821,12 @@ var init_DateSelectMode = __esm({
 });
 
 // src/pageObjects/elements/Editors/Date/Calendar.ts
-var import_selenium_webdriver12, BTN_CALENDAR_POPOVER_OPEN_SELECTOR, BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR, BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR, BTN_SAVE_SELECTOR, CALENDAR_CAPTION_SELECTOR, CALENDAR_CELL_SELECTOR, CALENDAR_PREVIOUS_SELECTOR, CALENDAR_NEXT_SELECTOR, TEXT_EDITOR_SELECTOR, movesToCalendarEndForWeek, movesToCalendarEndForMonth, Calendar;
+var BTN_CALENDAR_POPOVER_OPEN_SELECTOR, BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR, BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR, BTN_SAVE_SELECTOR, CALENDAR_CAPTION_SELECTOR, CALENDAR_CELL_SELECTOR, CALENDAR_PREVIOUS_SELECTOR, CALENDAR_NEXT_SELECTOR, TEXT_EDITOR_SELECTOR, movesToCalendarEndForWeek, movesToCalendarEndForMonth, Calendar;
 var init_Calendar = __esm({
   "src/pageObjects/elements/Editors/Date/Calendar.ts"() {
     "use strict";
     init_AbstractElementWithParent();
-    import_selenium_webdriver12 = require("selenium-webdriver");
     init_locators();
-    init_actions();
     init_utils();
     BTN_CALENDAR_POPOVER_OPEN_SELECTOR = "calendar-popover-open-button";
     BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR = "DateRange__inputs-item--dateFrom";
@@ -860,131 +841,110 @@ var init_Calendar = __esm({
     movesToCalendarEndForMonth = 1;
     Calendar = class extends AbstractElementWithParent {
       _parentCssSelector;
-      constructor({ parentCssSelector, dateFieldDataTestID, driver }) {
-        super("", byTestIdCssSelector(`${dateFieldDataTestID}-calendar-popover`), driver);
+      constructor({ parentCssSelector, dateFieldDataTestID, page }) {
+        super("", byTestIdCssSelector(`${dateFieldDataTestID}-calendar-popover`), page);
         this._parentCssSelector = parentCssSelector;
       }
+      get root() {
+        return this.getLocator();
+      }
       async init() {
-        const dateField = await this.driver.findElement(import_selenium_webdriver12.By.css(this._parentCssSelector));
-        const button = await dateField.findElement(import_selenium_webdriver12.By.css(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`));
-        await click(button, this.driver);
+        const dateField = this.page.locator(this._parentCssSelector);
+        await dateField.locator(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`).click();
       }
-      /**
-       * Переходимо на найвищий рівень календаря
-       */
       async moveToCalendarEnd(count) {
         while (count >= 0) {
-          const calendarElement = await this.getElement();
-          const button = await calendarElement.findElement(import_selenium_webdriver12.By.css(`.${CALENDAR_CAPTION_SELECTOR}`));
-          await click(button, this.driver);
+          await this.root.locator(`.${CALENDAR_CAPTION_SELECTOR}`).click();
           count--;
         }
       }
-      /**
-       * Пошук та клік по правильному періоду (2010-2019, 2020-2029, і т.д.)
-       */
       async choosePeriodForYear(targetYear) {
         let found = false;
         while (!found) {
-          const calendarElement = await this.getElement();
-          const periodCells = await calendarElement.findElements(import_selenium_webdriver12.By.css(`.${CALENDAR_CELL_SELECTOR} span`));
-          for (const cell of periodCells) {
-            const text = await cell.getText();
+          const periodCells = this.root.locator(`.${CALENDAR_CELL_SELECTOR} span`);
+          const count = await periodCells.count();
+          for (let i = 0; i < count; i++) {
+            const cell = periodCells.nth(i);
+            const text = await cell.innerText();
             if (text) {
               const [start, end] = text.split("-").map(Number);
               if (targetYear >= start && targetYear <= end) {
-                await click(cell, this.driver);
+                await cell.click();
                 found = true;
                 break;
               }
             }
           }
           if (!found) {
-            const firstPeriod = await periodCells[0].getText();
-            const [start] = firstPeriod.split("-").map(Number);
+            const firstText = await periodCells.first().innerText();
+            const [start] = firstText.split("-").map(Number);
             if (targetYear < start) {
-              const prevBtn = await calendarElement.findElement(import_selenium_webdriver12.By.css(`.${CALENDAR_PREVIOUS_SELECTOR}`));
-              await click(prevBtn, this.driver);
+              await this.root.locator(`.${CALENDAR_PREVIOUS_SELECTOR}`).click();
             } else {
-              const nextBtn = await calendarElement.findElement(import_selenium_webdriver12.By.css(`.${CALENDAR_NEXT_SELECTOR}`));
-              await click(nextBtn, this.driver);
+              await this.root.locator(`.${CALENDAR_NEXT_SELECTOR}`).click();
             }
           }
         }
       }
-      /**
-       * Пошук та клік по конкретному року з навігацією
-       */
       async chooseYear(targetYear) {
         let found = false;
         while (!found) {
-          const calendarElement = await this.getElement();
-          const yearCells = await calendarElement.findElements(import_selenium_webdriver12.By.css(`.${CALENDAR_CELL_SELECTOR} span`));
-          for (const cell of yearCells) {
-            const text = await cell.getText();
-            const cellYear = Number(text);
-            if (!isNaN(cellYear) && cellYear === targetYear) {
-              await click(cell, this.driver);
+          const yearCells = this.root.locator(`.${CALENDAR_CELL_SELECTOR} span`);
+          const count = await yearCells.count();
+          for (let i = 0; i < count; i++) {
+            const cell = yearCells.nth(i);
+            const year = Number(await cell.innerText());
+            if (!isNaN(year) && year === targetYear) {
+              await cell.click();
               found = true;
               break;
             }
           }
           if (!found) {
-            const firstYearText = await yearCells[0].getText();
-            const lastYearText = await yearCells[yearCells.length - 1].getText();
-            const firstYear = Number(firstYearText);
-            const lastYear = Number(lastYearText);
+            const firstYear = Number(await yearCells.first().innerText());
+            const lastYear = Number(await yearCells.nth(count - 1).innerText());
             if (targetYear < firstYear) {
-              const prevBtn = await calendarElement.findElement(import_selenium_webdriver12.By.css(`.${CALENDAR_PREVIOUS_SELECTOR}`));
-              await click(prevBtn, this.driver);
+              await this.root.locator(`.${CALENDAR_PREVIOUS_SELECTOR}`).click();
             } else if (targetYear > lastYear) {
-              const nextBtn = await calendarElement.findElement(import_selenium_webdriver12.By.css(`.${CALENDAR_NEXT_SELECTOR}`));
-              await click(nextBtn, this.driver);
+              await this.root.locator(`.${CALENDAR_NEXT_SELECTOR}`).click();
             } else {
               throw new Error(`Year ${targetYear} is not in the visible range but navigation failed`);
             }
           }
         }
       }
-      /**
-       * Пошук та клік по конкретному місяцю
-       */
       async chooseMonth(year, month) {
-        const calendarElement = await this.getElement();
-        const monthCells = await calendarElement.findElements(import_selenium_webdriver12.By.css(`.${CALENDAR_CELL_SELECTOR}`));
-        for (const cell of monthCells) {
+        const monthCells = this.root.locator(`.${CALENDAR_CELL_SELECTOR}`);
+        const count = await monthCells.count();
+        for (let i = 0; i < count; i++) {
+          const cell = monthCells.nth(i);
           const dataValue = await cell.getAttribute("data-value");
           if (dataValue) {
             const [cellYear, cellMonth] = dataValue.split("/").map(Number);
             if (cellYear === year && cellMonth === month) {
-              await click(cell, this.driver);
+              await cell.click();
               return;
             }
           }
         }
         throw new Error(`Month ${month} for year ${year} not found`);
       }
-      /**
-       * Пошук та клік по конкретному дню (ігноруємо дні з іншого місяця)
-       */
       async chooseDay(year, month, day) {
-        const calendarElement = await this.getElement();
-        const dayCells = await calendarElement.findElements(import_selenium_webdriver12.By.css(`.${CALENDAR_CELL_SELECTOR}`));
-        for (const cell of dayCells) {
+        const dayCells = this.root.locator(`.${CALENDAR_CELL_SELECTOR}`);
+        const count = await dayCells.count();
+        for (let i = 0; i < count; i++) {
+          const cell = dayCells.nth(i);
           const dataValue = await cell.getAttribute("data-value");
           if (dataValue) {
             const [cellYear, cellMonth, cellDay] = dataValue.split("/").map(Number);
             if (cellYear === year && cellMonth === month && cellDay === day) {
-              await click(cell, this.driver);
+              await cell.click();
               return;
             }
           }
         }
         throw new Error(`Day ${day}.${month}.${year} not found`);
       }
-      /**
-       * Встановлення дати для тижня
-       */
       async setValueForWeek(date) {
         const { year, month, day } = getYearMonthDay(date);
         await this.moveToCalendarEnd(movesToCalendarEndForWeek);
@@ -994,9 +954,6 @@ var init_Calendar = __esm({
         await this.chooseDay(year, month, day);
         await this.save();
       }
-      /**
-       * Встановлення дати для місяця
-       */
       async setValueForMonth(date) {
         const { year, month } = getYearMonthDay(date);
         await this.moveToCalendarEnd(movesToCalendarEndForMonth);
@@ -1004,46 +961,37 @@ var init_Calendar = __esm({
         await this.chooseMonth(year, month);
         await this.save();
       }
-      async getDateFromInput() {
-        const calendarPopoverElement = await this.getElement();
-        return calendarPopoverElement.findElement(
-          import_selenium_webdriver12.By.css(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .${TEXT_EDITOR_SELECTOR}`)
-        );
+      getDateFromInputLocator() {
+        return this.root.locator(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .${TEXT_EDITOR_SELECTOR}`);
       }
-      async getDateToInput() {
-        const calendarPopoverElement = await this.getElement();
-        return calendarPopoverElement.findElement(
-          import_selenium_webdriver12.By.css(`.${BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR} .${TEXT_EDITOR_SELECTOR}`)
-        );
+      getDateToInputLocator() {
+        return this.root.locator(`.${BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR} .${TEXT_EDITOR_SELECTOR}`);
       }
       async save() {
-        const btnOk = await this.driver.findElement(import_selenium_webdriver12.By.css(`.${BTN_SAVE_SELECTOR}`));
-        await click(btnOk, this.driver);
+        await this.root.locator(`.${BTN_SAVE_SELECTOR}`).click();
       }
     };
   }
 });
 
 // src/pageObjects/elements/Editors/Date/BaseDateEditor.ts
-var import_selenium_webdriver13, DATETIME_ALLOWED_SELECTOR, BaseDateEditor;
+var DATETIME_ALLOWED_SELECTOR, BaseDateEditor;
 var init_BaseDateEditor = __esm({
   "src/pageObjects/elements/Editors/Date/BaseDateEditor.ts"() {
     "use strict";
     init_AbstractEditor();
-    init_InputClearStrategy();
-    import_selenium_webdriver13 = require("selenium-webdriver");
-    init_actions();
     init_utils();
     init_DateSelectMode();
     init_Calendar();
+    init_ClearButtonStrategy();
     DATETIME_ALLOWED_SELECTOR = "dx-datebox-datetime";
     BaseDateEditor = class extends AbstractDXEditorWithInput {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
-        this.setClearStrategy(new InputClearStrategy());
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), page));
       }
       async getIsAllowedTime() {
-        const dateField = await this.driver.findElement(import_selenium_webdriver13.By.css(`${this.getFullCssSelector()}`));
+        const dateField = this.page.locator(`${this.getFullCssSelector()}`);
         const classString = await dateField.getAttribute("class");
         return classString.includes(DATETIME_ALLOWED_SELECTOR);
       }
@@ -1052,7 +1000,7 @@ var init_BaseDateEditor = __esm({
         const calendar = new Calendar({
           parentCssSelector: this.getFullCssSelector(),
           dateFieldDataTestID,
-          driver: this.driver
+          page: this.page
         });
         await calendar.init();
         return calendar;
@@ -1067,13 +1015,13 @@ var init_BaseDateEditor = __esm({
       }
       async setArrayValue(value) {
         const calendar = await this.initCalendar();
-        const dateFromInput = await calendar.getDateFromInput();
-        const dateToInput = await calendar.getDateToInput();
+        const dateFromInput = calendar.getDateFromInputLocator();
+        const dateToInput = calendar.getDateToInputLocator();
         await this.setSingleValue(value[0], dateFromInput);
         await this.setSingleValue(value[1], dateToInput);
         await calendar.save();
       }
-      async setSingleValue(value, inputEl) {
+      async setSingleValue(value, input) {
         const dateMode = await this.getDataDateMode();
         if (DateSelectMode.isWeek(dateMode)) {
           await this.setValueForWeek(value);
@@ -1083,18 +1031,18 @@ var init_BaseDateEditor = __esm({
           await this.setValueForMonth(value);
           return;
         }
-        const actions = this.driver.actions({ async: true });
         const isTimeAllowed = await this.getIsAllowedTime();
         const formattedDate = formatDMYDate(value, isTimeAllowed);
-        await click(inputEl, this.driver);
-        await actions.move({ origin: inputEl }).sendKeys(import_selenium_webdriver13.Key.HOME).perform();
-        await actions.move({ origin: inputEl }).sendKeys(formattedDate, import_selenium_webdriver13.Key.ENTER).perform();
+        await input.click();
+        await input.press("Home");
+        await input.pressSequentially(formattedDate);
+        await input.press("Enter");
       }
       async setDateValue(value) {
         if (Array.isArray(value)) {
           await this.setArrayValue(value);
         } else {
-          await this.setSingleValue(value, await this.getInputElement());
+          await this.setSingleValue(value, this.getInputLocator());
         }
       }
     };
@@ -1102,77 +1050,84 @@ var init_BaseDateEditor = __esm({
 });
 
 // src/pageObjects/elements/Editors/Date/SingleDateEditor.ts
-var import_selenium_webdriver14, SingleDateEditor;
+var SingleDateEditor;
 var init_SingleDateEditor = __esm({
   "src/pageObjects/elements/Editors/Date/SingleDateEditor.ts"() {
     "use strict";
-    import_selenium_webdriver14 = require("selenium-webdriver");
-    init_InputClearStrategy();
     init_BaseDateEditor();
     init_utils();
+    init_ClearButtonStrategy();
+    init_src();
     SingleDateEditor = class extends BaseDateEditor {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
-        this.setClearStrategy(new InputClearStrategy());
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), page));
       }
-      async getDateElement() {
-        return this.driver.findElement(import_selenium_webdriver14.By.css(this.getFullCssSelector() + " .dx-dropdowneditor-input-wrapper input[type=hidden]"));
+      getDateLocator() {
+        return this.page.locator(this.getFullCssSelector() + " .dx-dropdowneditor-input-wrapper input[type=hidden]");
       }
       async getDateValue() {
-        const inputEl = await this.getDateElement();
-        return inputEl.getAttribute("value");
+        const input = this.getDateLocator();
+        return input.getAttribute("value");
       }
       async getValue() {
         const value = await this.getDateValue();
         const isTimeAllowed = await this.getIsAllowedTime();
         if (isTimeAllowed) {
-          return value == "" ? null : formatToDateTime(value);
+          return value === "" ? null : formatToDateTime(value);
         }
-        return value == "" ? null : new Date(value);
+        return value === "" ? null : new Date(value);
       }
-      setValue(value) {
-        if (typeof value === "object") {
-          return this.setDateValue(value);
+      async setValue(value) {
+        if (value instanceof Date) {
+          await wait(async () => {
+            await this.setDateValue(value);
+            const updatedValue = await this.getValue();
+            return updatedValue.toDateString() === value.toDateString();
+          }, this.page);
+        } else {
+          throw new Error(`Value is incorrect. It should be a Date object`);
         }
-        throw new Error(`Value is incorrect. It should be Object`);
       }
     };
   }
 });
 
 // src/pageObjects/elements/Editors/Date/DateRangeEditor.ts
-var import_selenium_webdriver15, DateRangeEditor;
+var DateRangeEditor;
 var init_DateRangeEditor = __esm({
   "src/pageObjects/elements/Editors/Date/DateRangeEditor.ts"() {
     "use strict";
-    import_selenium_webdriver15 = require("selenium-webdriver");
-    init_InputClearStrategy();
     init_BaseDateEditor();
+    init_typesUtil();
+    init_ClearButtonStrategy();
     DateRangeEditor = class extends BaseDateEditor {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
-        this.setClearStrategy(new InputClearStrategy());
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), page));
       }
-      async getDateElement() {
-        return this.driver.findElement(import_selenium_webdriver15.By.css(this.getFullCssSelector() + " .dx-texteditor-input"));
+      getDateLocator() {
+        return this.page.locator(`${this.getFullCssSelector()} .dx-texteditor-input`);
       }
       async getDateValue() {
-        const inputEl = await this.getDateElement();
-        const dateFromStr = await inputEl.getAttribute("datefrom");
-        const dateToStr = await inputEl.getAttribute("dateto");
-        const dateFrom = new Date(dateFromStr);
-        const dateTo = new Date(dateToStr);
-        return [dateFrom, dateTo];
+        const input = this.getDateLocator();
+        const dateFromStr = await input.getAttribute("datefrom");
+        const dateToStr = await input.getAttribute("dateto");
+        const dateFrom = dateFromStr ? new Date(dateFromStr) : null;
+        const dateTo = dateToStr ? new Date(dateToStr) : null;
+        return dateFrom && dateTo ? [dateFrom, dateTo] : null;
       }
       async getValue() {
         const values = await this.getDateValue();
-        return !values.length ? null : values;
+        return values?.length ? values : null;
       }
-      setValue(value) {
-        if (typeof value === "object") {
-          return this.setDateValue(value);
+      async setValue(value) {
+        if (isDate(value) || isArrayOfDates(value)) {
+          const inputValue = Array.isArray(value) ? value : [value, value];
+          await this.setDateValue(inputValue);
+          return;
         }
-        throw new Error(`Value is incorrect. It should be Object`);
+        throw new Error(`Value is incorrect. It should be a Date object or Date array`);
       }
     };
   }
@@ -1197,18 +1152,18 @@ var init_DateEditor = __esm({
         await this.setEditorInstance();
       }
       async setEditorInstance() {
-        const { parentCssSelector, elementCssSelector, driver } = this;
-        const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
+        const { parentCssSelector, elementCssSelector, page } = this;
+        const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, page);
         const classString = await elementInstance.getClasses();
         switch (true) {
           case classString.includes("date-control" /* Date */):
-            this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, driver);
+            this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, page);
             break;
           case classString.includes("single-date-range-control" /* SingleDateRange */):
-            this.editorInstance = new DateRangeEditor(parentCssSelector, elementCssSelector, driver);
+            this.editorInstance = new DateRangeEditor(parentCssSelector, elementCssSelector, page);
             break;
           default:
-            this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, driver);
+            this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, page);
         }
       }
       async setValue(value) {
@@ -1225,17 +1180,13 @@ var init_DateEditor = __esm({
 });
 
 // src/pageObjects/elements/Editors/HeaderFilterDictionary.ts
-var import_selenium_webdriver16, TAGS_SELECTOR2, DX_TAG_CONTAINER2, DX_TEXTEDITOR_EMPTY3, CUSTOM_OPTION_LIST_SELECTOR, SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS2, TAG_BOX_LIST_ITEM_SELECTOR, combinedOptionHeaderFilterDictValueXpath, dropDownHeaderFilterDictionaryOptionClick, HeaderFilterDictionary;
+var TAGS_SELECTOR2, DX_TAG_CONTAINER2, DX_TEXTEDITOR_EMPTY3, CUSTOM_OPTION_LIST_SELECTOR, SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS2, TAG_BOX_LIST_ITEM_SELECTOR, combinedOptionHeaderFilterDictValueXpath, dropDownHeaderFilterDictionaryOptionClick, HeaderFilterDictionary;
 var init_HeaderFilterDictionary = __esm({
   "src/pageObjects/elements/Editors/HeaderFilterDictionary.ts"() {
     "use strict";
     init_AbstractEditor();
-    import_selenium_webdriver16 = require("selenium-webdriver");
-    init_actions();
-    init_locators();
     init_ClearButtonStrategy();
-    init_fixElementStaleError();
-    init_withCustomTimeouts();
+    init_locators();
     TAGS_SELECTOR2 = ".dx-tag .tag-text";
     DX_TAG_CONTAINER2 = "dx-tag-container";
     DX_TEXTEDITOR_EMPTY3 = "dx-texteditor-empty";
@@ -1243,69 +1194,60 @@ var init_HeaderFilterDictionary = __esm({
     SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS2 = "d5-multi-select-item";
     TAG_BOX_LIST_ITEM_SELECTOR = '.dx-overlay-wrapper .dx-list-item[aria-selected="true"]';
     combinedOptionHeaderFilterDictValueXpath = (value) => `//div[contains(@class, '${SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS2}') and contains(text(), '${value}')]`;
-    dropDownHeaderFilterDictionaryOptionClick = async (optionValue, driver, dataTEST = "", delay = true) => {
-      let err = null;
+    dropDownHeaderFilterDictionaryOptionClick = async (optionValue, page, dataTEST = "", delay = true) => {
+      const calendarPopoverSelector = byTestIdCssSelector(`${dataTEST}`);
+      const calendarPopover = page.locator(calendarPopoverSelector);
+      const customOptionList = calendarPopover.locator(`.${CUSTOM_OPTION_LIST_SELECTOR}`);
+      const optElement = customOptionList.locator(`xpath=${combinedOptionHeaderFilterDictValueXpath(optionValue)}`);
       try {
-        const calendarPopoverSelector = byTestIdCssSelector(`${dataTEST}`);
-        await withCustomTimeouts_default({
-          driver,
-          timeout: delay ? void 0 : 600,
-          callback: async () => {
-            const calendarPopoverElement = await driver.findElement(import_selenium_webdriver16.By.css(calendarPopoverSelector));
-            const customOptionList = calendarPopoverElement.findElement(import_selenium_webdriver16.By.css(`.${CUSTOM_OPTION_LIST_SELECTOR}`));
-            const optElement = await customOptionList.findElement(import_selenium_webdriver16.By.xpath(combinedOptionHeaderFilterDictValueXpath(optionValue)));
-            await click(optElement, driver);
-          }
-        });
-      } catch (e) {
-        err = new Error(`Item not found: "${optionValue}"`);
+        await optElement.waitFor({ state: "visible", timeout: delay ? void 0 : 600 });
+        await optElement.click();
+      } catch {
+        throw new Error(`Item not found: "${optionValue}"`);
       }
-      if (err)
-        throw err;
     };
     HeaderFilterDictionary = class extends AbstractDXEditorWithInput {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
-        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), this.driver));
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), page));
+      }
+      getInputLocator() {
+        return this.page.locator(`${this.getFullCssSelector()} .dx-texteditor-input`);
       }
       async setTagBoxInputValue(values) {
         const lastElement = values[values.length - 1];
-        const inputEl = await this.getInputElement();
+        const inputEl = this.getInputLocator();
         await inputEl.click();
         for (const value of values) {
           await this.selectOption(inputEl, value, lastElement);
         }
       }
       async waitOptionSelection() {
-        await fixElementStaleError(import_selenium_webdriver16.By.css(TAG_BOX_LIST_ITEM_SELECTOR), this.driver);
+        const selectedItem = this.page.locator(TAG_BOX_LIST_ITEM_SELECTOR);
+        await selectedItem.waitFor({ state: "visible" });
       }
       async selectOption(inputEl, value, lastElement) {
         try {
-          await inputEl.sendKeys(value);
+          await inputEl.fill(value);
           const dataTEST = await this.getDataTestId();
-          await dropDownHeaderFilterDictionaryOptionClick(value, this.driver, dataTEST);
-          const textLength = await inputEl.getAttribute("value").then((value2) => value2.length);
-          for (let i = 0; i < textLength; i++) {
-            await inputEl.sendKeys(import_selenium_webdriver16.Key.BACK_SPACE);
+          await dropDownHeaderFilterDictionaryOptionClick(value, this.page, dataTEST);
+          if (value !== lastElement) {
+            await inputEl.fill("");
           }
         } catch (error) {
           throw error;
         }
         await this.waitOptionSelection();
-        if (value !== lastElement) {
-          await inputEl.clear();
-        }
       }
       async getHeaderFilterDictionaryInputValue() {
         if (await this.isHeaderFilterDictionaryEmpty()) {
           return [];
         }
-        const tags = await this.driver.findElements(
-          import_selenium_webdriver16.By.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER2} ${TAGS_SELECTOR2}`)
-        );
+        const tags = this.page.locator(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER2} ${TAGS_SELECTOR2}`);
+        const count = await tags.count();
         const values = [];
-        for (const tag of tags) {
-          values.push(await tag.getAttribute("textContent"));
+        for (let i = 0; i < count; i++) {
+          values.push(await tags.nth(i).innerText() ?? "");
         }
         return values;
       }
@@ -1344,26 +1286,26 @@ var init_editorFactory = __esm({
     init_ButtonGroup();
     init_DateEditor();
     init_HeaderFilterDictionary();
-    editorFactory = async (parentCssSelector, elementCssSelector, driver) => {
-      const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
-      const classSting = await elementInstance.getClasses();
-      if ((classSting.includes("text-control" /* Text */) || classSting.includes("text-area-control" /* TextArea */)) && !classSting.includes("single-date-range-control" /* SingleDateRange */))
-        return new TextEditor(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("number-control" /* Number */)) return new NumberEditor(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("check-box" /* CheckBox */)) return new CheckBox(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("multi-select-control" /* Multiselect */)) return new TagBox(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("select-control" /* Select */))
-        return new SelectBoxEditor(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("switch-control" /* Switch */)) return new SwitchEditor(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("date-control" /* Date */) || classSting.includes("single-date-range-control" /* SingleDateRange */)) {
-        return new DateEditor(parentCssSelector, elementCssSelector, driver);
-      }
-      if (classSting.includes("buttons-group" /* BooleanSelector */))
-        return new BooleanSelector(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("button-group-field" /* ButtonGroup */))
-        return new ButtonGroup(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("header-filter-dictionary" /* HeaderFilterDictionary */))
-        return new HeaderFilterDictionary(parentCssSelector, elementCssSelector, driver);
+    editorFactory = async (parentCssSelector, elementCssSelector, page) => {
+      const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, page);
+      const classString = await elementInstance.getClasses();
+      if ((classString.includes("text-control" /* Text */) || classString.includes("text-area-control" /* TextArea */)) && !classString.includes("single-date-range-control" /* SingleDateRange */))
+        return new TextEditor(parentCssSelector, elementCssSelector, page);
+      if (classString.includes("number-control" /* Number */)) return new NumberEditor(parentCssSelector, elementCssSelector, page);
+      if (classString.includes("check-box" /* CheckBox */)) return new CheckBox(parentCssSelector, elementCssSelector, page);
+      if (classString.includes("multi-select-control" /* Multiselect */)) return new TagBox(parentCssSelector, elementCssSelector, page);
+      if (classString.includes("select-control" /* Select */))
+        return new SelectBoxEditor(parentCssSelector, elementCssSelector, page);
+      if (classString.includes("switch-control" /* Switch */)) return new SwitchEditor(parentCssSelector, elementCssSelector, page);
+      if (classString.includes("date-control" /* Date */) || classString.includes("single-date-range-control" /* SingleDateRange */)) {
+        return new DateEditor(parentCssSelector, elementCssSelector, page);
+      }
+      if (classString.includes("buttons-group" /* BooleanSelector */))
+        return new BooleanSelector(parentCssSelector, elementCssSelector, page);
+      if (classString.includes("button-group-field" /* ButtonGroup */))
+        return new ButtonGroup(parentCssSelector, elementCssSelector, page);
+      if (classString.includes("header-filter-dictionary" /* HeaderFilterDictionary */))
+        return new HeaderFilterDictionary(parentCssSelector, elementCssSelector, page);
       throw new Error("Unknown type of editor. Please write ticket to the support");
     };
   }
@@ -1380,6 +1322,35 @@ var init_Editors = __esm({
   }
 });
 
+// src/pageObjects/elements/SubsystemsPanel/SubsystemItem.ts
+var SubsystemItem;
+var init_SubsystemItem = __esm({
+  "src/pageObjects/elements/SubsystemsPanel/SubsystemItem.ts"() {
+    "use strict";
+    init_waitElementIsVisible();
+    SubsystemItem = class {
+      bySelector;
+      page;
+      constructor({ page, bySelector }) {
+        this.bySelector = bySelector;
+        this.page = page;
+      }
+      getElement() {
+        return this.page.locator(this.bySelector);
+      }
+      async getTitle() {
+        await waitElementIsVisible_default({ locator: this.getElement() });
+        const el = this.getElement();
+        return await el.getAttribute("data-title");
+      }
+      async click() {
+        const el = this.getElement();
+        await el.click();
+      }
+    };
+  }
+});
+
 // src/utils/createDataTestId.ts
 function createDataTestId(formName, itemType, itemName) {
   return `${formName}-${itemType}-${itemName}`;
@@ -1420,45 +1391,145 @@ var init_createDataTestId = __esm({
   }
 });
 
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
+var SEARCH_ITEM_SELECTOR, BACK_BUTTON_SELECTOR, SEARCH_INPUT_SELECTOR, byTitleCssSelector, SubsystemsPanel;
+var init_SubsystemsPanel = __esm({
+  "src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts"() {
+    "use strict";
+    init_AbstractElement();
+    init_SubsystemsPanelHeader();
+    init_wait();
+    init_locators();
+    init_Editors();
+    init_SubsystemItem();
+    init_createDataTestId();
+    init_ClearButtonStrategy();
+    init_waitElementIsVisible();
+    SEARCH_ITEM_SELECTOR = "search-item";
+    BACK_BUTTON_SELECTOR = "subsystem-back-item";
+    SEARCH_INPUT_SELECTOR = "search-subsystem-input";
+    byTitleCssSelector = (title) => {
+      return `span[data-title="${title}"]`;
+    };
+    SubsystemsPanel = class extends AbstractElement {
+      header;
+      constructor(page) {
+        super(page);
+        this.header = new SubsystemsPanelHeader("#aside", byTestIdCssSelector("subsystems-panel-title", "span"), this.page);
+      }
+      async headerTitle() {
+        const title = await this.header.title();
+        await wait(async () => await title.innerText() != "", this.page);
+        return title.innerText();
+      }
+      getSearchComponent() {
+        return new TextEditor("#aside", byTestIdCssSelector(SEARCH_INPUT_SELECTOR), this.page);
+      }
+      /**
+       * Находит сабсистему по заголовку
+       * @example
+       * const subsystemsPanel= new SubsystemsPanel();
+       * //...
+       * await subsystemsPanel.search('SubSystemTitle');
+       */
+      async search(title) {
+        const searchComponent = this.getSearchComponent();
+        await this.searchClear();
+        await searchComponent.setValue(title);
+        await wait(
+          async () => {
+            const findElement = this.itemByTitle(title).getElement();
+            const classes = await findElement.getAttribute("class");
+            return classes.includes(SEARCH_ITEM_SELECTOR);
+          },
+          this.page,
+          `Cannot find element: ${title}`
+        );
+      }
+      /**
+       * Очищает поиск сабсистем
+       * @example
+       * const subsystemsPanel= new SubsystemsPanel();
+       * //...
+       * await subsystemsPanel.searchClear();
+       */
+      async searchClear() {
+        const clearBtnSelector = `#aside ${byTestIdCssSelector(SEARCH_INPUT_SELECTOR)} ${DX_CLEAR_BUTTON_AREA}`;
+        const clearBtn = this.page.locator(clearBtnSelector);
+        if (await clearBtn.isVisible()) {
+          await clearBtn.click();
+        }
+      }
+      /**
+       * Возвращает сабсистему по имени
+       * @example
+       * const subsystemsPanel= new SubsystemsPanel();
+       * //...
+       * const subsystem = subsystemsPanel.item('SubSystemName');
+       */
+      item(name) {
+        const elementCSS = createSubSystemTestId(name);
+        return new SubsystemItem({ page: this.page, bySelector: `${byTestIdCssSelector(elementCSS, "span")}` });
+      }
+      /**
+       * Возвращает сабсистему по заголовку
+       * @example
+       * const subsystemsPanel= new SubsystemsPanel();
+       * //...
+       * const subsystem = subsystemsPanel.itemByTitle('SubSystemTitle');
+       */
+      itemByTitle(title) {
+        return new SubsystemItem({ page: this.page, bySelector: byTitleCssSelector(title) });
+      }
+      /**
+       * Возвращается на уровень выше по сабсистемам
+       * @example
+       * const subsystemsPanel= new SubsystemsPanel();
+       * //...
+       * wait subsystemsPanel.back();
+       */
+      async back() {
+        const locator = this.page.locator(`#aside .${BACK_BUTTON_SELECTOR}`);
+        await waitElementIsVisible_default({ locator });
+        await locator.click();
+      }
+    };
+  }
+});
+
 // src/pageObjects/elements/AbstractButton.ts
 var D5_BUTTON_IS_PRESSED, AbstractButton;
 var init_AbstractButton = __esm({
   "src/pageObjects/elements/AbstractButton.ts"() {
     "use strict";
     init_AbstractElementWithParent();
-    init_actions();
-    init_waitElementIsClickable();
     D5_BUTTON_IS_PRESSED = "d5-is-pressed";
     AbstractButton = class extends AbstractElementWithParent {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+      }
+      get button() {
+        return this.getLocator();
+      }
+      getLocator() {
+        return super.getLocator();
       }
       async click() {
-        const button = await this.getElement();
-        await waitElementIsClickable_default({
-          element: button,
-          errorMessage: this.buttonNotDisplayedError(),
-          driver: this.driver
-        });
-        await click(button, this.driver);
+        await this.button.click();
       }
       async isDisabled() {
-        const button = await this.getElement();
-        return await button.getCssValue("pointer-events") === "none";
+        return await this.button.isDisabled();
       }
-      async isDisplayed() {
-        try {
-          const button = await this.getElement();
-          return await button.isDisplayed();
-        } catch {
-          return false;
-        }
+      async isVisible() {
+        return await this.button.isVisible();
       }
       async isPressed() {
         try {
-          const button = await this.getElement();
-          const classAttribute = await button.getAttribute("class");
-          return classAttribute.includes(D5_BUTTON_IS_PRESSED);
+          if (await this.button.isVisible()) {
+            const classAttribute = await this.button.getAttribute("class");
+            return classAttribute.includes(D5_BUTTON_IS_PRESSED);
+          }
+          return false;
         } catch {
           return false;
         }
@@ -1468,21 +1539,22 @@ var init_AbstractButton = __esm({
 });
 
 // src/pageObjects/elements/DXComponents/DXButton.ts
-var import_selenium_webdriver18, DXButton;
+var DXButton;
 var init_DXButton = __esm({
   "src/pageObjects/elements/DXComponents/DXButton.ts"() {
     "use strict";
     init_AbstractButton();
-    import_selenium_webdriver18 = require("selenium-webdriver");
     DXButton = class extends AbstractButton {
       async getText() {
         const classes = await this.getClasses();
-        if (!classes.includes("dx-button-has-text")) {
+        if (!classes?.includes("dx-button-has-text")) {
+          return null;
+        }
+        const textEl = this.getLocator().locator(".dx-button-text");
+        if (!await textEl.count()) {
           return null;
         }
-        const el = await this.getElement();
-        const textEl = el.findElement(import_selenium_webdriver18.By.className("dx-button-text"));
-        return await textEl.getText();
+        return await textEl.innerText();
       }
     };
   }
@@ -1498,8 +1570,8 @@ var init_FormButton = __esm({
     init_DXButton();
     FormButton = class extends DXButton {
       name;
-      constructor(parentCssSelector, formName, name, driver) {
-        super(parentCssSelector, byTestIdCssSelector(createFormButtonTestId(formName, name)), driver);
+      constructor(parentCssSelector, formName, name, page) {
+        super(parentCssSelector, byTestIdCssSelector(createFormButtonTestId(formName, name)), page);
         this.name = name;
       }
       buttonNotDisplayedError() {
@@ -1519,9 +1591,9 @@ var init_AbstractGroup = __esm({
     "use strict";
     init_AbstractElementWithParent();
     AbstractGroup = class extends AbstractElementWithParent {
-      async isDisplayed() {
-        const groupElement = await this.getElement();
-        return await groupElement.isDisplayed();
+      async isVisible() {
+        const groupElement = this.getLocator();
+        return await groupElement.isVisible();
       }
     };
   }
@@ -1539,24 +1611,24 @@ var init_Panel = __esm({
 });
 
 // src/pageObjects/elements/Groups/TabPanel.ts
-var import_selenium_webdriver19, TabPanelItem, TabPanel;
+var TabPanelItem, TabPanel;
 var init_TabPanel = __esm({
   "src/pageObjects/elements/Groups/TabPanel.ts"() {
     "use strict";
     init_AbstractGroup();
-    import_selenium_webdriver19 = require("selenium-webdriver");
-    init_actions();
     TabPanelItem = class extends AbstractGroup {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
+      }
+      get itemElement() {
+        return this.getLocator();
       }
       async click() {
-        await click(await this.getElement(), this.driver);
+        await this.itemElement.click();
       }
       async isActive() {
-        const tabPanelItemElement = await this.getElement();
-        const grandparentTab = await tabPanelItemElement.findElement(import_selenium_webdriver19.By.xpath('ancestor::div[@role="tab"][1]'));
-        return await grandparentTab.getAttribute("aria-selected") === "true";
+        const tab = this.itemElement.locator('xpath=ancestor::div[@role="tab"][1]');
+        return await tab.getAttribute("aria-selected") === "true";
       }
       async getTitle() {
         return "";
@@ -1564,7 +1636,11 @@ var init_TabPanel = __esm({
     };
     TabPanel = class extends AbstractGroup {
       item(name) {
-        return new TabPanelItem(this.getFullCssSelector(), `.tab-panel-item[data-groupname="${name}"]`, this.driver);
+        return new TabPanelItem(
+          this.getFullCssSelector(),
+          `.tab-panel-item[data-groupname="${name}"]`,
+          this.page
+        );
       }
       async getTitle() {
         return "";
@@ -1574,37 +1650,35 @@ var init_TabPanel = __esm({
 });
 
 // src/pageObjects/elements/Groups/Accordion/AccordionItem.ts
-var import_selenium_webdriver20, ACCORDION_TITLE_CONTAINER, AccordionItem;
+var ACCORDION_TITLE_CONTAINER, AccordionItem;
 var init_AccordionItem = __esm({
   "src/pageObjects/elements/Groups/Accordion/AccordionItem.ts"() {
     "use strict";
     init_AbstractGroup();
-    import_selenium_webdriver20 = require("selenium-webdriver");
-    init_actions();
-    ACCORDION_TITLE_CONTAINER = "accordion-title-container";
+    ACCORDION_TITLE_CONTAINER = ".accordion-title-container";
     AccordionItem = class extends AbstractGroup {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
       }
       async getDataOpenedAccordItemAttr() {
-        const accordionElement = await this.getElement();
-        return await accordionElement.getAttribute("data-opened");
+        const locator = this.getLocator();
+        if (await locator.isVisible()) {
+          return locator.getAttribute("data-opened");
+        }
+        return "";
       }
       async clickAccordionItemTitle() {
-        const accordionElement = await this.getElement();
-        const accordTitleElement = await accordionElement.findElement(import_selenium_webdriver20.By.className(ACCORDION_TITLE_CONTAINER));
-        await accordTitleElement.click();
+        await this.getLocator().locator(ACCORDION_TITLE_CONTAINER).click();
       }
       async click() {
-        await click(await this.getElement(), this.driver);
+        await this.getLocator().click();
       }
       async isExpanded() {
-        const dataOpened = await this.getDataOpenedAccordItemAttr();
-        return dataOpened === "true";
+        return await this.getDataOpenedAccordItemAttr() === "true";
       }
       async isCollapsed() {
-        const dataOpened = await this.getDataOpenedAccordItemAttr();
-        return dataOpened === "false" || !dataOpened;
+        const opened = await this.getDataOpenedAccordItemAttr();
+        return opened === "false" || opened === null;
       }
       async expand() {
         if (!await this.isExpanded()) {
@@ -1628,11 +1702,11 @@ var init_Accordion = __esm({
     init_AbstractGroup();
     init_AccordionItem();
     Accordion = class extends AbstractGroup {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
       }
       item(name) {
-        return new AccordionItem(this.getFullCssSelector(), `.d5-accordion-item[data-groupname="${name}"]`, this.driver);
+        return new AccordionItem(this.getFullCssSelector(), `.d5-accordion-item[data-groupname="${name}"]`, this.page);
       }
     };
   }
@@ -1648,14 +1722,14 @@ var init_groupFactory = __esm({
     init_TabPanel();
     init_Accordion();
     init_AccordionItem();
-    groupFactory = async (parentCssSelector, elementCssSelector, driver) => {
-      const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
+    groupFactory = async (parentCssSelector, elementCssSelector, page) => {
+      const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, page);
       const classSting = await elementInstance.getClasses();
-      if (classSting.includes("tab-panel-group")) return new TabPanel(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("tab-panel-item")) return new TabPanelItem(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("panel-group")) return new Panel(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("accordion-group")) return new Accordion(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("d5-accordion-item")) return new AccordionItem(parentCssSelector, elementCssSelector, driver);
+      if (classSting.includes("tab-panel-group")) return new TabPanel(parentCssSelector, elementCssSelector, page);
+      if (classSting.includes("tab-panel-item")) return new TabPanelItem(parentCssSelector, elementCssSelector, page);
+      if (classSting.includes("panel-group")) return new Panel(parentCssSelector, elementCssSelector, page);
+      if (classSting.includes("accordion-group")) return new Accordion(parentCssSelector, elementCssSelector, page);
+      if (classSting.includes("d5-accordion-item")) return new AccordionItem(parentCssSelector, elementCssSelector, page);
       throw new Error("Unknown type of group. Please write ticket to the support");
     };
   }
@@ -1674,23 +1748,23 @@ var init_FormGroup = __esm({
     init_TabPanel();
     FormGroup = class extends AbstractElementWithParent {
       groupInstance;
-      constructor(parentCssSelector, formName, name, driver) {
-        super(parentCssSelector, byTestIdCssSelector(createGroupTestId(formName, name)), driver);
+      constructor(parentCssSelector, formName, name, page) {
+        super(parentCssSelector, byTestIdCssSelector(createGroupTestId(formName, name)), page);
       }
       async initInstance() {
         if (!this.groupInstance) {
-          this.groupInstance = await groupFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
+          this.groupInstance = await groupFactory(this.parentCssSelector, this.elementCssSelector, this.page);
         }
       }
       /**
        * Возвращает булевое значение доступна ли группа
        * @example
-       * expect(await tableList.group('MainSuperPanel').isDisplayed();
+       * expect(await tableList.group('MainSuperPanel').isVisible();
        */
-      async isDisplayed() {
+      async isVisible() {
         try {
           await this.initInstance();
-          return this.groupInstance.isDisplayed();
+          return this.groupInstance.isVisible();
         } catch {
           return false;
         }
@@ -1766,10 +1840,12 @@ var init_AbstractForm = __esm({
     AbstractForm = class extends AbstractPage {
       containerCssSelector = "";
       _formName = "";
-      containerBy;
-      getContainerElement = () => {
-        return this.driver.findElement(this.containerBy);
-      };
+      get container() {
+        return this.page.locator(this.containerCssSelector);
+      }
+      constructor(page) {
+        super(page);
+      }
       set formName(name) {
         this._formName = name;
       }
@@ -1786,22 +1862,20 @@ var init_AbstractForm = __esm({
        */
       async exists() {
         try {
-          let elements = await this.driver.findElements(this.containerBy);
-          if (elements.length === 0) {
-            return false;
-          }
-          await waitElementIsVisible_default({
-            element: elements[0],
-            errorMessage: "Element exists in DOM but is not visible",
-            driver: this.driver
-          });
+          const container = this.page.locator(this.containerCssSelector);
+          await waitElementIsVisible_default({ locator: container });
           return true;
         } catch (error) {
           return false;
         }
       }
       button(name) {
-        return new FormButton(this.containerCssSelector, this.formName, name, this.driver);
+        return new FormButton(
+          this.containerCssSelector,
+          this.formName,
+          name,
+          this.page
+        );
       }
       /**
        * Находит группу на форме по имени
@@ -1811,7 +1885,12 @@ var init_AbstractForm = __esm({
        * expect(await formEdit.group('Name');
        */
       group(name) {
-        return new FormGroup(this.containerCssSelector, this.formName, name, this.driver);
+        return new FormGroup(
+          this.containerCssSelector,
+          this.formName,
+          name,
+          this.page
+        );
       }
     };
   }
@@ -1831,11 +1910,10 @@ function getCssRowByIndexSelector(index) {
 function getCssCellByIndexSelector(index) {
   return `td[role="gridcell"][aria-colindex="${transformInputIndex(index)}"]`;
 }
-var import_selenium_webdriver21, getColumnByIndexCssSelector, getColumnByCaptionCssSelector, getColumnByNameCssSelector, transformInputIndex, transformOutputIndex;
+var getColumnByIndexCssSelector, getColumnByCaptionCssSelector, getColumnByNameCssSelector, transformInputIndex, transformOutputIndex;
 var init_utils2 = __esm({
   "src/pageObjects/elements/Table/utils.ts"() {
     "use strict";
-    import_selenium_webdriver21 = require("selenium-webdriver");
     getColumnByIndexCssSelector = (columnIndex) => `td[aria-colindex="${transformInputIndex(columnIndex)}"]`;
     getColumnByCaptionCssSelector = (caption) => `td[role="columnheader"][aria-label="Column ${caption}"]`;
     getColumnByNameCssSelector = (name) => `td[role="columnheader"][data-fieldname="${name}"]`;
@@ -1852,19 +1930,18 @@ var init_types3 = __esm({
 });
 
 // src/pageObjects/elements/Table/elements/Cell.ts
-var import_selenium_webdriver22, Cell;
+var Cell;
 var init_Cell = __esm({
   "src/pageObjects/elements/Table/elements/Cell.ts"() {
     "use strict";
-    import_selenium_webdriver22 = require("selenium-webdriver");
     init_AbstractElementWithParent();
     init_utils2();
     init_types3();
     Cell = class extends AbstractElementWithParent {
       _index;
       getCellIndex;
-      constructor(parentCssSelector, getCellIndex, driver, index) {
-        super(parentCssSelector, getCssCellByIndexSelector(index), driver);
+      constructor(parentCssSelector, getCellIndex, page, index) {
+        super(parentCssSelector, getCssCellByIndexSelector(index), page);
         this.getCellIndex = getCellIndex;
         this._index = index;
       }
@@ -1873,25 +1950,27 @@ var init_Cell = __esm({
         this.elementCssSelector = getCssCellByIndexSelector(index);
       }
       async getBooleanValue(cellEl) {
-        const booleanEl = await cellEl.findElement(import_selenium_webdriver22.By.className("boolean-widget"));
-        return await booleanEl.getAttribute("aria-checked") === "true" ? 1 : 0;
+        const booleanEl = cellEl.locator(".boolean-widget");
+        const checked = await booleanEl.getAttribute("aria-checked");
+        return checked === "true" ? 1 : 0;
       }
       async getTagsValue(cellEl) {
-        const tagsCssSelector = ".multiselect-container .multiselect-cell";
-        const tags = await cellEl.findElements(import_selenium_webdriver22.By.css(tagsCssSelector));
+        const tags = cellEl.locator(".multiselect-container .multiselect-cell");
+        const count = await tags.count();
         const values = [];
-        for (const tag of tags) {
-          values.push(await tag.getAttribute("textContent"));
+        for (let i = 0; i < count; i++) {
+          const text = await tags.nth(i).innerText();
+          if (text) values.push(text.trim());
         }
         return values.length ? values : null;
       }
       async getNumberValue(cellEl) {
-        const value = (await cellEl.getText()).trim();
-        return value == "" ? null : Number.parseFloat(value);
+        const text = (await cellEl.innerText())?.trim() ?? "";
+        return text === "" ? null : Number.parseFloat(text);
       }
       async getDateValue(cellEl, cellElClass) {
-        const value = (await cellEl.getText()).trim();
-        if (value === "") return null;
+        const value = (await cellEl.innerText())?.trim() ?? "";
+        if (!value) return null;
         const getDate = (stringDate) => {
           const isWithTime = cellElClass.includes("with-time");
           try {
@@ -1917,21 +1996,21 @@ var init_Cell = __esm({
         }
         return getDate(value);
       }
-      async getElement() {
+      async element() {
         if (this._index == null) {
           this.index = await this.getCellIndex();
         }
-        return super.getElement();
+        return this.getLocator();
       }
       async getValue() {
-        const cellEl = await this.getElement();
-        const cellElClass = await cellEl.getAttribute("class");
+        const cellEl = await this.element();
+        const cellElClass = await cellEl.getAttribute("class") ?? "";
         if (cellElClass.includes("boolean-column" /* Boolean */)) return this.getBooleanValue(cellEl);
         if (cellElClass.includes("tags-column" /* Tags */)) return this.getTagsValue(cellEl);
         if (cellElClass.includes("number-column" /* Number */)) return this.getNumberValue(cellEl);
         if (cellElClass.includes("date-column" /* Date */)) return this.getDateValue(cellEl, cellElClass);
-        const cellText = await cellEl.getText();
-        return cellText == "" ? null : cellText;
+        const cellText = (await cellEl.innerText())?.trim() ?? "";
+        return cellText === "" ? null : cellText;
       }
       getIndex() {
         return this._index;
@@ -1941,17 +2020,14 @@ var init_Cell = __esm({
 });
 
 // src/pageObjects/elements/Table/elements/Row.ts
-var import_selenium_webdriver23, DX_SELECTION_CLASS, DX_ROW_EDIT_CLASS, DX_DATA_ROW_CLASS, FIRST_CLICKED_CELL_SELECTOR, Row;
+var DX_SELECTION_CLASS, DX_ROW_EDIT_CLASS, DX_DATA_ROW_CLASS, FIRST_CLICKED_CELL_SELECTOR, Row;
 var init_Row = __esm({
   "src/pageObjects/elements/Table/elements/Row.ts"() {
     "use strict";
-    import_selenium_webdriver23 = require("selenium-webdriver");
     init_Cell();
     init_utils2();
     init_AbstractElementWithParent();
-    init_actions();
     init_wait();
-    init_fixElementStaleError();
     DX_SELECTION_CLASS = "dx-selection";
     DX_ROW_EDIT_CLASS = "dx-edit-row";
     DX_DATA_ROW_CLASS = "dx-data-row";
@@ -1964,11 +2040,11 @@ var init_Row = __esm({
        * @param parentCssSelector
        * @param fixedTableContentCssSelector
        * @param index починається з 0 (в getCssRowByIndexSelector додається +1)
-       * @param driver
+       * @param page
        * @param getColumnBy
        */
-      constructor(parentCssSelector, fixedTableContentCssSelector, index, driver, getColumnBy) {
-        super(parentCssSelector, getCssRowByIndexSelector(index), driver);
+      constructor(parentCssSelector, fixedTableContentCssSelector, index, page, getColumnBy) {
+        super(parentCssSelector, getCssRowByIndexSelector(index), page);
         this.index = index;
         this.getColumnBy = getColumnBy;
         this.fixedTableContentCssSelector = fixedTableContentCssSelector;
@@ -1976,10 +2052,8 @@ var init_Row = __esm({
       _getCell({ index, name, title }) {
         return new Cell(
           this.getFullCssSelector(),
-          () => {
-            return this.getColumnBy({ title, name }).getIndex();
-          },
-          this.driver,
+          () => this.getColumnBy({ title, name }).getIndex(),
+          this.page,
           index
         );
       }
@@ -1993,61 +2067,56 @@ var init_Row = __esm({
         return this._getCell({ title });
       }
       async select(preserve = false) {
-        await staleElementAction(async () => {
-          const rowEl = await this.getElement();
-          const isSelected = (await this.getClasses()).includes(DX_SELECTION_CLASS);
-          const clickedElement = await rowEl.findElement(import_selenium_webdriver23.By.css(FIRST_CLICKED_CELL_SELECTOR));
-          if (isSelected && !preserve) {
-            await this.driver.actions({ async: true }).keyUp(import_selenium_webdriver23.Key.CONTROL).perform();
-          }
-          if (preserve && !isSelected) {
-            await this.driver.actions({ async: true }).keyDown(import_selenium_webdriver23.Key.CONTROL).perform();
-            await click(clickedElement, this.driver);
-            return;
-          }
-          await click(clickedElement, this.driver);
-        });
-        await safeWait(
+        const rowEl = this.getLocator();
+        const classes = await this.getClasses();
+        const isSelected = classes.includes(DX_SELECTION_CLASS);
+        const clickedElement = rowEl.locator(FIRST_CLICKED_CELL_SELECTOR);
+        if (isSelected && !preserve) {
+          await this.page.keyboard.up("Control");
+        }
+        if (preserve && !isSelected) {
+          await this.page.keyboard.down("Control");
+          await clickedElement.click();
+          return;
+        }
+        await clickedElement.click();
+        await wait(
           async () => {
-            const classes = await this.getClasses();
-            return classes.includes(DX_SELECTION_CLASS);
+            const classes2 = await this.getClasses();
+            return classes2.includes(DX_SELECTION_CLASS);
           },
-          this.driver,
+          this.page,
           "Cannot select row"
         );
       }
       async isSelected() {
-        const result = await this.getAttribute("aria-selected");
-        return result === "true";
+        const rowEl = this.getLocator();
+        const ariaSelected = await rowEl.getAttribute("aria-selected");
+        return ariaSelected === "true";
       }
       getIndex() {
         return this.index;
       }
       async getCells() {
-        const cells = await this.driver.findElements(import_selenium_webdriver23.By.css(`${this.getFullCssSelector()} td[role="gridcell"]`));
+        const rowEl = this.getLocator();
+        const cellsCount = await rowEl.locator('td[role="gridcell"]').count();
         const result = [];
-        cells.forEach((_, index) => {
-          const newCell = this.getCellByIndex(index);
-          result.push(newCell);
-        });
+        for (let i = 0; i < cellsCount; i++) {
+          result.push(this.getCellByIndex(i));
+        }
         return result;
       }
       async clickInlineButton(buttonClass) {
-        const buttonCssSelector = `.${DX_DATA_ROW_CLASS}[aria-rowindex="${transformInputIndex(
-          this.index
-        )}"] .${buttonClass}`;
-        const by = import_selenium_webdriver23.By.css(`${this.parentCssSelector} ${this.fixedTableContentCssSelector} ${buttonCssSelector}`);
-        await staleElementAction(async () => {
-          const button = await fixElementStaleError(by, this.driver);
-          await click(button, this.driver);
-        });
+        const buttonSelector = `.${DX_DATA_ROW_CLASS}[aria-rowindex="${transformInputIndex(this.index)}"] .${buttonClass}`;
+        const button = this.page.locator(`${this.parentCssSelector} ${this.fixedTableContentCssSelector} ${buttonSelector}`);
+        await button.click();
       }
       async checkEditingMode(isEditing, msg) {
-        await safeWait(
+        await wait(
           async () => {
             return (await this.getClasses()).includes(DX_ROW_EDIT_CLASS) === isEditing;
           },
-          this.driver,
+          this.page,
           msg
         );
       }
@@ -2068,21 +2137,19 @@ var init_Row = __esm({
 });
 
 // src/pageObjects/elements/Table/elements/Column.ts
-var import_selenium_webdriver24, Column;
+var Column;
 var init_Column = __esm({
   "src/pageObjects/elements/Table/elements/Column.ts"() {
     "use strict";
-    import_selenium_webdriver24 = require("selenium-webdriver");
     init_utils2();
     init_AbstractElementWithParent();
-    init_fixElementStaleError();
     Column = class extends AbstractElementWithParent {
       _index;
       _caption;
       _name;
       headerCssSelector;
-      constructor({ parentCssSelector, headerCssSelector, name, caption, index, driver }) {
-        super(parentCssSelector, "", driver);
+      constructor({ parentCssSelector, headerCssSelector, name, caption, index, page }) {
+        super(parentCssSelector, "", page);
         this._name = name;
         this.index = index;
         this._caption = caption;
@@ -2090,17 +2157,17 @@ var init_Column = __esm({
       }
       set index(index) {
         this._index = index;
-        this.elementCssSelector = getColumnByIndexCssSelector(index);
+        this.elementCssSelector = `${this.headerCssSelector} ${getColumnByIndexCssSelector(index)}`;
       }
       get index() {
         return this._index;
       }
-      async getElement() {
+      async element() {
         await this.getIndex();
-        return super.getElement();
+        return this.getLocator();
       }
       async getColumnHeaderIndexBy(cssSelector) {
-        const column = await fixElementStaleError(import_selenium_webdriver24.By.css(`${this.parentCssSelector} ${this.headerCssSelector} ${cssSelector}`), this.driver);
+        const column = this.page.locator(`${this.parentCssSelector} ${this.headerCssSelector} ${cssSelector}`);
         return transformOutputIndex(await column.getAttribute("aria-colindex"));
       }
       async getIndexByCaption() {
@@ -2110,13 +2177,12 @@ var init_Column = __esm({
         return this.getColumnHeaderIndexBy(getColumnByNameCssSelector(this._name));
       }
       async caption() {
-        const el = await this.getElement();
-        return el.getText();
+        const el = await this.element();
+        const text = await el.innerText();
+        return text?.trim() ?? null;
       }
       async getIndex() {
-        if (this.index != null) {
-          return this.index;
-        }
+        if (this.index != null) return this.index;
         if (this._caption != null) {
           this.index = await this.getIndexByCaption();
           return this.index;
@@ -2125,7 +2191,7 @@ var init_Column = __esm({
           this.index = await this.getIndexByName();
           return this.index;
         }
-        throw new Error("Cant get the index in the column");
+        throw new Error("Cannot get the index in the column");
       }
     };
   }
@@ -2139,31 +2205,24 @@ var init_EditorButton = __esm({
     init_locators();
     init_createDataTestId();
     init_AbstractElementWithParent();
-    init_waitElementIsClickable();
-    init_actions();
     EditorButton = class extends AbstractElementWithParent {
       name;
-      constructor(parentCssSelector, name, driver) {
-        super(parentCssSelector, byTestIdCssSelector(createEditorButtonTestId(name)), driver);
+      constructor(parentCssSelector, name, page) {
+        super(parentCssSelector, byTestIdCssSelector(createEditorButtonTestId(name)), page);
         this.name = name;
       }
       buttonNotDisplayedError() {
         return `Editor Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
       }
       async click() {
-        const button = await this.getElement();
-        await waitElementIsClickable_default({
-          element: button,
-          errorMessage: this.buttonNotDisplayedError(),
-          driver: this.driver
-        });
-        await click(button, this.driver);
+        const button = this.getLocator();
+        await button.click();
       }
-      async isDisplayed() {
+      async isVisible() {
         try {
-          const button = await this.getElement();
-          return await button.isDisplayed();
-        } catch (error) {
+          const button = this.getLocator();
+          return await button.isVisible();
+        } catch {
           return false;
         }
       }
@@ -2181,12 +2240,12 @@ var init_AbstractEditor2 = __esm({
     init_EditorButton();
     AbstractEditor = class extends AbstractElementWithParent {
       editor;
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
+      constructor(parentCssSelector, elementCssSelector, page) {
+        super(parentCssSelector, elementCssSelector, page);
       }
       async initEditor() {
         if (!this.editor) {
-          this.editor = await editorFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
+          this.editor = await editorFactory(this.parentCssSelector, this.elementCssSelector, this.page);
         }
       }
       /**
@@ -2254,16 +2313,16 @@ var init_AbstractEditor2 = __esm({
         return this.editor.isDisabled();
       }
       /**
-       * Возвращает значение true|false в зависимости isDisplayed поле или нет
+       * Возвращает значение true|false в зависимости isVisible поле или нет
        * @example
-       * expect(await formEdit.field('NumberFld').isDisplayed()).toBe(true);
-       * expect(await formEdit.field('TextFld').isDisplayed()).toBe(false);
+       * expect(await formEdit.field('NumberFld').isVisible()).toBe(true);
+       * expect(await formEdit.field('TextFld').isVisible()).toBe(false);
        */
-      async isDisplayed() {
+      async isVisible() {
         try {
           await this.initEditor();
-          const element = await this.getElement();
-          return await element.isDisplayed();
+          const element = this.getLocator();
+          return await element.isVisible();
         } catch {
           return false;
         }
@@ -2276,86 +2335,49 @@ var init_AbstractEditor2 = __esm({
        * await form.field('Name').button('editorButton).click()
        */
       button(name) {
-        return new EditorButton(this.getFullCssSelector(), name, this.driver);
+        return new EditorButton(this.getFullCssSelector(), name, this.page);
+      }
+    };
+  }
+});
+
+// src/pageObjects/elements/FormField.ts
+var FormField;
+var init_FormField = __esm({
+  "src/pageObjects/elements/FormField.ts"() {
+    "use strict";
+    init_locators();
+    init_createDataTestId();
+    init_AbstractEditor2();
+    FormField = class extends AbstractEditor {
+      constructor(parentCssSelector, formName, name, page) {
+        super(parentCssSelector, byTestIdCssSelector(createFieldTestId(formName, name)), page);
       }
     };
   }
 });
 
-// src/pageObjects/elements/FormField.ts
-var FormField;
-var init_FormField = __esm({
-  "src/pageObjects/elements/FormField.ts"() {
-    "use strict";
-    init_locators();
-    init_createDataTestId();
-    init_AbstractEditor2();
-    FormField = class extends AbstractEditor {
-      constructor(parentCssSelector, formName, name, driver) {
-        super(parentCssSelector, byTestIdCssSelector(createFieldTestId(formName, name)), driver);
-      }
-    };
-  }
-});
-
-// src/utils/typesUtil.ts
-var import_util, types, type, isArray, isString;
-var init_typesUtil = __esm({
-  "src/utils/typesUtil.ts"() {
-    "use strict";
-    import_util = require("selenium-webdriver/lib/util");
-    types = {
-      "[object Array]": "array",
-      "[object Date]": "date",
-      "[object Object]": "object",
-      "[object String]": "string",
-      "[object Null]": "null"
-    };
-    type = function(object) {
-      const typeOfObject = Object.prototype.toString.call(object);
-      return typeof object === "object" ? types[typeOfObject] || "object" : typeof object;
-    };
-    isArray = function(value) {
-      return type(value) === "array";
-    };
-    isString = function(object) {
-      return typeof object === "string";
-    };
-  }
-});
-
 // src/pageObjects/elements/AbstractDropDownMenuList.ts
 var AbstractDropDownMenuList;
 var init_AbstractDropDownMenuList = __esm({
   "src/pageObjects/elements/AbstractDropDownMenuList.ts"() {
     "use strict";
     init_AbstractElementWithParent();
-    init_actions();
-    init_waitElementIsClickable();
-    init_fixElementStaleError();
     init_typesUtil();
     AbstractDropDownMenuList = class extends AbstractElementWithParent {
-      buttonNotDisplayedError(name) {
-        return `Menu button ${name} cannot be clicked. It is not displayed or it is disabled`;
-      }
-      async clickItemBy(errorMessage, by) {
-        await waitElementIsClickable_default({
-          errorMessage,
-          driver: this.driver,
-          by
-        });
-        const menuItemElement = await fixElementStaleError(by, this.driver);
-        await click(menuItemElement, this.driver);
+      async clickItemBy(locator) {
+        const menuItemElement = this.page.locator(locator);
+        await menuItemElement.click();
       }
-      async getElementByPath(path2, getBy, returnLastElement = false) {
-        let pathList = isString(path2) ? [path2] : path2;
+      async getElementByPath(path, getBy, returnLastElement = false) {
+        let pathList = isString(path) ? [path] : path;
         let result = null;
         let index = 1;
         for (let text of pathList) {
           if (!returnLastElement || index < pathList.length) {
-            await this.clickItemBy(this.buttonNotDisplayedError(text), getBy(text));
+            await this.clickItemBy(getBy(text));
           } else {
-            result = await fixElementStaleError(getBy(text), this.driver);
+            result = this.page.locator(getBy(text));
           }
           index++;
         }
@@ -2380,26 +2402,12 @@ var init_AbstractDropDownMenuList = __esm({
   }
 });
 
-// src/utils/cssToXPath.ts
-function cssClassesToXPath(classNames) {
-  const classNamesList = classNames.split(".").filter((className) => !!className);
-  const chained = classNamesList.map((className) => `contains(@class, "${className}")`).join(" and ");
-  return `[${chained}]`;
-}
-var init_cssToXPath = __esm({
-  "src/utils/cssToXPath.ts"() {
-    "use strict";
-  }
-});
-
 // src/pageObjects/elements/DXContextMenuList.ts
-var import_selenium_webdriver25, CONTEXT_MENU_CLASS, CONTEXT_MENU_ITEM_TEXT_CLASS, DXContextMenuList;
+var CONTEXT_MENU_CLASS, CONTEXT_MENU_ITEM_TEXT_CLASS, DXContextMenuList;
 var init_DXContextMenuList = __esm({
   "src/pageObjects/elements/DXContextMenuList.ts"() {
     "use strict";
     init_AbstractDropDownMenuList();
-    import_selenium_webdriver25 = require("selenium-webdriver");
-    init_cssToXPath();
     init_waitElementIsVisible();
     CONTEXT_MENU_CLASS = "dx-context-menu";
     CONTEXT_MENU_ITEM_TEXT_CLASS = "dx-menu-item-text";
@@ -2407,23 +2415,21 @@ var init_DXContextMenuList = __esm({
       /**
        * @param parentCssSelector
        * @param classNames - Список класів. Починається з крапки
-       * @param driver
+       * @param page
        */
-      constructor(parentCssSelector, classNames, driver) {
-        super(parentCssSelector, `.${CONTEXT_MENU_CLASS}${classNames}`, driver);
+      constructor(parentCssSelector, classNames, page) {
+        super(parentCssSelector, `.${CONTEXT_MENU_CLASS}${classNames}`, page);
       }
       getButtonTitleBy(title) {
-        const buttonByTextXpath2 = (text) => `//span[contains(@class, "${CONTEXT_MENU_ITEM_TEXT_CLASS}") and contains(text(), "${text}")]`;
-        const xpath = "//div" + cssClassesToXPath(this.elementCssSelector) + buttonByTextXpath2(title);
-        return import_selenium_webdriver25.By.xpath(xpath);
+        return `${this.elementCssSelector} span.${CONTEXT_MENU_ITEM_TEXT_CLASS}:has-text("${title}")`;
       }
       async isVisible() {
         try {
+          const el = this.page.locator(`.dx-overlay-wrapper .${CONTEXT_MENU_CLASS}`);
           await waitElementIsVisible_default({
-            element: await this.driver.findElement(import_selenium_webdriver25.By.css(`.dx-overlay-wrapper .dx-context-menu`)),
-            driver: this.driver,
-            errorMessage: "Cannot find dropdown element"
+            locator: el
           });
+          return true;
         } catch {
           return false;
         }
@@ -2442,8 +2448,8 @@ var init_ContextMenu = __esm({
     ContextMenu = class extends DXContextMenuList {
       _formName;
       _initFn;
-      constructor(cssClass, formName, driver) {
-        super("", cssClass, driver);
+      constructor(cssClass, formName, page) {
+        super("", cssClass, page);
         this._formName = formName;
       }
       setInit(cb) {
@@ -2451,7 +2457,7 @@ var init_ContextMenu = __esm({
         return this;
       }
       getButtonNameBy(name) {
-        return byTestId(`cm-${this._formName}-${name}`);
+        return byTestIdCssSelector(`cm-${this._formName}-${name}`);
       }
       async clickButtonByTitle(title) {
         await this._initFn?.();
@@ -2466,20 +2472,17 @@ var init_ContextMenu = __esm({
 });
 
 // src/pageObjects/elements/Table/Table.ts
-var import_selenium_webdriver26, Table;
+var Table;
 var init_Table = __esm({
   "src/pageObjects/elements/Table/Table.ts"() {
     "use strict";
-    import_selenium_webdriver26 = require("selenium-webdriver");
     init_createDataTestId();
     init_AbstractElementWithParent();
     init_Row();
     init_Column();
     init_FormField();
     init_ContextMenu();
-    init_actions();
     init_wait();
-    init_withCustomTimeouts();
     Table = class extends AbstractElementWithParent {
       formName;
       headerCssSelector;
@@ -2493,9 +2496,9 @@ var init_Table = __esm({
         headerCssSelector,
         fixedTableContentCssSelector,
         formName,
-        driver
+        page
       }) {
-        super(parentCssSelector, `#${createTableId(formName)}`, driver);
+        super(parentCssSelector, `#${createTableId(formName)}`, page);
         this.formName = formName;
         this.headerCssSelector = headerCssSelector;
         this.contextMenuCssSelector = contextMenuCssSelector;
@@ -2513,7 +2516,7 @@ var init_Table = __esm({
        * @param index починається з 0
        */
       getRowByIndex(index) {
-        return new Row(this.getFullCssSelector(), this.fixedTableContentCssSelector, index, this.driver, this.getColumnBy);
+        return new Row(this.getFullCssSelector(), this.fixedTableContentCssSelector, index, this.page, this.getColumnBy);
       }
       /**
        * @param index починається з 0
@@ -2522,26 +2525,26 @@ var init_Table = __esm({
         this.getRowByIndex(index);
         return new Column({
           parentCssSelector: this.getFullCssSelector(),
-          driver: this.driver,
+          page: this.page,
           index
         });
       }
-      getColumnByTitle = (title) => {
+      getColumnByTitle(title) {
         return new Column({
           parentCssSelector: this.getFullCssSelector(),
           headerCssSelector: this.headerCssSelector,
           caption: title,
-          driver: this.driver
+          page: this.page
         });
-      };
-      getColumnByName = (name) => {
+      }
+      getColumnByName(name) {
         return new Column({
           parentCssSelector: this.getFullCssSelector(),
           headerCssSelector: this.headerCssSelector,
           name,
-          driver: this.driver
+          page: this.page
         });
-      };
+      }
       /**
        * Вибрати рядок по індексу.
        * @param index починається з 0
@@ -2559,48 +2562,31 @@ var init_Table = __esm({
           await this.selectRowByIndex(index, true);
         }
       }
-      getRowElements(timeout) {
-        const rowsFullCssSelector = `${this.getFullCssSelector()} ${this.tableContentCssSelector} .dx-row.dx-data-row`;
-        return withCustomTimeouts_default({
-          driver: this.driver,
-          timeout,
-          callback: () => {
-            return this.driver.findElements(import_selenium_webdriver26.By.css(rowsFullCssSelector));
-          }
-        });
+      getRowElements() {
+        const rowsSelector = `${this.getFullCssSelector()} ${this.tableContentCssSelector} .dx-row.dx-data-row`;
+        return this.page.locator(rowsSelector);
       }
       async getRows() {
-        const rows = await this.getRowElements();
+        const rowCount = await this.getRowElements().count();
         const result = [];
-        rows.forEach((_, index) => {
-          const newRow = new Row(
-            this.getFullCssSelector(),
-            this.fixedTableContentCssSelector,
-            index,
-            this.driver,
-            this.getColumnBy
-          );
-          result.push(newRow);
-        });
+        for (let i = 0; i < rowCount; i++) {
+          result.push(this.getRowByIndex(i));
+        }
         return result;
       }
       async getColumns() {
-        const columns = await this.driver.findElements(
-          import_selenium_webdriver26.By.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"] .header-template-text`)
+        const columnsLocator = this.page.locator(
+          `${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"] .header-template-text`
         );
+        const count = await columnsLocator.count();
         const result = [];
-        columns.forEach((_, index) => {
-          const newCol = new Column({
-            parentCssSelector: this.getFullCssSelector(),
-            index,
-            driver: this.driver
-          });
-          result.push(newCol);
-        });
+        for (let i = 0; i < count; i++) {
+          result.push(new Column({ parentCssSelector: this.getFullCssSelector(), page: this.page, index: i }));
+        }
         return result;
       }
       element() {
-        return this.getElement();
+        return this.getLocator();
       }
       /**
        * Находит поле когда форма находится в состоянии редактирования
@@ -2610,7 +2596,7 @@ var init_Table = __esm({
        * expect(await form.field('Name').getValue()).toBe('test value');
        */
       field(name) {
-        return new FormField(this.getFullCssSelector(), this.formName, name, this.driver);
+        return new FormField(this.getFullCssSelector(), this.formName, name, this.page);
       }
       /**
        * Возвращает список строк которые выделены
@@ -2622,11 +2608,11 @@ var init_Table = __esm({
        */
       async getSelectedRows() {
         const rows = await this.getRows();
-        let result = [];
+        const result = [];
         for (const row of rows) {
           if (await row.isSelected()) {
+            result.push(row);
           }
-          result.push(row);
         }
         return result;
       }
@@ -2643,17 +2629,16 @@ var init_Table = __esm({
        * await form.contextMenu('FieldName', 3).clickButton(['Group', 'ButtonInGroup']);
        */
       contextMenu(fieldName, rowIndex) {
-        return new ContextMenu(this.contextMenuCssSelector, this.formName, this.driver).setInit(async () => {
+        return new ContextMenu(this.contextMenuCssSelector, this.formName, this.page).setInit(async () => {
           let row;
           if (rowIndex != null) {
             row = this.getRowByIndex(rowIndex);
           } else {
             [row] = await this.getSelectedRows();
           }
-          if (!row)
-            throw new Error("No row available row for context menu");
-          const cellElement = await row.getCell(fieldName).getElement();
-          await contextMenu(cellElement, this.driver);
+          if (!row) throw new Error("No row available row for context menu");
+          const cellElement = await row.getCell(fieldName).element();
+          await cellElement.click({ button: "right" });
         });
       }
       /**
@@ -2665,16 +2650,14 @@ var init_Table = __esm({
        * @returns {Promise<string>} Повертає значення комірки
        *
        * @example
-       * const table = new Table(driver);
+       * const table = new Table(page);
        *
        * // Отримання значення комірки 'Name' в першому рядку (індекс 0)
        * const cellValue = await table.getCellValueByCellName('Name', 0);
        * expect(cellValue).toBe('Очікуване значення');
        */
       getCellValueByCellName(cellName, rowIndex) {
-        if (rowIndex == null) {
-          throw new Error("Error: getCellValue(): rowIndex is required");
-        }
+        if (rowIndex == null) throw new Error("Error: getCellValue(): rowIndex is required");
         const row = this.getRowByIndex(rowIndex);
         return row.getCell(cellName).getValue();
       }
@@ -2684,19 +2667,15 @@ var init_Table = __esm({
        * @returns {Promise<boolean>} Повертає true, якщо таблиця порожня, false - якщо містить рядки
        *
        * @example
-       * const table = new Table(driver);
+       * const table = new Table(page);
        *
        * // Перевірка чи порожня таблиця
        * const empty = await table.isEmpty();
        * expect(empty).toBe(true);
        */
       async isEmpty() {
-        try {
-          await this.waitRowsCount(0);
-          return true;
-        } catch {
-          return false;
-        }
+        const rowCount = await this.getRowElements().count();
+        return rowCount === 0;
       }
       /**
        * Очікує, поки кількість рядків у таблиці не стане рівною заданому значенню.
@@ -2707,7 +2686,7 @@ var init_Table = __esm({
        * @throws {Error} Викидає помилку, якщо очікування перевищує тайм-аут
        *
        * @example
-       * const table = new Table(driver);
+       * const table = new Table(page);
        *
        * // Очікування, поки таблиця не стане порожньою
        * await table.waitRowsCount(0);
@@ -2717,21 +2696,20 @@ var init_Table = __esm({
        * console.log('Таблиця містить 5 рядків');
        */
       async waitRowsCount(count) {
-        await safeWait(async () => {
-          const rows = await this.getRowElements(1e3);
-          return rows.length === count;
-        }, this.driver, `Rows count not equal: ${count}`);
+        await wait(async () => {
+          const rowsCount = await this.getRowElements().count();
+          return rowsCount === count;
+        }, this.page, `Rows count not equal: ${count}`);
       }
     };
   }
 });
 
 // src/pageObjects/elements/TableToolbar/ToolbarButton.ts
-var import_selenium_webdriver27, TOOLBAR_BUTTON_CLASS, TOOLBAR_BUTTON_TEXT_CLASS, getToolbarButtonSelector, getToolbarButtonTextSelector, getToolbarButtonTextByTestIdSelector, ToolbarButton;
+var TOOLBAR_BUTTON_CLASS, TOOLBAR_BUTTON_TEXT_CLASS, getToolbarButtonSelector, getToolbarButtonTextSelector, getToolbarButtonTextByTestIdSelector, ToolbarButton;
 var init_ToolbarButton = __esm({
   "src/pageObjects/elements/TableToolbar/ToolbarButton.ts"() {
     "use strict";
-    import_selenium_webdriver27 = require("selenium-webdriver");
     init_AbstractButton();
     init_locators();
     TOOLBAR_BUTTON_CLASS = "toolbar-button";
@@ -2741,8 +2719,8 @@ var init_ToolbarButton = __esm({
     getToolbarButtonTextByTestIdSelector = (testId) => `${byTestIdCssSelector(testId)} .${TOOLBAR_BUTTON_TEXT_CLASS}`;
     ToolbarButton = class extends AbstractButton {
       name;
-      constructor(parentCssSelector, name, driver) {
-        super(parentCssSelector, getToolbarButtonSelector(name), driver);
+      constructor(parentCssSelector, name, page) {
+        super(parentCssSelector, getToolbarButtonSelector(name), page);
         this.name = name;
       }
       buttonNotDisplayedError() {
@@ -2750,8 +2728,8 @@ var init_ToolbarButton = __esm({
       }
       async getTitle() {
         try {
-          const buttonTextContainer = await this.driver.findElement(import_selenium_webdriver27.By.css(getToolbarButtonTextSelector(this.name)));
-          return await buttonTextContainer.getText();
+          const buttonTextContainer = this.page.locator(getToolbarButtonTextSelector(this.name));
+          return await buttonTextContainer.innerText();
         } catch (_) {
           return null;
         }
@@ -2761,17 +2739,16 @@ var init_ToolbarButton = __esm({
 });
 
 // src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts
-var import_selenium_webdriver28, ToolbarGroupButton;
+var ToolbarGroupButton;
 var init_ToolbarGroupButton = __esm({
   "src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts"() {
     "use strict";
     init_AbstractButton();
-    import_selenium_webdriver28 = require("selenium-webdriver");
     init_ToolbarButton();
     ToolbarGroupButton = class extends AbstractButton {
       name;
-      constructor(parentCssSelector, name, driver) {
-        super(parentCssSelector, ``, driver);
+      constructor(parentCssSelector, name, page) {
+        super(parentCssSelector, ``, page);
         this.name = name;
       }
       buttonNotDisplayedError() {
@@ -2780,8 +2757,8 @@ var init_ToolbarGroupButton = __esm({
       async getTitle() {
         try {
           const buttonTestId = await this.getDataTestId();
-          const buttonTextContainer = await this.driver.findElement(import_selenium_webdriver28.By.css(getToolbarButtonTextByTestIdSelector(buttonTestId)));
-          return await buttonTextContainer.getText();
+          const buttonTextContainer = this.page.locator(getToolbarButtonTextByTestIdSelector(buttonTestId));
+          return await buttonTextContainer.innerText();
         } catch (_) {
           return null;
         }
@@ -2796,16 +2773,15 @@ var init_AbstractDropDownMenuButton = __esm({
   "src/pageObjects/elements/AbstractDropDownMenuButton.ts"() {
     "use strict";
     init_AbstractElementWithParent();
-    init_actions();
     AbstractDropDownMenuButton = class extends AbstractElementWithParent {
       _list;
-      constructor(parentCssSelector, elementCssSelector, list, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
+      constructor(parentCssSelector, elementCssSelector, list, page) {
+        super(parentCssSelector, elementCssSelector, page);
         this._list = list;
       }
       async openDropdownMenu() {
-        const dropdown = await this.getElement();
-        await click(dropdown, this.driver);
+        const dropdown = this.getLocator();
+        await dropdown.click();
         await this._list.isVisible();
       }
       async clickButton(name) {
@@ -2833,6 +2809,7 @@ var ToolbarMenuItem;
 var init_ToolbarMenuItem = __esm({
   "src/pageObjects/elements/TableToolbar/ToolbarMenuItem.ts"() {
     "use strict";
+    init_waitElementIsVisible();
     ToolbarMenuItem = class {
       getMenuItem;
       name;
@@ -2840,26 +2817,44 @@ var init_ToolbarMenuItem = __esm({
         this.getMenuItem = getMenuItem;
         this.name = name;
       }
+      isPressed() {
+        throw new Error("Method not implemented.");
+      }
+      getLocator() {
+        throw new Error("Method not implemented.");
+      }
       async click() {
-        const menuItemElement = await this.getMenuItem(this.name);
-        await menuItemElement.click();
+        try {
+          const menuItemElement = await this.getMenuItem(this.name);
+          await waitElementIsVisible_default({ locator: menuItemElement });
+          await menuItemElement.click();
+        } catch (error) {
+          throw new Error(`Cannot click on toolbar menu item: ${this.name}`);
+        }
       }
       async getTitle() {
         try {
           const menuItemElement = await this.getMenuItem(this.name);
-          return await menuItemElement.getText();
+          await waitElementIsVisible_default({ locator: menuItemElement });
+          return await menuItemElement.innerText();
         } catch (_) {
           return null;
         }
       }
       async isDisabled() {
-        const menuItemElement = await this.getMenuItem(this.name);
-        return await menuItemElement.getCssValue("pointer-events") === "none";
+        try {
+          const menuItemElement = await this.getMenuItem(this.name);
+          await waitElementIsVisible_default({ locator: menuItemElement });
+          return await menuItemElement.isDisabled();
+        } catch (_) {
+          return false;
+        }
       }
-      async isDisplayed() {
+      async isVisible() {
         try {
           const menuItemElement = await this.getMenuItem(this.name);
-          return await menuItemElement.isDisplayed();
+          await waitElementIsVisible_default({ locator: menuItemElement });
+          return await menuItemElement.isVisible();
         } catch (_) {
           return false;
         }
@@ -2883,8 +2878,8 @@ var init_ToolbarMenu = __esm({
     getFullCssSelector = (formName, name) => `${buttonGroupItemSelector(formName, name)} ${SPINDOWN_CLASS}`;
     ToolbarMenuList = class extends DXContextMenuList {
       _formName;
-      constructor(parentCssSelector, elementCssSelector, formName, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
+      constructor(parentCssSelector, elementCssSelector, formName, page) {
+        super(parentCssSelector, elementCssSelector, page);
         this._formName = formName;
       }
       getButtonNameBy(name) {
@@ -2892,10 +2887,10 @@ var init_ToolbarMenu = __esm({
       }
     };
     ToolbarMenu = class extends AbstractDropDownMenuButton {
-      constructor(parentCssSelector, formName, name, driver) {
+      constructor(parentCssSelector, formName, name, page) {
         const fullSelector = getFullCssSelector(formName, name);
-        const list = new ToolbarMenuList(parentCssSelector, ".toolbar-dropdown-context-menu", formName, driver);
-        super(parentCssSelector, fullSelector, list, driver);
+        const list = new ToolbarMenuList(parentCssSelector, ".toolbar-dropdown-context-menu", formName, page);
+        super(parentCssSelector, fullSelector, list, page);
       }
       checkNameValue(name) {
         if (!isString(name) && !isArray(name))
@@ -2913,13 +2908,13 @@ var init_ToolbarMenu = __esm({
         this.checkTitleValue(title);
         return new ToolbarMenuItem(this.getMenuItemElementByTitle.bind(this), title);
       }
-      async buttonIsDisplayed(name) {
+      async buttonIsVisible(name) {
         const button = this.buttonByName(name);
-        return await button.isDisplayed();
+        return await button.isVisible();
       }
-      async buttonByTitleIsDisplayed(title) {
+      async buttonByTitleIsVisible(title) {
         const button = this.buttonByTitle(title);
-        return await button.isDisplayed();
+        return await button.isVisible();
       }
       async buttonTitle(name) {
         const button = this.buttonByName(name);
@@ -2955,14 +2950,15 @@ var init_ToolbarItem = __esm({
     init_ToolbarButton();
     init_locators();
     init_ToolbarMenu();
+    init_waitElementIsVisible();
     GROUP_BUTTON_CLASS = "toolbar-group-button";
     toolbarItemSelector = (form, name) => byTestIdCssSelector(`ftb-${form}-${name}`);
     ToolbarItem = class extends AbstractElementWithParent {
       _button;
       _formName;
       _itemName;
-      constructor(parentCssSelector, formName, itemName, driver) {
-        super(parentCssSelector, toolbarItemSelector(formName, itemName), driver);
+      constructor(parentCssSelector, formName, itemName, page) {
+        super(parentCssSelector, toolbarItemSelector(formName, itemName), page);
         this._itemName = itemName;
         this._formName = formName;
       }
@@ -2970,23 +2966,33 @@ var init_ToolbarItem = __esm({
         if (this._button) return this._button;
         const classNames = await this.getClasses();
         if (classNames.includes(GROUP_BUTTON_CLASS)) {
-          this._button = new ToolbarGroupButton(this.getFullCssSelector(), this._itemName, this.driver);
+          this._button = new ToolbarGroupButton(this.getFullCssSelector(), this._itemName, this.page);
           return;
         }
-        this._button = new ToolbarButton(this.parentCssSelector, this._itemName, this.driver);
+        this._button = new ToolbarButton(this.parentCssSelector, this._itemName, this.page);
       }
       async click() {
-        await this.init();
-        await this._button.click();
+        try {
+          await this.init();
+          await waitElementIsVisible_default({ locator: this._button.getLocator() });
+          await this._button.click();
+        } catch (error) {
+          throw new Error(`Cannot click on toolbar item: ${this._itemName}`);
+        }
       }
       async isDisabled() {
-        await this.init();
-        return await this._button.isDisabled();
+        try {
+          await this.init();
+          await waitElementIsVisible_default({ locator: this._button.getLocator() });
+          return await this._button.isDisabled();
+        } catch (error) {
+          return false;
+        }
       }
-      async isDisplayed() {
+      async isVisible() {
         try {
           await this.init();
-          return this._button.isDisplayed();
+          return this._button.isVisible();
         } catch (error) {
           return false;
         }
@@ -3000,11 +3006,15 @@ var init_ToolbarItem = __esm({
         }
       }
       async getTitle() {
-        await this.init();
-        return await this._button.getTitle();
+        try {
+          await this.init();
+          return await this._button.getTitle();
+        } catch (error) {
+          return "";
+        }
       }
       get menu() {
-        return new ToolbarMenu(this.parentCssSelector, this._formName, this._itemName, this.driver);
+        return new ToolbarMenu(this.parentCssSelector, this._formName, this._itemName, this.page);
       }
     };
   }
@@ -3020,30 +3030,25 @@ var init_FormToolbar = __esm({
     TABLE_TOOLBAR_CLASS = "d5-table-toolbar";
     FormToolbar = class extends AbstractElementWithParent {
       formName;
-      constructor(parentCssSelector, formName, driver) {
-        super(parentCssSelector, `#${TABLE_TOOLBAR_CLASS}-${formName}`, driver);
+      constructor(parentCssSelector, formName, page) {
+        super(parentCssSelector, `#${TABLE_TOOLBAR_CLASS}-${formName}`, page);
         this.formName = formName;
       }
       button(name) {
-        return new ToolbarItem(this.getFullCssSelector(), this.formName, name, this.driver);
+        return new ToolbarItem(this.getFullCssSelector(), this.formName, name, this.page);
       }
     };
   }
 });
 
 // src/pageObjects/elements/Filters/FilterOperation.ts
-var import_selenium_webdriver29, FILTER_OPERATIONS, BUTTON_OPERATION_WIDGET, OPERATIONS_WIDGET_POPUP, getWidgetInPopupSelector, FilterOperation;
+var FILTER_OPERATIONS, BUTTON_OPERATION_WIDGET, OPERATIONS_WIDGET_POPUP, getWidgetInPopupSelector, FilterOperation;
 var init_FilterOperation = __esm({
   "src/pageObjects/elements/Filters/FilterOperation.ts"() {
     "use strict";
-    import_selenium_webdriver29 = require("selenium-webdriver");
-    init_fixElementStaleError();
     init_AbstractElementWithParent();
     init_locators();
-    init_actions();
     init_wait();
-    init_waitElementIsClickable();
-    init_waitElementIsVisible();
     FILTER_OPERATIONS = [
       "=",
       "<>",
@@ -3065,44 +3070,42 @@ var init_FilterOperation = __esm({
     getWidgetInPopupSelector = (operationName) => `.dx-list-item [data-operation="${operationName}"]`;
     FilterOperation = class extends AbstractElementWithParent {
       _testId;
-      constructor({ parentCssSelector, filterTestID, driver }) {
-        super(parentCssSelector, `${byTestIdCssSelector(`${BUTTON_OPERATION_WIDGET}-${filterTestID}`)}`, driver);
+      constructor({ parentCssSelector, filterTestID, page }) {
+        super(
+          parentCssSelector,
+          byTestIdCssSelector(`${BUTTON_OPERATION_WIDGET}-${filterTestID}`),
+          page
+        );
         this._testId = filterTestID;
       }
+      popup() {
+        return this.page.locator(
+          byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)
+        );
+      }
       async initOperationWidget() {
-        const widgetButtonEl = await this.getElement();
-        await waitElementIsClickable_default({
-          element: widgetButtonEl,
-          errorMessage: "Widget operation is not clickable",
-          driver: this.driver
-        });
-        const clickableElement = await widgetButtonEl.findElement(import_selenium_webdriver29.By.className("dx-icon"));
-        await click(clickableElement, this.driver);
-        try {
-          const widgetPopupEl = await this.driver.findElement(import_selenium_webdriver29.By.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)}`));
-          await waitElementIsVisible_default({
-            element: widgetPopupEl,
-            errorMessage: `Operation widget popup is not visible`,
-            driver: this.driver
-          });
-        } catch (_) {
-          throw `Operation widget popup is not visible`;
-        }
+        const widgetButton = this.getLocator();
+        const icon = widgetButton.locator(".dx-icon");
+        await icon.first().click();
+        const popup = this.popup();
+        await popup.waitFor({ state: "visible" });
       }
       async setOperation(operationName) {
         if (!FILTER_OPERATIONS.includes(operationName)) {
           throw new Error(`Operation with name "${operationName}" is not correct.`);
         }
         await this.initOperationWidget();
-        const operationEl = await fixElementStaleError(import_selenium_webdriver29.By.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)} ${getWidgetInPopupSelector(operationName)}`), this.driver);
-        await click(operationEl, this.driver);
-        await safeWait(
+        const operationItem = this.popup().locator(
+          getWidgetInPopupSelector(operationName)
+        );
+        await operationItem.click();
+        await wait(
           async () => {
             const currOperationName = await this.getAttribute("data-operation");
             if (operationName === "isblank") return true;
             return currOperationName === operationName;
           },
-          this.driver,
+          this.page,
           "Operation is not changed"
         );
       }
@@ -3115,12 +3118,12 @@ var init_FilterOperation = __esm({
         const currValue = await this.getIsBlank();
         if (currValue !== value) {
           await this.setOperation("isblank");
-          await safeWait(
+          await wait(
             async () => {
               const currIsBlank = await this.getIsBlank();
               return currIsBlank === value;
             },
-            this.driver,
+            this.page,
             "Operation is not changed"
           );
         }
@@ -3145,8 +3148,8 @@ var init_FormFilterField = __esm({
     FormFilterField = class extends AbstractEditor {
       formName;
       name;
-      constructor(parentCssSelector, formName, name, driver) {
-        super(parentCssSelector, byTestIdCssSelector(createLayoutFilterTestId(formName, name)), driver);
+      constructor(parentCssSelector, formName, name, page) {
+        super(parentCssSelector, byTestIdCssSelector(createLayoutFilterTestId(formName, name)), page);
         this.formName = formName;
         this.name = name;
       }
@@ -3198,7 +3201,7 @@ var init_FormFilterField = __esm({
         return new FilterOperation({
           parentCssSelector: this.parentCssSelector,
           filterTestID: createLayoutFilterTestId(this.formName, this.name),
-          driver: this.driver
+          page: this.page
         });
       }
       /**
@@ -3259,8 +3262,8 @@ var init_PanelFilterField = __esm({
     PanelFilterField = class extends AbstractEditor {
       formName;
       name;
-      constructor(parentCssSelector, formName, name, driver) {
-        super(parentCssSelector, byTestIdCssSelector(createDocFilterTestId(formName, name)), driver);
+      constructor(parentCssSelector, formName, name, page) {
+        super(parentCssSelector, byTestIdCssSelector(createDocFilterTestId(formName, name)), page);
         this.formName = formName;
         this.name = name;
       }
@@ -3312,7 +3315,7 @@ var init_PanelFilterField = __esm({
         return new FilterOperation({
           parentCssSelector: this.parentCssSelector,
           filterTestID: createDocFilterTestId(this.formName, this.name),
-          driver: this.driver
+          page: this.page
         });
       }
       /**
@@ -3362,14 +3365,12 @@ var init_PanelFilterField = __esm({
 });
 
 // src/pageObjects/elements/Filters/FilterPanel.ts
-var import_selenium_webdriver30, drawerSelector, FILTER_PANEL_SELECTOR, CLOSE_SELECTOR, FilterPanel;
+var drawerSelector, FILTER_PANEL_SELECTOR, CLOSE_SELECTOR, FilterPanel;
 var init_FilterPanel = __esm({
   "src/pageObjects/elements/Filters/FilterPanel.ts"() {
     "use strict";
-    import_selenium_webdriver30 = require("selenium-webdriver");
     init_AbstractElement();
     init_PanelFilterField();
-    init_actions();
     drawerSelector = (formName) => `.secondary-drawer-side-panel.form-${formName}`;
     FILTER_PANEL_SELECTOR = ".filter-panel";
     CLOSE_SELECTOR = ".button-close";
@@ -3380,11 +3381,10 @@ var init_FilterPanel = __esm({
       }
       async filterPanelButtons() {
         const selector = `${this.elementCssSelector} ${FILTER_PANEL_SELECTOR} .filter-panel__buttons-panel .dx-button-text`;
-        const el = await this.getElement();
-        return el.findElements(import_selenium_webdriver30.By.css(selector));
+        return this.page.locator(selector).all();
       }
-      constructor(formName, driver) {
-        super(driver, drawerSelector(formName));
+      constructor(formName, page) {
+        super(page, drawerSelector(formName));
         this._formName = formName;
       }
       /**
@@ -3394,28 +3394,28 @@ var init_FilterPanel = __esm({
        * await form.filterPanel.filterField('NumberFld');
        */
       filterField(name) {
-        return new PanelFilterField(this.filterPanelSelector, this._formName, name, this.driver);
+        return new PanelFilterField(this.filterPanelSelector, this._formName, name, this.page);
       }
       async apply() {
         const btn = await this.findButtonByTitle("\u0417\u0430\u0441\u0442\u043E\u0441\u0443\u0432\u0430\u0442\u0438");
-        await click(btn, this.driver);
+        await btn.click();
       }
       async findButtonByTitle(title) {
         const buttons = await this.filterPanelButtons();
         for (const btn of buttons) {
-          if (await btn.getText() === title) {
+          if (await btn.innerText() === title) {
             return btn;
           }
         }
       }
       async clearAll() {
         const btn = await this.findButtonByTitle("\u041E\u0447\u0438\u0441\u0442\u0438\u0442\u0438");
-        await click(btn, this.driver);
-        await this.driver.sleep(300);
+        await btn.click();
+        await this.page.waitForTimeout(300);
       }
       async close() {
-        const btn = await this.driver.findElement(import_selenium_webdriver30.By.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
-        await click(btn, this.driver);
+        const btn = this.page.locator(`${this.elementCssSelector} ${CLOSE_SELECTOR}`);
+        await btn.click();
       }
     };
   }
@@ -3430,8 +3430,8 @@ var init_HeaderFilterField = __esm({
     init_createDataTestId();
     init_AbstractEditor2();
     HeaderFilterField = class extends AbstractEditor {
-      constructor(parentCssSelector, formName, name, driver) {
-        super(parentCssSelector, byTestIdCssSelector(createHeaderFilterTestId(formName, name)), driver);
+      constructor(parentCssSelector, formName, name, page) {
+        super(parentCssSelector, byTestIdCssSelector(createHeaderFilterTestId(formName, name)), page);
       }
       async getValue() {
         return super.getValue();
@@ -3456,71 +3456,51 @@ var init_HeaderFilterField = __esm({
 });
 
 // src/pageObjects/elements/Filters/ColumnFilter.ts
-var import_selenium_webdriver31, APPLY_SELECTOR, CANCEL_SELECTOR, HEADER_FILTER_ICON, HEADER_FILTER_CONTAINER, HEADER_FILTER_BUTTONS, ColumnFilter;
+var APPLY_SELECTOR, CANCEL_SELECTOR, HEADER_FILTER_ICON, HEADER_FILTER_CONTAINER, HEADER_FILTER_BUTTONS, ColumnFilter;
 var init_ColumnFilter = __esm({
   "src/pageObjects/elements/Filters/ColumnFilter.ts"() {
     "use strict";
-    init_actions();
-    import_selenium_webdriver31 = require("selenium-webdriver");
     init_HeaderFilterField();
-    init_waitElementIsVisible();
-    init_AbstractElement();
     init_FilterOperation();
     init_createDataTestId();
-    init_wait();
+    init_waitElementIsVisible();
     APPLY_SELECTOR = ".apply-button";
     CANCEL_SELECTOR = ".cancel-button";
     HEADER_FILTER_ICON = ".indicators-container .filter-icon";
     HEADER_FILTER_CONTAINER = ".header-filter";
     HEADER_FILTER_BUTTONS = ".header-filter-buttons";
-    ColumnFilter = class extends AbstractElement {
+    ColumnFilter = class {
       _formName;
       _name;
       _column;
-      constructor(formName, name, column, driver) {
-        super(driver, HEADER_FILTER_CONTAINER);
+      page;
+      constructor(formName, name, column, page) {
         this._formName = formName;
         this._name = name;
         this._column = column;
-        this.driver = driver;
+        this.page = page;
       }
-      async getApplyButton() {
-        const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${APPLY_SELECTOR}`;
-        return this.driver.findElement(import_selenium_webdriver31.By.css(selector));
+      getApplyButton() {
+        return this.page.locator(`${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${APPLY_SELECTOR}`);
       }
-      async getCancelButton() {
-        const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${CANCEL_SELECTOR}`;
-        return this.driver.findElement(import_selenium_webdriver31.By.css(selector));
+      getCancelButton() {
+        return this.page.locator(`${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${CANCEL_SELECTOR}`);
       }
       async apply() {
-        const btn = await this.getApplyButton();
-        await click(btn, this.driver);
+        await this.getApplyButton().click();
       }
       async cancel() {
-        const btn = await this.getCancelButton();
-        await click(btn, this.driver);
+        await this.getCancelButton().click();
       }
       async initFilter() {
-        const columnEl = await this._column.getElement();
-        const actions = this.driver.actions({ async: true });
-        await actions.move({ origin: columnEl }).perform();
-        const headerFilterIconBy = import_selenium_webdriver31.By.css(HEADER_FILTER_ICON);
-        let headerFilterIcon = await columnEl.findElement(headerFilterIconBy);
-        await safeWait(
-          () => {
-            return headerFilterIcon.isDisplayed();
-          },
-          this.driver,
-          `HeaderFilter "${this._name}" is not visible`
-        );
-        await click(headerFilterIcon, this.driver);
-        const filter = new HeaderFilterField("", this._formName, this._name, this.driver);
-        const filterEl = await filter.getElement();
-        await waitElementIsVisible_default({
-          element: filterEl,
-          driver: this.driver,
-          errorMessage: `Header filter is not visible`
-        });
+        const columnEl = await this._column.element();
+        await columnEl.hover();
+        const headerFilterIcon = columnEl.locator(HEADER_FILTER_ICON);
+        await headerFilterIcon.waitFor({ state: "visible" });
+        await headerFilterIcon.click();
+        const filter = new HeaderFilterField("", this._formName, this._name, this.page);
+        const filterEl = filter.getLocator();
+        await waitElementIsVisible_default({ locator: filterEl });
         return filter;
       }
       /**
@@ -3547,9 +3527,9 @@ var init_ColumnFilter = __esm({
         const filterOperation = new FilterOperation({
           parentCssSelector: HEADER_FILTER_CONTAINER,
           filterTestID: createHeaderFilterTestId(this._formName, this._name),
-          driver: this.driver
+          page: this.page
         });
-        const inputEl = await filter.getElement();
+        const inputEl = filter.getLocator();
         if (typeof operation === "string") {
           await inputEl.click();
           await filterOperation.setOperation(operation);
@@ -3559,7 +3539,7 @@ var init_ColumnFilter = __esm({
           await filterOperation.setIsBlank(isBlank);
         }
         await filter.setValue(value);
-        return this.apply();
+        await this.apply();
       }
       /**
        * Очищает значение в поле
@@ -3586,12 +3566,12 @@ var init_ColumnFilter = __esm({
        */
       async initOperation() {
         const filter = await this.initFilter();
-        const inputEl = await filter.getElement();
+        const inputEl = filter.getLocator();
         await inputEl.click();
         return new FilterOperation({
           parentCssSelector: HEADER_FILTER_CONTAINER,
           filterTestID: createHeaderFilterTestId(this._formName, this._name),
-          driver: this.driver
+          page: this.page
         });
       }
       /**
@@ -3611,7 +3591,7 @@ var init_ColumnFilter = __esm({
        */
       async getOperation() {
         const filterOperation = await this.initOperation();
-        return await filterOperation.getOperation();
+        return filterOperation.getOperation();
       }
       /**
        * Устанавливает операцию 'isblank' для фильтра
@@ -3630,7 +3610,7 @@ var init_ColumnFilter = __esm({
        */
       async getIsBlank() {
         const filterOperation = await this.initOperation();
-        return await filterOperation.getIsBlank();
+        return filterOperation.getIsBlank();
       }
       async isReadonly() {
         const filter = await this.initFilter();
@@ -3672,8 +3652,8 @@ var init_ListForm = __esm({
       fixedTableContentCssSelector;
       tableContentCssSelector;
       contextMenuCssSelector;
-      constructor(driver) {
-        super(driver);
+      constructor(page) {
+        super(page);
         this.popupContainerCssSelector = `.popup.form-inline-${this.formName}`;
         this.headerCssSelector = DATAGRID_HEADER_CSS_SELECTOR;
         this.fixedTableContentCssSelector = FIXED_DATAGRID_CONTENT_CSS_SELECTOR;
@@ -3688,17 +3668,15 @@ var init_ListForm = __esm({
        * expect(listForm.table());
        */
       table() {
-        return new Table(
-          {
-            parentCssSelector: this.containerCssSelector,
-            headerCssSelector: this.headerCssSelector,
-            fixedTableContentCssSelector: this.fixedTableContentCssSelector,
-            formName: this.formName,
-            driver: this.driver,
-            contextMenuCssSelector: this.contextMenuCssSelector,
-            tableContentCssSelector: this.tableContentCssSelector
-          }
-        );
+        return new Table({
+          parentCssSelector: this.containerCssSelector,
+          headerCssSelector: this.headerCssSelector,
+          fixedTableContentCssSelector: this.fixedTableContentCssSelector,
+          formName: this.formName,
+          page: this.page,
+          contextMenuCssSelector: this.contextMenuCssSelector,
+          tableContentCssSelector: this.tableContentCssSelector
+        });
       }
       /**
        * Находит таблицу
@@ -3708,7 +3686,7 @@ var init_ListForm = __esm({
        * expect(listForm.toolbarButton());
        */
       toolbarButton(name) {
-        const toolbar = new FormToolbar(this.containerCssSelector, this.formName, this.driver);
+        const toolbar = new FormToolbar(this.containerCssSelector, this.formName, this.page);
         return toolbar.button(name);
       }
       /**
@@ -3719,11 +3697,11 @@ var init_ListForm = __esm({
        * expect(listForm.formFilter());
        */
       formFilter(name) {
-        return new FormFilterField(this.containerCssSelector, this.formName, name, this.driver);
+        return new FormFilterField(this.containerCssSelector, this.formName, name, this.page);
       }
       columnFilter(name) {
         const column = this.table().getColumnByName(name);
-        return new ColumnFilter(this.formName, name, column, this.driver);
+        return new ColumnFilter(this.formName, name, column, this.page);
       }
       /**
        * Модель панели фильтрации
@@ -3734,7 +3712,7 @@ var init_ListForm = __esm({
        * expect(listForm.filterPanel());
        */
       get filterPanel() {
-        return new FilterPanel(this.formName, this.driver);
+        return new FilterPanel(this.formName, this.page);
       }
     };
   }
@@ -3754,8 +3732,8 @@ var init_TreeView = __esm({
     TREELIST_CONTENT_CSS_SELECTOR = ".dx-treelist-content .dx-treelist-table.dx-treelist-table-fixed";
     FIXED_TREELIST_CONTENT_CSS_SELECTOR = ".dx-treelist-sticky-columns .dx-treelist-content .dx-treelist-table.dx-treelist-table-fixed";
     TreeView = class extends ListForm {
-      constructor(driver) {
-        super(driver);
+      constructor(page) {
+        super(page);
         this.popupContainerCssSelector = `.popup.tree-view-${this.formName}`;
         this.headerCssSelector = TREELIST_HEADER_CSS_SELECTOR;
         this.fixedTableContentCssSelector = FIXED_TREELIST_CONTENT_CSS_SELECTOR;
@@ -3805,29 +3783,28 @@ var init_createSubFormInstance = __esm({
 });
 
 // src/pageObjects/elements/Forms/Form.ts
-var import_selenium_webdriver32, formTestId, Form;
+var formTestId, Form;
 var init_Form = __esm({
   "src/pageObjects/elements/Forms/Form.ts"() {
     "use strict";
     init_locators();
-    import_selenium_webdriver32 = require("selenium-webdriver");
     init_AbstractForm();
-    init_waitElementIsVisible();
     init_createSubFormInstance();
+    init_waitElementIsVisible();
     formTestId = (formName) => `form-content-wrapper-${formName}`;
     Form = class extends AbstractForm {
       popupContainerCssSelector;
-      constructor(driver) {
-        super(driver);
+      constructor(page) {
+        super(page);
         this.setSubFormMode();
       }
       async isModal() {
-        const el = await this.getContainerElement();
+        const el = this.getContainerElement();
         const value = await el.getAttribute("data-ismodal");
         return value === "true";
       }
       async isFullScreen() {
-        const el = await this.getContainerElement();
+        const el = this.getContainerElement();
         const value = await el.getAttribute("data-isfullscreen");
         return value === "true";
       }
@@ -3837,29 +3814,27 @@ var init_Form = __esm({
        * const listForm = new MyForm();
        * //...
        * expect(await listForm.getTitleText()).toBe('MyFormTitle');
+       * Получение заголовка на форме
        */
       async getTitleText() {
         const getFullScreenTitle = async () => {
-          let titleEl = await this.driver.findElement(import_selenium_webdriver32.By.className("main-toolbar-form-title"));
-          return titleEl.getText();
+          const titleEl = this.page.locator(".main-toolbar-form-title");
+          return titleEl.innerText();
         };
         if (await this.isFullScreen()) {
           return getFullScreenTitle();
         }
         if (await this.isModal()) {
-          const titleEl = await this.driver.findElement(import_selenium_webdriver32.By.css(`${this.popupContainerCssSelector} .popup-title`));
+          const titleEl = this.page.locator(`${this.popupContainerCssSelector} .popup-title`);
           await waitElementIsVisible_default({
-            element: titleEl,
-            driver: this.driver,
-            errorMessage: `Form title element is not visible`
+            locator: titleEl
           });
-          return titleEl.getText();
+          return titleEl.innerText();
         }
         return getFullScreenTitle();
       }
       setSubFormMode() {
         const testId = formTestId(this.formName);
-        this.containerBy = byTestId(testId);
         this.containerCssSelector = byTestIdCssSelector(testId);
       }
       /**
@@ -3873,26 +3848,26 @@ var init_Form = __esm({
       async subForm(name, options = {}) {
         const { isDockPanel = false } = options;
         const cssSelector = subformCssSelector(this.containerCssSelector, subFormTestId(name), isDockPanel);
-        const byCssSelector = import_selenium_webdriver32.By.css(cssSelector);
-        const subFormEl = await this.driver.findElement(byCssSelector);
+        const subFormEl = this.page.locator(cssSelector);
         await waitElementIsVisible_default({
-          element: subFormEl,
-          driver: this.driver,
-          errorMessage: `Subform "${name}" is not visible`
+          locator: subFormEl
         });
         const formType = await subFormEl.getAttribute("data-formtype");
-        const formName = await subFormEl.getAttribute("data-formname");
-        let SubFormFactoryClass = await classDependencyInjector(formType);
+        const formName = await subFormEl.getAttribute("data-formname") ?? "";
+        const SubFormFactoryClass = await classDependencyInjector(formType);
         const SubForm = class extends SubFormFactoryClass {
           setSubFormMode() {
             this.containerCssSelector = cssSelector;
-            this.containerBy = byCssSelector;
+            this.containerBy = cssSelector;
           }
           get formName() {
             return formName;
           }
         };
-        return new SubForm(this.driver);
+        return new SubForm(this.page);
+      }
+      getContainerElement() {
+        return this.page.locator(this.containerCssSelector);
       }
     };
   }
@@ -3903,20 +3878,18 @@ var FormEdit_exports = {};
 __export(FormEdit_exports, {
   default: () => FormEdit
 });
-var import_selenium_webdriver33, FormEdit;
+var FormEdit;
 var init_FormEdit = __esm({
   "src/pageObjects/elements/Forms/FormEdit.ts"() {
     "use strict";
     init_Form();
-    import_selenium_webdriver33 = require("selenium-webdriver");
     init_FormField();
-    init_actions();
     init_wait();
     FormEdit = class extends Form {
       saveButtonId = "#button-save";
       closeButtonId = "#button-cancel";
-      constructor(driver) {
-        super(driver);
+      constructor(page) {
+        super(page);
         this.popupContainerCssSelector = `.popup.form-edit-${this.formName}`;
       }
       async getButtonCssSelector(buttonId) {
@@ -3933,7 +3906,7 @@ var init_FormEdit = __esm({
        * expect(await formEdit.field('Name').getValue()).toBe('test value');
        */
       field(name) {
-        return new FormField(this.containerCssSelector, this.formName, name, this.driver);
+        return new FormField(this.containerCssSelector, this.formName, name, this.page);
       }
       /**
        * Проверяет не отключена ли кнопка Сохранить
@@ -3944,7 +3917,7 @@ var init_FormEdit = __esm({
        */
       async isSaveButtonDisabled() {
         const saveButtonCssSelector = await this.getButtonCssSelector(this.saveButtonId);
-        const saveButton = await this.driver.findElement(import_selenium_webdriver33.By.css(saveButtonCssSelector));
+        const saveButton = this.page.locator(saveButtonCssSelector);
         const result = await saveButton.getAttribute("aria-disabled");
         return result === "true";
       }
@@ -3957,9 +3930,9 @@ var init_FormEdit = __esm({
        */
       async saveButtonClick() {
         const saveButtonCssSelector = await this.getButtonCssSelector(this.saveButtonId);
-        const saveButton = await this.driver.findElement(import_selenium_webdriver33.By.css(saveButtonCssSelector));
-        await safeWait(async () => !await this.isSaveButtonDisabled(), this.driver, "Button is disabled");
-        await click(saveButton, this.driver);
+        const saveButton = this.page.locator(saveButtonCssSelector);
+        await wait(async () => !await this.isSaveButtonDisabled(), this.page, "Button is disabled");
+        await saveButton.click();
       }
       /**
        * Нажатие на кнопку Закрить
@@ -3970,8 +3943,91 @@ var init_FormEdit = __esm({
        */
       async closeButtonClick() {
         const closeButtonCssSelector = await this.getButtonCssSelector(this.closeButtonId);
-        const closeButton = await this.driver.findElement(import_selenium_webdriver33.By.css(closeButtonCssSelector));
-        await click(closeButton, this.driver);
+        const closeButton = this.page.locator(closeButtonCssSelector);
+        await closeButton.click();
+      }
+    };
+  }
+});
+
+// src/pageObjects/elements/Forms/ReportForm.ts
+var ReportForm;
+var init_ReportForm = __esm({
+  "src/pageObjects/elements/Forms/ReportForm.ts"() {
+    "use strict";
+    init_FormEdit();
+    ReportForm = class extends FormEdit {
+      constructor(page) {
+        super(page);
+        this.popupContainerCssSelector = `.popup.form-report-${this.formName}`;
+        this.saveButtonId = "#button-apply";
+      }
+      /**
+       * Знаходить поле/фільтр у формі репорту за ім'ям
+       * @example
+       * const formReport = new MyForm();
+       * //...
+       * expect(await formReport.filterField('Name').getValue()).toBe('test value');
+       */
+      filterField(name) {
+        return super.field(name);
+      }
+    };
+  }
+});
+
+// src/pageObjects/elements/Dialog.ts
+var DIALOG_CLASS, DIALOG_TITLE_CLASS, DIALOG_TEXT_CLASS, DIALOG_BUTTONS_PANEL_CLASS, buttonByTextXpath, DialogButton, Dialog;
+var init_Dialog = __esm({
+  "src/pageObjects/elements/Dialog.ts"() {
+    "use strict";
+    init_AbstractElement();
+    init_AbstractButton();
+    DIALOG_CLASS = ".d5-dialog";
+    DIALOG_TITLE_CLASS = ".dialog__title";
+    DIALOG_TEXT_CLASS = ".dialog__text";
+    DIALOG_BUTTONS_PANEL_CLASS = ".dialog__buttons-panel";
+    buttonByTextXpath = (text) => `xpath=.//span[contains(@class, "dx-button-text") and contains(text(), "${text}")]`;
+    DialogButton = class extends AbstractButton {
+      text;
+      constructor(parentCssSelector, text, page) {
+        super(parentCssSelector, "", page);
+        this.text = text;
+      }
+      getLocator() {
+        const panel = super.getLocator();
+        return panel.locator(buttonByTextXpath(this.text));
+      }
+      buttonNotDisplayedError() {
+        return `Dialog button ${this.text} cannot be clicked. It is not displayed or it is disabled`;
+      }
+      getTitle() {
+        throw new Error(`Method "getTitle()" is not working.`);
+      }
+    };
+    Dialog = class extends AbstractElement {
+      constructor(page) {
+        super(page, DIALOG_CLASS);
+      }
+      get titleSelector() {
+        return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_TITLE_CLASS]);
+      }
+      get textSelector() {
+        return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_TEXT_CLASS]);
+      }
+      get buttonsSelector() {
+        return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_BUTTONS_PANEL_CLASS]);
+      }
+      async title() {
+        const el = this.page.locator(this.titleSelector);
+        return await el.innerText();
+      }
+      async text() {
+        const el = this.page.locator(this.textSelector);
+        return await el.innerText();
+      }
+      button(text) {
+        return new DialogButton(this.buttonsSelector, text, this.page);
       }
     };
   }
@@ -6783,6 +6839,25 @@ var require_d5lib = __commonJS({
   }
 });
 
+// src/api/ApiRequest.ts
+function ApiRequest(objectName, operation) {
+  const { auth } = config();
+  (0, import_d5lib.config)(auth);
+  const postInstance = (0, import_d5lib.post)(objectName, operation);
+  const invoke = async () => {
+    return postInstance.send(true);
+  };
+  return Object.assign(postInstance, { invoke });
+}
+var import_d5lib;
+var init_ApiRequest = __esm({
+  "src/api/ApiRequest.ts"() {
+    "use strict";
+    init_config();
+    import_d5lib = __toESM(require_d5lib());
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -6804,405 +6879,38 @@ __export(src_exports, {
   TreeView: () => TreeView,
   byTestId: () => byTestId,
   byTestIdCssSelector: () => byTestIdCssSelector,
-  click: () => click,
   config: () => config,
-  contextMenu: () => contextMenu,
-  createDriver: () => createDriver,
   disabledLocator: () => disabledLocator,
   editorFactory: () => editorFactory,
-  elementIsNotPresent: () => elementIsNotPresent,
   readonlyLocator: () => readonlyLocator,
-  signIn: () => signIn,
-  wait: () => safeWait,
-  waitElementIsClickable: () => waitElementIsClickable_default,
+  wait: () => wait,
   waitElementIsVisible: () => waitElementIsVisible_default
 });
 module.exports = __toCommonJS(src_exports);
-init_config();
-
-// src/pageObjects/pages/LoginPage.ts
-init_AbstractPage();
-init_config();
-init_waitElementIsVisible();
-init_actions();
-init_locators();
-var import_selenium_webdriver3 = require("selenium-webdriver");
-var LOGIN_PATH = "/login";
-var LoginPage = class extends AbstractPage {
-  usernameField = byTestId("loginField", "input");
-  passwordField = byTestId("passwordField", "input");
-  loginButton = byTestId("loginButton");
-  async locate() {
-    await super.locate();
-    const login = await this.driver.findElement(this.usernameField);
-    await waitElementIsVisible_default({
-      element: login,
-      driver: this.driver
-    });
-  }
-  get path() {
-    return LOGIN_PATH;
-  }
-  async enterUsername(username) {
-    await this.driver.findElement(this.usernameField).sendKeys(username);
-  }
-  async enterPassword(password) {
-    await this.driver.findElement(this.passwordField).sendKeys(password);
-  }
-  async clickLoginButton() {
-    await click(await this.driver.findElement(this.loginButton), this.driver);
-    await waitElementIsVisible_default({
-      driver: this.driver,
-      by: import_selenium_webdriver3.By.id("section"),
-      errorMessage: "Sing in not successful"
-    });
-  }
-  async loginWith(username, password) {
-    await this.enterUsername(username);
-    await this.enterPassword(password);
-    await this.clickLoginButton();
-  }
-  async authorize() {
-    await this.loginWith(config().auth.login, config().auth.password);
-  }
-};
-
-// src/index.ts
-init_locators();
-
-// src/utils/createDriver.ts
-var import_selenium_webdriver4 = require("selenium-webdriver");
-var import_node_path = __toESM(require("path"));
-var import_node_fs = __toESM(require("fs"));
-var import_node_os = __toESM(require("os"));
-init_config();
-var import_chrome = __toESM(require("selenium-webdriver/chrome"));
-var import_firefox = __toESM(require("selenium-webdriver/firefox"));
-function chromeOptions(builder, options) {
-  const ChromeOptions = new import_chrome.default.Options();
-  if (options.headless) {
-    ChromeOptions.addArguments(`--headless=new`);
-    ChromeOptions.addArguments(`--disable-gpu`);
-    ChromeOptions.addArguments(`--disable-dev-shm-usage`);
-    ChromeOptions.addArguments(`--window-size=1920,1080`);
-  }
-  const userDataDir = import_node_path.default.join(import_node_os.default.tmpdir(), ".chrome-cache");
-  if (!import_node_fs.default.existsSync(userDataDir)) {
-    import_node_fs.default.mkdirSync(userDataDir, { recursive: true });
-  }
-  ChromeOptions.addArguments(`--user-data-dir=${userDataDir}`);
-  return builder.setChromeOptions(ChromeOptions);
-}
-function firefoxOptions(builder, options) {
-  const FirefoxOptions = new import_firefox.default.Options();
-  if (options.headless) {
-    FirefoxOptions.addArguments(`--headless`);
-  }
-  return builder.setFirefoxOptions(FirefoxOptions);
-}
-function setOptions(builder, browser, options) {
-  switch (browser) {
-    case "chrome":
-      return chromeOptions(builder, options);
-    case "firefox":
-      return firefoxOptions(builder, options);
-    default:
-      return builder;
-  }
-}
-var createDriver = async (browser) => {
-  const _browser = browser ?? config().browser;
-  const headless = config().headless === "true";
-  let builder = new import_selenium_webdriver4.Builder().forBrowser(_browser);
-  builder = setOptions(builder, _browser, { headless });
-  const driver = await builder.build();
-  const manage = driver.manage();
-  await manage.setTimeouts({ implicit: config().timeout });
-  if (!headless) {
-    await manage.window().maximize();
-  }
-  return driver;
-};
-
-// src/utils/elementIsNotPresent.ts
-var import_selenium_webdriver5 = require("selenium-webdriver");
-var elementIsNotPresent = function elementIsNotPresent2(locator) {
-  return new import_selenium_webdriver5.Condition("for no element to be located " + locator, async function(driver) {
-    const elements = await driver.findElements(locator);
-    return elements.length == 0;
-  });
-};
-
-// src/index.ts
-init_waitElementIsVisible();
-init_waitElementIsClickable();
-init_wait();
-
-// src/utils/signIn.ts
-async function signIn(driver) {
-  const webDriver = driver ?? await createDriver();
-  const loginPage = new LoginPage(webDriver);
-  await loginPage.locate();
-  await loginPage.authorize();
-  return webDriver;
-}
-
-// src/index.ts
-init_actions();
-init_AbstractPage();
-
-// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
-init_AbstractElement();
-
-// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanelHeader.ts
-init_AbstractElementWithParent();
-var import_selenium_webdriver6 = require("selenium-webdriver");
-var SubsystemsPanelHeader = class extends AbstractElementWithParent {
-  async title() {
-    return this.driver.findElement(import_selenium_webdriver6.By.css(this.getFullCssSelector()));
-  }
-};
-
-// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
-var import_selenium_webdriver17 = require("selenium-webdriver");
-init_wait();
-init_locators();
-init_Editors();
-
-// src/pageObjects/elements/SubsystemsPanel/SubsystemItem.ts
-init_actions();
-init_fixElementStaleError();
-init_waitElementIsVisible();
-init_waitElementIsClickable();
-var SubsystemItem = class {
-  bySelector;
-  driver;
-  constructor({ driver, bySelector }) {
-    this.bySelector = bySelector;
-    this.driver = driver;
-  }
-  async getElement() {
-    return fixElementStaleError(this.bySelector, this.driver);
-  }
-  async getTitle() {
-    await waitElementIsVisible_default(
-      {
-        by: this.bySelector,
-        driver: this.driver
-      }
-    );
-    const el = await this.getElement();
-    return await el.getAttribute("data-title");
-  }
-  async click() {
-    await waitElementIsClickable_default(
-      {
-        by: this.bySelector,
-        driver: this.driver
-      }
-    );
-    const el = await this.getElement();
-    await click(el, this.driver);
-  }
-};
-
-// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
-init_createDataTestId();
-init_actions();
-init_ClearButtonStrategy();
-init_waitElementIsVisible();
-init_fixElementStaleError();
-var SEARCH_ITEM_SELECTOR = "search-item";
-var BACK_BUTTON_SELECTOR = "subsystem-back-item";
-var SEARCH_INPUT_SELECTOR = "search-subsystem-input";
-var byTitleCssSelector = (title) => {
-  return `span[data-title="${title}"]`;
-};
-var SubsystemsPanel = class extends AbstractElement {
-  header;
-  constructor(driver) {
-    super(driver);
-    this.header = new SubsystemsPanelHeader("#aside", byTestIdCssSelector("subsystems-panel-title", "span"), this.driver);
-  }
-  async headerTitle() {
-    const title = await this.header.title();
-    await safeWait(async () => await title.getText() != "", this.driver);
-    return title.getText();
-  }
-  getSearchComponent() {
-    return new TextEditor("#aside", byTestIdCssSelector(SEARCH_INPUT_SELECTOR), this.driver);
-  }
-  /**
-   * Находит сабсистему по заголовку
-   * @example
-   * const subsystemsPanel= new SubsystemsPanel();
-   * //...
-   * await subsystemsPanel.search('SubSystemTitle');
-   */
-  async search(title) {
-    const searchComponent = this.getSearchComponent();
-    await this.searchClear();
-    await searchComponent.setValue(title);
-    await safeWait(
-      async () => {
-        const findElement = await this.itemByTitle(title).getElement();
-        const classes = await findElement.getAttribute("class");
-        return classes.includes(SEARCH_ITEM_SELECTOR);
-      },
-      this.driver,
-      `Cannot find element: ${title}`
-    );
-  }
-  /**
-   * Очищает поиск сабсистем
-   * @example
-   * const subsystemsPanel= new SubsystemsPanel();
-   * //...
-   * await subsystemsPanel.searchClear();
-   */
-  async searchClear() {
-    const clearBtnSelector = `#aside ${byTestIdCssSelector(SEARCH_INPUT_SELECTOR)} .${DX_CLEAR_BUTTON_AREA}`;
-    const clearBtn = await fixElementStaleError(import_selenium_webdriver17.By.css(clearBtnSelector), this.driver);
-    if (await clearBtn.isDisplayed()) {
-      await click(clearBtn, this.driver);
-    }
-  }
-  /**
-   * Возвращает сабсистему по имени
-   * @example
-   * const subsystemsPanel= new SubsystemsPanel();
-   * //...
-   * const subsystem = subsystemsPanel.item('SubSystemName');
-   */
-  item(name) {
-    const elementCSS = createSubSystemTestId(name);
-    return new SubsystemItem({ driver: this.driver, bySelector: import_selenium_webdriver17.By.css(`${byTestIdCssSelector(elementCSS, "span")}`) });
-  }
-  /**
-   * Возвращает сабсистему по заголовку
-   * @example
-   * const subsystemsPanel= new SubsystemsPanel();
-   * //...
-   * const subsystem = subsystemsPanel.itemByTitle('SubSystemTitle');
-   */
-  itemByTitle(title) {
-    return new SubsystemItem({ driver: this.driver, bySelector: import_selenium_webdriver17.By.css(byTitleCssSelector(title)) });
-  }
-  /**
-   * Возвращается на уровень выше по сабсистемам
-   * @example
-   * const subsystemsPanel= new SubsystemsPanel();
-   * //...
-   * wait subsystemsPanel.back();
-   */
-  async back() {
-    const by = import_selenium_webdriver17.By.css(`#aside .${BACK_BUTTON_SELECTOR}`);
-    await waitElementIsVisible_default(
-      {
-        by,
-        driver: this.driver
-      }
-    );
-    await click(await fixElementStaleError(by, this.driver), this.driver);
-  }
-};
-
-// src/index.ts
-init_FormEdit();
-init_ListForm();
-init_TreeView();
-
-// src/pageObjects/elements/Forms/ReportForm.ts
-init_FormEdit();
-var ReportForm = class extends FormEdit {
-  constructor(driver) {
-    super(driver);
-    this.popupContainerCssSelector = `.popup.form-report-${this.formName}`;
-    this.saveButtonId = "#button-apply";
-  }
-  /**
-   * Знаходить поле/фільтр у формі репорту за ім'ям
-   * @example
-   * const formReport = new MyForm();
-   * //...
-   * expect(await formReport.filterField('Name').getValue()).toBe('test value');
-   */
-  filterField(name) {
-    return super.field(name);
-  }
-};
-
-// src/index.ts
-init_Editors();
-init_FormField();
-init_FormFilterField();
-init_PanelFilterField();
-init_FilterPanel();
-
-// src/pageObjects/elements/Dialog.ts
-init_AbstractElement();
-var import_selenium_webdriver34 = require("selenium-webdriver");
-init_AbstractButton();
-var DIALOG_CLASS = ".d5-dialog";
-var DIALOG_TITLE_CLASS = ".dialog__title";
-var DIALOG_TEXT_CLASS = ".dialog__text";
-var DIALOG_BUTTONS_PANEL_CLASS = ".dialog__buttons-panel";
-var buttonByTextXpath = (text) => `.//span[contains(@class, "dx-button-text") and contains(text(), "${text}")]`;
-var DialogButton = class extends AbstractButton {
-  text;
-  constructor(parentCssSelector, text, driver) {
-    super(parentCssSelector, "", driver);
-    this.text = text;
-  }
-  async getElement() {
-    const panel = await super.getElement();
-    return panel.findElement(import_selenium_webdriver34.By.xpath(buttonByTextXpath(this.text)));
-  }
-  buttonNotDisplayedError() {
-    return `Dialog button ${this.text} cannot be clicked. It is not displayed or it is disabled`;
-  }
-  getTitle() {
-    throw new Error(`Method "getTitle()" is not working.`);
-  }
-};
-var Dialog = class extends AbstractElement {
-  constructor(driver) {
-    super(driver, DIALOG_CLASS);
-  }
-  get titleSelector() {
-    return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_TITLE_CLASS]);
-  }
-  get textSelector() {
-    return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_TEXT_CLASS]);
-  }
-  get buttonsSelector() {
-    return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_BUTTONS_PANEL_CLASS]);
-  }
-  async title() {
-    const el = await this.driver.findElement(import_selenium_webdriver34.By.css(this.titleSelector));
-    return await el.getText();
-  }
-  async text() {
-    const el = await this.driver.findElement(import_selenium_webdriver34.By.css(this.textSelector));
-    return await el.getText();
-  }
-  button(text) {
-    return new DialogButton(this.buttonsSelector, text, this.driver);
+var init_src = __esm({
+  "src/index.ts"() {
+    init_config();
+    init_LoginPage();
+    init_locators();
+    init_waitElementIsVisible();
+    init_wait();
+    init_AbstractPage();
+    init_LoginPage();
+    init_SubsystemsPanel();
+    init_FormEdit();
+    init_ListForm();
+    init_TreeView();
+    init_ReportForm();
+    init_Editors();
+    init_FormField();
+    init_FormFilterField();
+    init_PanelFilterField();
+    init_FilterPanel();
+    init_Dialog();
+    init_ApiRequest();
   }
-};
-
-// src/api/ApiRequest.ts
-init_config();
-var import_d5lib = __toESM(require_d5lib());
-function ApiRequest(objectName, operation) {
-  const { auth } = config();
-  (0, import_d5lib.config)(auth);
-  const postInstance = (0, import_d5lib.post)(objectName, operation);
-  const invoke = async () => {
-    return postInstance.send(true);
-  };
-  return Object.assign(postInstance, { invoke });
-}
+});
+init_src();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbstractPage,
@@ -7223,17 +6931,11 @@ function ApiRequest(objectName, operation) {
   TreeView,
   byTestId,
   byTestIdCssSelector,
-  click,
   config,
-  contextMenu,
-  createDriver,
   disabledLocator,
   editorFactory,
-  elementIsNotPresent,
   readonlyLocator,
-  signIn,
   wait,
-  waitElementIsClickable,
   waitElementIsVisible
 });
 /*! For license information please see d5lib.js.LICENSE.txt */