d5-testing-library 1.4.0 → 1.6.0

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

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,88 +30,166 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  AbstractPage: () => AbstractPage,
-  ControlClass: () => ControlClass,
-  Dialog: () => Dialog,
-  FilterPanel: () => FilterPanel,
-  FormEdit: () => FormEdit,
-  FormField: () => FormField,
-  FormFilterField: () => FormFilterField,
-  ListForm: () => ListForm,
-  LoginPage: () => LoginPage,
-  NumberEditor: () => NumberEditor,
-  PanelFilterField: () => PanelFilterField,
-  SubsystemsPanel: () => SubsystemsPanel,
-  TextEditor: () => TextEditor,
-  TreeView: () => TreeView,
-  byTestId: () => byTestId,
-  byTestIdCssSelector: () => byTestIdCssSelector,
-  click: () => click,
-  config: () => config,
-  createDriver: () => createDriver,
-  editorFactory: () => editorFactory,
-  elementIsNotPresent: () => elementIsNotPresent,
-  readonlyLocator: () => readonlyLocator,
-  signIn: () => signIn,
-  wait: () => wait,
-  waitElementIsVisible: () => waitElementIsVisible
+// src/config.ts
+function config(cfg) {
+  return configInstance.config(cfg);
+}
+var process, driversMap, createConfigProxy, Config, configInstance;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    process = __toESM(require("process"));
+    driversMap = /* @__PURE__ */ new Map();
+    createConfigProxy = (config2) => {
+      return new Proxy(config2, {
+        get(_target, prop) {
+          if (prop === "driver") {
+            return driversMap.get(process.pid);
+          }
+          return Reflect.get(...arguments);
+        },
+        set(_target, prop, value) {
+          if (prop === "driver") {
+            driversMap.set(process.pid, value);
+            return true;
+          }
+          return Reflect.set(...arguments);
+        }
+      });
+    };
+    Config = class _Config {
+      static instance;
+      appConfig;
+      static getInstance() {
+        if (!_Config.instance) {
+          _Config.instance = new _Config();
+        }
+        return _Config.instance;
+      }
+      config = (cfg) => {
+        if (!cfg)
+          return createConfigProxy(this.appConfig);
+        this.appConfig = cfg;
+      };
+    };
+    configInstance = Config.getInstance();
+  }
 });
-module.exports = __toCommonJS(src_exports);
 
-// src/config.ts
-var process = __toESM(require("process"));
-var driversMap = /* @__PURE__ */ new Map();
-var createConfigProxy = (config2) => {
-  return new Proxy(config2, {
-    get(_target, prop) {
-      if (prop === "driver") {
-        return driversMap.get(process.pid);
-      }
-      return Reflect.get(...arguments);
-    },
-    set(_target, prop, value) {
-      if (prop === "driver") {
-        driversMap.set(process.pid, value);
-        return true;
-      }
-      return Reflect.set(...arguments);
-    }
-  });
-};
-var Config = class _Config {
-  static instance;
-  appConfig;
-  static getInstance() {
-    if (!_Config.instance) {
-      _Config.instance = new _Config();
+// src/utils/fixElementStaleError.ts
+function fixElementStaleError(by, driver) {
+  const maxCount = 3;
+  let err;
+  const call = async (times = 0) => {
+    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.name === "StaleElementReferenceError") {
+        return call(++times);
+      }
     }
-    return _Config.instance;
-  }
-  config = (cfg) => {
-    if (!cfg)
-      return createConfigProxy(this.appConfig);
-    this.appConfig = cfg;
+    if (err)
+      throw err;
   };
-};
-var configInstance = Config.getInstance();
-function config(cfg) {
-  return configInstance.config(cfg);
+  return call();
 }
+var init_fixElementStaleError = __esm({
+  "src/utils/fixElementStaleError.ts"() {
+    "use strict";
+  }
+});
 
 // src/pageObjects/AbstractElement.ts
-var import_selenium_webdriver2 = require("selenium-webdriver");
+var import_selenium_webdriver, AbstractElement;
+var init_AbstractElement = __esm({
+  "src/pageObjects/AbstractElement.ts"() {
+    "use strict";
+    import_selenium_webdriver = require("selenium-webdriver");
+    init_config();
+    init_fixElementStaleError();
+    AbstractElement = class {
+      driver;
+      elementCssSelector;
+      constructor(driver, elementCssSelector) {
+        this.driver = driver || config().driver;
+        this.elementCssSelector = elementCssSelector;
+      }
+      getFullCssSelector() {
+        return this.elementCssSelector;
+      }
+      joinRelativeCssSelectors(selectors) {
+        return selectors.join(" ");
+      }
+      getElement() {
+        return fixElementStaleError(import_selenium_webdriver.By.css(this.getFullCssSelector()), this.driver);
+      }
+      async getAttribute(attr) {
+        const element = await this.getElement();
+        return await element.getAttribute(attr);
+      }
+      async getClasses() {
+        return await this.getAttribute("class");
+      }
+      async getDataTestId() {
+        return await this.getAttribute("data-testid");
+      }
+    };
+  }
+});
 
-// src/utils/waitElementIsVisible.ts
-var import_selenium_webdriver = require("selenium-webdriver");
+// src/pageObjects/pages/AbstractPage.ts
+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);
+      }
+      prependHash(urlPath) {
+        if (!urlPath.startsWith("/#")) {
+          return `/#${urlPath}`;
+        }
+        return urlPath;
+      }
+      async goToUrl(url) {
+        await this.driver.get(url);
+      }
+      get path() {
+        return "/#";
+      }
+      async locate() {
+        await this.goToUrl(this.url);
+      }
+      async reloadPage() {
+        await this.driver.navigate().refresh();
+      }
+    };
+  }
+});
 
 // src/utils/wait.ts
 async function wait(condition, driver, errorMessage, timeout) {
   driver = driver ?? config().driver;
   await driver.wait(condition, timeout ?? config().timeout, errorMessage);
 }
+var init_wait = __esm({
+  "src/utils/wait.ts"() {
+    "use strict";
+    init_config();
+  }
+});
 
 // src/utils/waitElementIsVisible.ts
 async function waitElementIsVisible({
@@ -118,205 +199,81 @@ async function waitElementIsVisible({
   driver
 }) {
   driver = driver ?? config().driver;
-  const condition = import_selenium_webdriver.until.elementIsVisible(element);
+  const condition = import_selenium_webdriver2.until.elementIsVisible(element);
   await wait(condition.fn, driver, errorMessage ?? condition.description(), timeout ?? config().timeout);
 }
-
-// src/pageObjects/AbstractElement.ts
-var AbstractElement = class {
-  driver;
-  elementCssSelector;
-  constructor(driver, elementCssSelector) {
-    this.driver = driver || config().driver;
-    this.elementCssSelector = elementCssSelector;
-  }
-  getFullCssSelector() {
-    return this.elementCssSelector;
-  }
-  joinRelativeCssSelectors(selectors) {
-    return selectors.join(" ");
-  }
-  async getElement() {
-    return this.driver.findElement(import_selenium_webdriver2.By.css(this.getFullCssSelector()));
-  }
-  async getAttribute(attr) {
-    const element = await this.getElement();
-    await waitElementIsVisible({
-      element,
-      driver: this.driver,
-      errorMessage: `Element not found: ${this.getFullCssSelector()}`
-    });
-    return await element.getAttribute(attr);
-  }
-  async getClasses() {
-    return await this.getAttribute("class");
+var import_selenium_webdriver2;
+var init_waitElementIsVisible = __esm({
+  "src/utils/waitElementIsVisible.ts"() {
+    "use strict";
+    import_selenium_webdriver2 = require("selenium-webdriver");
+    init_config();
+    init_wait();
   }
-  async getDataTestId() {
-    return await this.getAttribute("data-testid");
-  }
-};
-
-// src/pageObjects/pages/AbstractPage.ts
-var AbstractPage = class extends AbstractElement {
-  url;
-  host;
-  constructor(driver) {
-    super(driver);
-    this.host = config().auth.host;
-    this.url = this.host + this.prependHash(this.path);
-  }
-  prependHash(urlPath) {
-    if (!urlPath.startsWith("/#")) {
-      return `/#${urlPath}`;
-    }
-    return urlPath;
-  }
-  async goToUrl(url) {
-    await this.driver.get(url);
-  }
-  get path() {
-    return "/#";
-  }
-  async locate() {
-    await this.goToUrl(this.url);
-  }
-  async reloadPage() {
-    await this.driver.navigate().refresh();
-  }
-};
+});
 
 // src/utils/actions.ts
-var click = async (webElement, driver) => {
-  driver = driver ?? config().driver;
-  if (!await webElement.isDisplayed()) {
-    await driver.executeScript("arguments[0].scrollIntoView(true);", webElement);
+var click;
+var init_actions = __esm({
+  "src/utils/actions.ts"() {
+    "use strict";
+    init_config();
+    click = async (webElement, driver) => {
+      driver = driver ?? config().driver;
+      if (!await webElement.isDisplayed()) {
+        await driver.executeScript("arguments[0].scrollIntoView(true);", webElement);
+      }
+      const actions = driver.actions({ async: true });
+      await actions.move({ origin: webElement }).click().perform();
+    };
   }
-  const actions = driver.actions({ async: true });
-  await actions.move({ origin: webElement }).click().perform();
-};
+});
 
 // src/utils/locators.ts
-var import_selenium_webdriver3 = require("selenium-webdriver");
-var byTestIdCssSelector = (testId, element = "div") => {
-  return `${element}[data-testid="${testId}"]`;
-};
-var byTestId = (testId, element = "div") => {
-  return import_selenium_webdriver3.By.css(byTestIdCssSelector(testId, element));
-};
-var readonlyLocator = "readonly";
-
-// src/pageObjects/pages/LoginPage.ts
-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({
-      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);
-  }
-  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);
+var import_selenium_webdriver3, byTestIdCssSelector, byTestId, readonlyLocator;
+var init_locators = __esm({
+  "src/utils/locators.ts"() {
+    "use strict";
+    import_selenium_webdriver3 = require("selenium-webdriver");
+    byTestIdCssSelector = (testId, element = "div") => {
+      return `${element}[data-testid="${testId}"]`;
+    };
+    byTestId = (testId, element = "div") => {
+      return import_selenium_webdriver3.By.css(byTestIdCssSelector(testId, element));
+    };
+    readonlyLocator = "readonly";
   }
-};
-
-// src/utils/createDriver.ts
-var import_selenium_webdriver4 = require("selenium-webdriver");
-var createDriver = async (browser) => {
-  const driver = await new import_selenium_webdriver4.Builder().forBrowser(browser ?? config().browser).build();
-  const manage = driver.manage();
-  await manage.setTimeouts({ implicit: config().timeout });
-  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/utils/signIn.ts
-async function signIn(driver) {
-  const webDriver = driver ?? await createDriver();
-  config().driver = webDriver;
-  const loginPage = new LoginPage(webDriver);
-  await loginPage.locate();
-  await loginPage.authorize();
-  return webDriver;
-}
+});
 
 // src/pageObjects/AbstractElementWithParent.ts
-var AbstractElementWithParent = class extends AbstractElement {
-  parentCssSelector;
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(driver, elementCssSelector);
-    this.parentCssSelector = parentCssSelector;
-  }
-  getFullCssSelector() {
-    if (!this.elementCssSelector) {
-      return this.parentCssSelector;
-    }
-    if (!this.parentCssSelector) {
-      return this.elementCssSelector;
-    }
-    return `${this.parentCssSelector} ${this.elementCssSelector}`;
-  }
-  async isReadonly() {
-    const fieldEl = await this.getElement();
-    const classSting = await fieldEl.getAttribute("class");
-    return classSting.includes(readonlyLocator);
-  }
-};
-
-// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanelHeader.ts
-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 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 wait(async () => await title.getText() != "", this.driver);
-    return title.getText();
+var AbstractElementWithParent;
+var init_AbstractElementWithParent = __esm({
+  "src/pageObjects/AbstractElementWithParent.ts"() {
+    "use strict";
+    init_AbstractElement();
+    init_locators();
+    AbstractElementWithParent = class extends AbstractElement {
+      parentCssSelector;
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(driver, elementCssSelector);
+        this.parentCssSelector = parentCssSelector;
+      }
+      getFullCssSelector() {
+        if (!this.elementCssSelector) {
+          return this.parentCssSelector;
+        }
+        if (!this.parentCssSelector) {
+          return this.elementCssSelector;
+        }
+        return `${this.parentCssSelector} ${this.elementCssSelector}`;
+      }
+      async isReadonly() {
+        const classSting = await this.getClasses();
+        return classSting.includes(readonlyLocator);
+      }
+    };
   }
-};
-
-// src/pageObjects/elements/Forms/AbstractForm.ts
-var import_selenium_webdriver8 = require("selenium-webdriver");
+});
 
 // src/utils/createDataTestId.ts
 function createDataTestId(formName, itemType, itemName) {
@@ -343,6 +300,11 @@ function createTableId(formName) {
 function createFormButtonTestId(formName, itemName) {
   return createDataTestId(formName, "button" /* BUTTON */, itemName);
 }
+var init_createDataTestId = __esm({
+  "src/utils/createDataTestId.ts"() {
+    "use strict";
+  }
+});
 
 // src/utils/waitElementIsClickable.ts
 async function waitElementIsClickable({
@@ -357,1487 +319,2317 @@ async function waitElementIsClickable({
     return await element.isDisplayed() && !isDisabled;
   }, driver, errorMessage, timeout ?? config().timeout);
 }
+var init_waitElementIsClickable = __esm({
+  "src/utils/waitElementIsClickable.ts"() {
+    "use strict";
+    init_config();
+    init_wait();
+  }
+});
 
 // src/pageObjects/elements/TableToolbar/AbstractButton.ts
-var AbstractButton = class extends AbstractElementWithParent {
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-  }
-  async click() {
-    const button = await this.getElement();
-    await waitElementIsClickable({
-      element: button,
-      errorMessage: this.buttonNotDisplayedError(),
-      driver: this.driver
-    });
-    await click(button, this.driver);
-  }
-  async isDisabled() {
-    const button = await this.getElement();
-    return await button.getCssValue("pointer-events") === "none";
+var AbstractButton;
+var init_AbstractButton = __esm({
+  "src/pageObjects/elements/TableToolbar/AbstractButton.ts"() {
+    "use strict";
+    init_AbstractElementWithParent();
+    init_actions();
+    init_waitElementIsClickable();
+    AbstractButton = class extends AbstractElementWithParent {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+      }
+      async click() {
+        const button = await this.getElement();
+        await waitElementIsClickable({
+          element: button,
+          errorMessage: this.buttonNotDisplayedError(),
+          driver: this.driver
+        });
+        await click(button, this.driver);
+      }
+      async isDisabled() {
+        const button = await this.getElement();
+        return await button.getCssValue("pointer-events") === "none";
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/DXComponents/DXButton.ts
-var import_selenium_webdriver7 = require("selenium-webdriver");
-var DXButton = class extends AbstractButton {
-  async getText() {
-    const classes = await this.getClasses();
-    if (!classes.includes("dx-button-has-text")) {
-      return null;
-    }
-    const el = await this.getElement();
-    const textEl = el.findElement(import_selenium_webdriver7.By.className("dx-button-text"));
-    return await textEl.getText();
+var import_selenium_webdriver7, DXButton;
+var init_DXButton = __esm({
+  "src/pageObjects/elements/DXComponents/DXButton.ts"() {
+    "use strict";
+    init_AbstractButton();
+    import_selenium_webdriver7 = require("selenium-webdriver");
+    DXButton = class extends AbstractButton {
+      async getText() {
+        const classes = await this.getClasses();
+        if (!classes.includes("dx-button-has-text")) {
+          return null;
+        }
+        const el = await this.getElement();
+        const textEl = el.findElement(import_selenium_webdriver7.By.className("dx-button-text"));
+        return await textEl.getText();
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/FormButton.ts
-var FormButton = class extends DXButton {
-  name;
-  constructor(parentCssSelector, formName, name, driver) {
-    super(parentCssSelector, byTestIdCssSelector(createFormButtonTestId(formName, name)), driver);
-    this.name = name;
-  }
-  buttonNotDisplayedError() {
-    return `Form Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
+var FormButton;
+var init_FormButton = __esm({
+  "src/pageObjects/elements/FormButton.ts"() {
+    "use strict";
+    init_locators();
+    init_createDataTestId();
+    init_DXButton();
+    FormButton = class extends DXButton {
+      name;
+      constructor(parentCssSelector, formName, name, driver) {
+        super(parentCssSelector, byTestIdCssSelector(createFormButtonTestId(formName, name)), driver);
+        this.name = name;
+      }
+      buttonNotDisplayedError() {
+        return `Form Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
+      }
+    };
   }
-};
+});
 
-// src/pageObjects/elements/Forms/AbstractForm.ts
-var AbstractForm = class extends AbstractPage {
-  containerCssSelector = "";
-  containerBy;
-  popupContainerCssSelector;
-  constructor(driver) {
-    super(driver);
-    const testId = `form-content-wrapper-${this.formName}`;
-    this.containerBy = byTestId(testId);
-    this.containerCssSelector = byTestIdCssSelector(testId);
-  }
-  async isModal() {
-    const el = await this.getContainerElement();
-    const value = await el.getAttribute("data-ismodal");
-    return value === "true";
-  }
-  getContainerElement = () => {
-    return this.driver.findElement(this.containerBy);
-  };
-  get formName() {
-    return "";
-  }
-  /**
-   * Возвращает true если форма есть в DOM
-   * @example
-   * class MyForm extends FormEdit {}
-   * //...
-   * const formEdit = new MyForm();
-   * expect(await formEdit.exists()).toBe(true);
-   */
-  async exists() {
-    try {
-      let elements = await this.driver.findElements(this.containerBy);
-      return elements.length > 0;
-    } catch (error) {
-      return false;
-    }
-  }
-  /**
-   * Получение заголовка на формы
-   * @example
-   * const listForm = new MyForm();
-   * //...
-   * expect(await listForm.getTitleText()).toBe('MyFormTitle');
-   */
-  async getTitleText() {
-    if (await this.isModal()) {
-      const titleEl2 = await this.driver.findElement(import_selenium_webdriver8.By.css(`${this.popupContainerCssSelector} .popup-title`));
-      return titleEl2.getText();
-    }
-    let titleEl = await this.driver.findElement(import_selenium_webdriver8.By.className("main-toolbar-form-title"));
-    return titleEl.getText();
-  }
-  button(name) {
-    return new FormButton(this.containerCssSelector, this.formName, name, this.driver);
+// src/pageObjects/AbstractFormElement.ts
+var AbstractFormElement;
+var init_AbstractFormElement = __esm({
+  "src/pageObjects/AbstractFormElement.ts"() {
+    "use strict";
+    init_AbstractElementWithParent();
+    AbstractFormElement = class extends AbstractElementWithParent {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+      }
+    };
   }
-};
-
-// src/pageObjects/elements/Forms/FormEdit.ts
-var import_selenium_webdriver17 = require("selenium-webdriver");
-
-// src/pageObjects/elements/Editors/AbstractEditor.ts
-var import_selenium_webdriver9 = require("selenium-webdriver");
+});
 
-// src/pageObjects/elements/Editors/ClearStrategy/InputClearStrategy.ts
-var InputClearStrategy = class {
-  async clear(editor) {
-    const inputEl = await editor.getInputElement();
-    await inputEl.clear();
+// src/pageObjects/elements/Groups/AbstractGroup.ts
+var AbstractGroup;
+var init_AbstractGroup = __esm({
+  "src/pageObjects/elements/Groups/AbstractGroup.ts"() {
+    "use strict";
+    init_AbstractElementWithParent();
+    AbstractGroup = class extends AbstractElementWithParent {
+      async isDisplayed() {
+        const groupElement = await this.getElement();
+        return await groupElement.isDisplayed();
+      }
+    };
   }
-};
+});
 
-// src/pageObjects/elements/Editors/AbstractEditor.ts
-var AbstractDXEditorWithInput = class extends AbstractElementWithParent {
-  clearStrategy = new InputClearStrategy();
-  setClearStrategy(strategy) {
-    this.clearStrategy = strategy;
+// src/pageObjects/elements/Groups/Panel.ts
+var Panel;
+var init_Panel = __esm({
+  "src/pageObjects/elements/Groups/Panel.ts"() {
+    "use strict";
+    init_AbstractGroup();
+    Panel = class extends AbstractGroup {
+    };
+  }
+});
+
+// src/pageObjects/elements/Groups/TabPanel.ts
+var TabPanelItem, TabPanel;
+var init_TabPanel = __esm({
+  "src/pageObjects/elements/Groups/TabPanel.ts"() {
+    "use strict";
+    init_AbstractGroup();
+    init_actions();
+    TabPanelItem = class extends AbstractGroup {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+      }
+      async click() {
+        await click(await this.getElement(), this.driver);
+      }
+      async getTitle() {
+        return "";
+      }
+    };
+    TabPanel = class extends AbstractGroup {
+      item(name) {
+        return new TabPanelItem(this.getFullCssSelector(), `.tab-panel-item[data-groupname="${name}"]`, this.driver);
+      }
+      async getTitle() {
+        return "";
+      }
+    };
   }
-  getInputCssSelector() {
-    return `${this.getFullCssSelector()} .dx-texteditor-input`;
+});
+
+// src/pageObjects/elements/Groups/Accordion/AccordionItem.ts
+var import_selenium_webdriver8, ACCORDION_TITLE_CONTAINER, AccordionItem;
+var init_AccordionItem = __esm({
+  "src/pageObjects/elements/Groups/Accordion/AccordionItem.ts"() {
+    "use strict";
+    init_AbstractGroup();
+    import_selenium_webdriver8 = require("selenium-webdriver");
+    init_actions();
+    ACCORDION_TITLE_CONTAINER = "accordion-title-container";
+    AccordionItem = class extends AbstractGroup {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+      }
+      async getDataOpenedAccordItemAttr() {
+        const accordionElement = await this.getElement();
+        return await accordionElement.getAttribute("data-opened");
+      }
+      async clickAccordionItemTitle() {
+        const accordionElement = await this.getElement();
+        const accordTitleElement = await accordionElement.findElement(import_selenium_webdriver8.By.className(ACCORDION_TITLE_CONTAINER));
+        await accordTitleElement.click();
+      }
+      async click() {
+        await click(await this.getElement(), this.driver);
+      }
+      async isExpanded() {
+        const dataOpened = await this.getDataOpenedAccordItemAttr();
+        return dataOpened === "true";
+      }
+      async isCollapsed() {
+        const dataOpened = await this.getDataOpenedAccordItemAttr();
+        return dataOpened === "false" || !dataOpened;
+      }
+      async expand() {
+        if (!await this.isExpanded()) {
+          await this.clickAccordionItemTitle();
+        }
+      }
+      async collapse() {
+        if (await this.isExpanded()) {
+          await this.clickAccordionItemTitle();
+        }
+      }
+    };
   }
-  async getInputElement() {
-    return this.driver.findElement(import_selenium_webdriver9.By.css(this.getInputCssSelector()));
+});
+
+// src/pageObjects/elements/Groups/Accordion/Accordion.ts
+var Accordion;
+var init_Accordion = __esm({
+  "src/pageObjects/elements/Groups/Accordion/Accordion.ts"() {
+    "use strict";
+    init_AbstractGroup();
+    init_AccordionItem();
+    Accordion = class extends AbstractGroup {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+      }
+      item(name) {
+        return new AccordionItem(this.getFullCssSelector(), `.d5-accordion-item[data-groupname="${name}"]`, this.driver);
+      }
+    };
   }
-  async getInputValue() {
-    const inputEl = await this.getInputElement();
-    return inputEl.getAttribute("value");
+});
+
+// src/pageObjects/elements/Groups/groupFactory.ts
+var groupFactory;
+var init_groupFactory = __esm({
+  "src/pageObjects/elements/Groups/groupFactory.ts"() {
+    "use strict";
+    init_AbstractFormElement();
+    init_Panel();
+    init_TabPanel();
+    init_Accordion();
+    init_AccordionItem();
+    groupFactory = async (parentCssSelector, elementCssSelector, driver) => {
+      const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
+      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);
+      throw new Error("Unknown type of group. Please write ticket to the support");
+    };
   }
-  async setInputValue(value) {
-    const inputEl = await this.getInputElement();
-    await click(inputEl, this.driver);
-    await inputEl.sendKeys(value, import_selenium_webdriver9.Key.ENTER);
+});
+
+// src/pageObjects/elements/FormGroup.ts
+var FormGroup;
+var init_FormGroup = __esm({
+  "src/pageObjects/elements/FormGroup.ts"() {
+    "use strict";
+    init_AbstractElementWithParent();
+    init_locators();
+    init_createDataTestId();
+    init_groupFactory();
+    init_AccordionItem();
+    FormGroup = class extends AbstractElementWithParent {
+      groupInstance;
+      constructor(parentCssSelector, formName, name, driver) {
+        super(parentCssSelector, byTestIdCssSelector(createGroupTestId(formName, name)), driver);
+      }
+      async initInstance() {
+        if (!this.groupInstance) {
+          this.groupInstance = await groupFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
+        }
+      }
+      /**
+       * Возвращает булевое значение доступна ли группа
+       * @example
+       * expect(await tableList.group('MainSuperPanel').isDisplayed();
+       */
+      async isDisplayed() {
+        try {
+          await this.initInstance();
+          return this.groupInstance.isDisplayed();
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Клик по элементам группы.
+       * Метод работает если у группы есть дочерние элементы, например элементы аккордеона или вкладки таб панели.
+       * @example
+       * expect(await tableList.group('TabPanel').itemClick('Tab');
+       * expect(await tableList.group('Accordion').itemClick('AccordionItem');
+       */
+      async itemClick(name) {
+        await this.initInstance();
+        const item = this.groupInstance.item?.(name);
+        await item?.click();
+      }
+      /**
+       * Метод работает если группа - это элемент аккордеона или вкладка таб панели
+       * @example
+       * expect(await tableList.group('Tab').click();
+       * expect(await tableList.group('AccordionItem').click();
+       */
+      async click() {
+        await this.initInstance();
+        await this.groupInstance.click?.();
+      }
+      async collapse() {
+        await this.initInstance();
+        if (this.groupInstance instanceof AccordionItem) {
+          await this.groupInstance.collapse();
+        }
+      }
+      async expand() {
+        await this.initInstance();
+        if (this.groupInstance instanceof AccordionItem) {
+          await this.groupInstance.expand();
+        }
+      }
+      async isExpanded() {
+        await this.initInstance();
+        if (this.groupInstance instanceof AccordionItem) {
+          return await this.groupInstance.isExpanded();
+        }
+        return false;
+      }
+      async isCollapsed() {
+        await this.initInstance();
+        if (this.groupInstance instanceof AccordionItem) {
+          return await this.groupInstance.isCollapsed();
+        }
+        return false;
+      }
+    };
   }
-  async clear() {
-    await this.clearStrategy.clear(this);
+});
+
+// src/pageObjects/elements/Forms/AbstractForm.ts
+var AbstractForm;
+var init_AbstractForm = __esm({
+  "src/pageObjects/elements/Forms/AbstractForm.ts"() {
+    "use strict";
+    init_AbstractPage();
+    init_FormButton();
+    init_FormGroup();
+    AbstractForm = class extends AbstractPage {
+      containerCssSelector = "";
+      _formName = "";
+      containerBy;
+      getContainerElement = () => {
+        return this.driver.findElement(this.containerBy);
+      };
+      set formName(name) {
+        this._formName = name;
+      }
+      get formName() {
+        return this._formName;
+      }
+      /**
+       * Возвращает true если форма есть в DOM
+       * @example
+       * class MyForm extends FormEdit {}
+       * //...
+       * const formEdit = new MyForm();
+       * expect(await formEdit.exists()).toBe(true);
+       */
+      async exists() {
+        try {
+          let elements = await this.driver.findElements(this.containerBy);
+          return elements.length > 0;
+        } catch (error) {
+          return false;
+        }
+      }
+      button(name) {
+        return new FormButton(this.containerCssSelector, this.formName, name, this.driver);
+      }
+      /**
+       * Находит группу на форме по имени
+       * @example
+       * const formEdit = new MyForm();
+       * //...
+       * expect(await formEdit.group('Name');
+       */
+      group(name) {
+        return new FormGroup(this.containerCssSelector, this.formName, name, this.driver);
+      }
+    };
   }
-};
+});
 
-// src/pageObjects/elements/Editors/TextEditor.ts
-var TextEditor = class extends AbstractDXEditorWithInput {
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-    this.setClearStrategy(new InputClearStrategy());
+// src/pageObjects/elements/Forms/types.ts
+var init_types = __esm({
+  "src/pageObjects/elements/Forms/types.ts"() {
+    "use strict";
   }
-  getValue() {
-    return this.getInputValue();
+});
+
+// src/pageObjects/elements/Table/utils.ts
+function getCssRowByIndexSelector(index) {
+  return `tr[aria-rowindex="${transformInputIndex(index)}"]`;
+}
+function getCssCellByIndexSelector(index) {
+  return `td[role="gridcell"][aria-colindex="${transformInputIndex(index)}"]`;
+}
+var import_selenium_webdriver9, getColumnByIndexCssSelector, getColumnByCaptionCssSelector, getColumnByNameCssSelector, transformInputIndex, transformOutputIndex;
+var init_utils = __esm({
+  "src/pageObjects/elements/Table/utils.ts"() {
+    "use strict";
+    import_selenium_webdriver9 = 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}"]`;
+    transformInputIndex = (index) => index + 1;
+    transformOutputIndex = (index) => +index - 1;
   }
-  setValue(value) {
-    return this.setInputValue(value);
+});
+
+// src/pageObjects/elements/Table/types.ts
+var init_types2 = __esm({
+  "src/pageObjects/elements/Table/types.ts"() {
+    "use strict";
   }
-};
+});
 
-// src/pageObjects/elements/Editors/NumberEditor.ts
-var NumberEditor = class extends AbstractDXEditorWithInput {
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-    this.setClearStrategy(new InputClearStrategy());
+// src/pageObjects/elements/Table/elements/Cell.ts
+var import_selenium_webdriver10, Cell;
+var init_Cell = __esm({
+  "src/pageObjects/elements/Table/elements/Cell.ts"() {
+    "use strict";
+    import_selenium_webdriver10 = require("selenium-webdriver");
+    init_AbstractElementWithParent();
+    init_utils();
+    init_types2();
+    Cell = class extends AbstractElementWithParent {
+      _index;
+      getCellIndex;
+      constructor(parentCssSelector, getCellIndex, index, driver) {
+        super(parentCssSelector, getCssCellByIndexSelector(index), driver);
+        this.getCellIndex = getCellIndex;
+        this._index = index;
+      }
+      set index(index) {
+        this._index = index;
+        this.elementCssSelector = getCssCellByIndexSelector(index);
+      }
+      async getBooleanValue(cellEl) {
+        const booleanEl = await cellEl.findElement(import_selenium_webdriver10.By.className("boolean-widget"));
+        return await booleanEl.getAttribute("aria-checked") === "true" ? 1 : 0;
+      }
+      async getTagsValue(cellEl) {
+        const tagsCssSelector = ".multiselect-container .multiselect-cell";
+        const tags = await cellEl.findElements(import_selenium_webdriver10.By.css(tagsCssSelector));
+        const values = [];
+        for (const tag of tags) {
+          values.push(await tag.getAttribute("textContent"));
+        }
+        return values;
+      }
+      async getElement() {
+        if (this._index == null) {
+          this.index = await this.getCellIndex();
+        }
+        return super.getElement();
+      }
+      async getValue() {
+        const cellEl = await this.getElement();
+        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);
+        return cellEl.getText();
+      }
+      getIndex() {
+        return this._index;
+      }
+    };
   }
-  async getValue() {
-    const value = await super.getInputValue();
-    return value == "" ? null : Number.parseFloat(value);
+});
+
+// src/pageObjects/elements/Table/elements/Row.ts
+var import_selenium_webdriver11, DX_SELECTION_CLASS, DX_ROW_EDIT_CLASS, DX_DATA_ROW_CLASS, Row;
+var init_Row = __esm({
+  "src/pageObjects/elements/Table/elements/Row.ts"() {
+    "use strict";
+    import_selenium_webdriver11 = require("selenium-webdriver");
+    init_Cell();
+    init_utils();
+    init_AbstractElementWithParent();
+    init_actions();
+    init_wait();
+    DX_SELECTION_CLASS = "dx-selection";
+    DX_ROW_EDIT_CLASS = "dx-edit-row";
+    DX_DATA_ROW_CLASS = "dx-data-row";
+    Row = class extends AbstractElementWithParent {
+      index;
+      getColumnBy;
+      constructor(parentCssSelector, index, driver, getColumnBy) {
+        super(parentCssSelector, getCssRowByIndexSelector(index), driver);
+        this.index = index;
+        this.getColumnBy = getColumnBy;
+      }
+      _getCell({ index, name, title }) {
+        return new Cell(
+          this.getFullCssSelector(),
+          () => {
+            return this.getColumnBy({ title, name }).getIndex();
+          },
+          index,
+          this.driver
+        );
+      }
+      getCellByIndex(index) {
+        return this._getCell({ index });
+      }
+      getCell(name) {
+        return this._getCell({ name });
+      }
+      getCellByTitle(title) {
+        return this._getCell({ title });
+      }
+      async select() {
+        const rowEl = await this.getElement();
+        await click(rowEl, this.driver);
+        await wait(
+          async () => {
+            const classes = await this.getClasses();
+            return classes.includes(DX_SELECTION_CLASS);
+          },
+          this.driver,
+          "Cannot select row"
+        );
+      }
+      async isSelected() {
+        const result = await this.getAttribute("aria-selected");
+        return result === "true";
+      }
+      getIndex() {
+        return this.index;
+      }
+      async getCells() {
+        const cells = await this.driver.findElements(import_selenium_webdriver11.By.css(`${this.getFullCssSelector()} td[role="gridcell"]`));
+        const result = [];
+        cells.forEach((_, index) => {
+          const newCell = this.getCellByIndex(index);
+          result.push(newCell);
+        });
+        return result;
+      }
+      async clickInlineButton(buttonClass) {
+        const FIXED_TABLE_CSS_SELECTOR = ".dx-fixed-columns .dx-datagrid-content.dx-datagrid-content-fixed";
+        const buttonCssSelector = `.${DX_DATA_ROW_CLASS}[aria-rowindex="${transformInputIndex(
+          this.index
+        )}"] .${buttonClass}`;
+        const button = await this.driver.findElement(
+          import_selenium_webdriver11.By.css(`${this.parentCssSelector} ${FIXED_TABLE_CSS_SELECTOR} ${buttonCssSelector}`)
+        );
+        return click(button, this.driver);
+      }
+      async checkEditingMode(isEditing, msg) {
+        await wait(
+          async () => {
+            return (await this.getClasses()).includes(DX_ROW_EDIT_CLASS) === isEditing;
+          },
+          this.driver,
+          msg
+        );
+      }
+      async edit() {
+        await this.clickInlineButton("edit");
+        await this.checkEditingMode(true, "Row did not switch to edit mode");
+      }
+      async save() {
+        await this.clickInlineButton("save");
+        await this.checkEditingMode(false, "Row did not saved");
+      }
+      async cancel() {
+        await this.clickInlineButton("cancel");
+        await this.checkEditingMode(false, "Row did not switch to normal mode");
+      }
+    };
   }
-  setValue(value) {
-    return this.setInputValue(value);
+});
+
+// src/pageObjects/elements/Table/elements/Column.ts
+var import_selenium_webdriver12, Column;
+var init_Column = __esm({
+  "src/pageObjects/elements/Table/elements/Column.ts"() {
+    "use strict";
+    import_selenium_webdriver12 = require("selenium-webdriver");
+    init_utils();
+    init_AbstractElementWithParent();
+    init_fixElementStaleError();
+    Column = class extends AbstractElementWithParent {
+      _index;
+      _caption;
+      _name;
+      headerCssSelector;
+      constructor({ parentCssSelector, headerCssSelector, name, caption, index, driver }) {
+        super(parentCssSelector, "", driver);
+        this._name = name;
+        this.index = index;
+        this._caption = caption;
+        this.headerCssSelector = headerCssSelector;
+      }
+      set index(index) {
+        this._index = index;
+        this.elementCssSelector = getColumnByIndexCssSelector(index);
+      }
+      get index() {
+        return this._index;
+      }
+      async getElement() {
+        await this.getIndex();
+        return super.getElement();
+      }
+      async getColumnHeaderIndexBy(cssSelector) {
+        const column = await fixElementStaleError(import_selenium_webdriver12.By.css(`${this.parentCssSelector} ${this.headerCssSelector} ${cssSelector}`), this.driver);
+        return transformOutputIndex(await column.getAttribute("aria-colindex"));
+      }
+      async getIndexByCaption() {
+        return this.getColumnHeaderIndexBy(getColumnByCaptionCssSelector(this._caption));
+      }
+      async getIndexByName() {
+        return this.getColumnHeaderIndexBy(getColumnByNameCssSelector(this._name));
+      }
+      async caption() {
+        const el = await this.getElement();
+        return el.getText();
+      }
+      async getIndex() {
+        if (this.index != null) {
+          return this.index;
+        }
+        if (this._caption != null) {
+          this.index = await this.getIndexByCaption();
+          return this.index;
+        }
+        if (this._name != null) {
+          this.index = await this.getIndexByName();
+          return this.index;
+        }
+        throw new Error("Cant get the index in the column");
+      }
+    };
   }
-};
+});
 
-// src/pageObjects/elements/Editors/types.ts
-var ControlClass = /* @__PURE__ */ ((ControlClass2) => {
-  ControlClass2["Text"] = "text-control";
-  ControlClass2["TextArea"] = "text-area-control";
-  ControlClass2["Number"] = "number-control";
-  ControlClass2["CheckBox"] = "check-box";
-  ControlClass2["Multiselect"] = "multi-select-control";
-  ControlClass2["Select"] = "select-control";
-  ControlClass2["Switch"] = "switch-control";
-  ControlClass2["Date"] = "date-control";
-  ControlClass2["SingleDateRange"] = "single-date-range-control";
-  ControlClass2["BooleanSelector"] = "buttons-group";
-  ControlClass2["ButtonGroup"] = "button-group-field";
-  return ControlClass2;
-})(ControlClass || {});
+// src/pageObjects/elements/Editors/ClearStrategy/InputClearStrategy.ts
+var InputClearStrategy;
+var init_InputClearStrategy = __esm({
+  "src/pageObjects/elements/Editors/ClearStrategy/InputClearStrategy.ts"() {
+    "use strict";
+    InputClearStrategy = class {
+      async clear(editor) {
+        const inputEl = await editor.getInputElement();
+        await inputEl.clear();
+      }
+    };
+  }
+});
 
-// src/pageObjects/AbstractFormElement.ts
-var AbstractFormElement = class extends AbstractElementWithParent {
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
+// src/pageObjects/elements/Editors/AbstractEditor.ts
+var import_selenium_webdriver13, AbstractDXEditorWithInput;
+var init_AbstractEditor = __esm({
+  "src/pageObjects/elements/Editors/AbstractEditor.ts"() {
+    "use strict";
+    import_selenium_webdriver13 = require("selenium-webdriver");
+    init_actions();
+    init_InputClearStrategy();
+    init_AbstractElementWithParent();
+    AbstractDXEditorWithInput = class extends AbstractElementWithParent {
+      clearStrategy = new InputClearStrategy();
+      setClearStrategy(strategy) {
+        this.clearStrategy = strategy;
+      }
+      getInputCssSelector() {
+        return `${this.getFullCssSelector()} .dx-texteditor-input`;
+      }
+      async getInputElement() {
+        return this.driver.findElement(import_selenium_webdriver13.By.css(this.getInputCssSelector()));
+      }
+      async getInputValue() {
+        const inputEl = await this.getInputElement();
+        return inputEl.getAttribute("value");
+      }
+      async setInputValue(value) {
+        const inputEl = await this.getInputElement();
+        await click(inputEl, this.driver);
+        await inputEl.sendKeys(value, import_selenium_webdriver13.Key.ENTER);
+      }
+      async clear() {
+        await this.clearStrategy.clear(this);
+      }
+    };
   }
-};
+});
 
-// src/pageObjects/elements/Editors/CheckBox.ts
-var CheckBox = class extends AbstractElementWithParent {
-  async getValue() {
-    const result = await this.getAttribute("aria-checked");
-    if (result === "true")
-      return 1;
-    if (result === "false")
-      return 0;
-    return null;
-  }
-  async setValue(value) {
-    const inputEl = await this.getElement();
-    const currentValue = await this.getValue();
-    if (currentValue !== value) {
-      await click(inputEl, this.driver);
-    }
+// src/pageObjects/elements/Editors/TextEditor.ts
+var TextEditor;
+var init_TextEditor = __esm({
+  "src/pageObjects/elements/Editors/TextEditor.ts"() {
+    "use strict";
+    init_AbstractEditor();
+    init_InputClearStrategy();
+    TextEditor = class extends AbstractDXEditorWithInput {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new InputClearStrategy());
+      }
+      getValue() {
+        return this.getInputValue();
+      }
+      setValue(value) {
+        return this.setInputValue(value);
+      }
+    };
   }
-};
+});
 
-// src/pageObjects/elements/Editors/SelectBoxEditor.ts
-var import_selenium_webdriver11 = require("selenium-webdriver");
+// src/pageObjects/elements/Editors/NumberEditor.ts
+var NumberEditor;
+var init_NumberEditor = __esm({
+  "src/pageObjects/elements/Editors/NumberEditor.ts"() {
+    "use strict";
+    init_AbstractEditor();
+    init_InputClearStrategy();
+    NumberEditor = class extends AbstractDXEditorWithInput {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new InputClearStrategy());
+      }
+      async getValue() {
+        const value = await super.getInputValue();
+        return value == "" ? null : Number.parseFloat(value);
+      }
+      setValue(value) {
+        return this.setInputValue(value);
+      }
+    };
+  }
+});
+
+// src/pageObjects/elements/Editors/types.ts
+var ControlClass;
+var init_types3 = __esm({
+  "src/pageObjects/elements/Editors/types.ts"() {
+    "use strict";
+    ControlClass = /* @__PURE__ */ ((ControlClass2) => {
+      ControlClass2["Text"] = "text-control";
+      ControlClass2["TextArea"] = "text-area-control";
+      ControlClass2["Number"] = "number-control";
+      ControlClass2["CheckBox"] = "check-box";
+      ControlClass2["Multiselect"] = "multi-select-control";
+      ControlClass2["Select"] = "select-control";
+      ControlClass2["Switch"] = "switch-control";
+      ControlClass2["Date"] = "date-control";
+      ControlClass2["SingleDateRange"] = "single-date-range-control";
+      ControlClass2["BooleanSelector"] = "buttons-group";
+      ControlClass2["ButtonGroup"] = "button-group-field";
+      return ControlClass2;
+    })(ControlClass || {});
+  }
+});
+
+// src/pageObjects/elements/Editors/CheckBox.ts
+var CheckBox;
+var init_CheckBox = __esm({
+  "src/pageObjects/elements/Editors/CheckBox.ts"() {
+    "use strict";
+    init_actions();
+    init_AbstractElementWithParent();
+    CheckBox = class extends AbstractElementWithParent {
+      async getValue() {
+        const result = await this.getAttribute("aria-checked");
+        if (result === "true")
+          return 1;
+        if (result === "false")
+          return 0;
+        return null;
+      }
+      async setValue(value) {
+        const inputEl = await this.getElement();
+        const currentValue = await this.getValue();
+        if (currentValue !== value) {
+          await click(inputEl, this.driver);
+        }
+      }
+    };
+  }
+});
 
 // src/utils/xpathHelper.ts
-var XPathHelper = class {
-  static getClassAndValueXpath(cssClass, value) {
-    return `div[contains(@class, '${cssClass}') and contains(.,'${value}')]`;
+var XPathHelper;
+var init_xpathHelper = __esm({
+  "src/utils/xpathHelper.ts"() {
+    "use strict";
+    XPathHelper = class {
+      static getClassAndValueXpath(cssClass, value) {
+        return `div[contains(@class, '${cssClass}') and contains(.,'${value}')]`;
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts
-var import_selenium_webdriver10 = require("selenium-webdriver");
-var DX_TEXTEDITOR_EMPTY = "dx-texteditor-empty";
-var DX_CLEAR_BUTTON_AREA = "dx-clear-button-area";
-var ClearButtonStrategy = class {
-  editorContainerClass;
-  _driver;
-  constructor(editorContainerClass, driver) {
-    this.editorContainerClass = editorContainerClass;
-    this._driver = driver;
-  }
-  async isEmptyEditorField() {
-    const editorContainer = await this._driver.findElement(import_selenium_webdriver10.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_webdriver10.By.css(clearBtnSelector));
-    await click(clearBtn, this._driver);
+var import_selenium_webdriver14, DX_TEXTEDITOR_EMPTY, DX_CLEAR_BUTTON_AREA, ClearButtonStrategy;
+var init_ClearButtonStrategy = __esm({
+  "src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts"() {
+    "use strict";
+    import_selenium_webdriver14 = 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_webdriver14.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_webdriver14.By.css(clearBtnSelector));
+        await click(clearBtn, this._driver);
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/Editors/SelectBoxEditor.ts
-var SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS = "d5-multi-select-item";
-var combinedValueXpath = (value) => `//body/div[@id="root"]/div[contains(@class, "dx-overlay-wrapper")]//${XPathHelper.getClassAndValueXpath(SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS, value)}`;
-var dropDownOptionClick = async (optionValue, driver, delay = true) => {
-  const { implicit } = await driver.manage().getTimeouts();
-  let optElement = null;
-  const timeout = delay ? implicit : 200;
-  let err = null;
-  try {
-    await driver.manage().setTimeouts({ implicit: timeout });
-    optElement = await driver.findElement(import_selenium_webdriver11.By.xpath(combinedValueXpath(optionValue)));
-    await click(optElement, driver);
-  } catch (e) {
-    err = new Error(`Item not found: "${optionValue}"`);
-  } finally {
-    await driver.manage().setTimeouts({ implicit });
-  }
-  if (err)
-    throw err;
-};
-var SelectBoxEditor = class extends AbstractDXEditorWithInput {
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-    this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), this.driver));
-  }
-  async setSelectInputValue(value) {
-    const inputEl = await this.getInputElement();
-    await click(inputEl, this.driver);
-    try {
-      await dropDownOptionClick(value, this.driver, false);
-    } catch {
-      await inputEl.sendKeys(value, import_selenium_webdriver11.Key.ENTER);
-      await dropDownOptionClick(value, this.driver);
-    }
-  }
-  async getValue() {
-    const value = await super.getInputValue();
-    return value == "" ? null : value;
-  }
-  setValue(value) {
-    return this.setSelectInputValue(value);
+var import_selenium_webdriver15, 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_webdriver15 = require("selenium-webdriver");
+    init_xpathHelper();
+    init_actions();
+    init_ClearButtonStrategy();
+    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) => {
+      const { implicit } = await driver.manage().getTimeouts();
+      let optElement = null;
+      const timeout = delay ? implicit : 200;
+      let err = null;
+      try {
+        await driver.manage().setTimeouts({ implicit: timeout });
+        optElement = await driver.findElement(import_selenium_webdriver15.By.xpath(combinedValueXpath(optionValue)));
+        await click(optElement, driver);
+      } catch (e) {
+        err = new Error(`Item not found: "${optionValue}"`);
+      } finally {
+        await driver.manage().setTimeouts({ implicit });
+      }
+      if (err)
+        throw err;
+    };
+    SelectBoxEditor = class extends AbstractDXEditorWithInput {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), this.driver));
+      }
+      async setSelectInputValue(value) {
+        const inputEl = await this.getInputElement();
+        await click(inputEl, this.driver);
+        try {
+          await dropDownOptionClick(value, this.driver, false);
+        } catch {
+          await inputEl.sendKeys(value, import_selenium_webdriver15.Key.ENTER);
+          await dropDownOptionClick(value, this.driver);
+        }
+      }
+      async getValue() {
+        const value = await super.getInputValue();
+        return value == "" ? null : value;
+      }
+      setValue(value) {
+        return this.setSelectInputValue(value);
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/Editors/SwitchEditor.ts
-var SwitchEditor = class extends AbstractElementWithParent {
-  async getValue() {
-    const result = await this.getAttribute("aria-label");
-    if (result === "ON")
-      return 1;
-    if (result === "OFF")
-      return 0;
-    return null;
-  }
-  async setValue(value) {
-    if (value !== 0 && value !== 1) {
-      value = value ? 1 : 0;
-    }
-    const inputEl = await this.getElement();
-    const currentValue = await this.getValue();
-    if (currentValue === value) {
-      return;
-    }
-    await click(inputEl, this.driver);
-    await wait(async () => {
-      const updatedValue = await this.getValue();
-      return updatedValue !== currentValue;
-    }, this.driver);
+var SwitchEditor;
+var init_SwitchEditor = __esm({
+  "src/pageObjects/elements/Editors/SwitchEditor.ts"() {
+    "use strict";
+    init_actions();
+    init_AbstractElementWithParent();
+    init_wait();
+    SwitchEditor = class extends AbstractElementWithParent {
+      async getValue() {
+        const result = await this.getAttribute("aria-label");
+        if (result === "ON")
+          return 1;
+        if (result === "OFF")
+          return 0;
+        return null;
+      }
+      async setValue(value) {
+        if (value !== 0 && value !== 1) {
+          value = value ? 1 : 0;
+        }
+        const inputEl = await this.getElement();
+        const currentValue = await this.getValue();
+        if (currentValue === value) {
+          return;
+        }
+        await click(inputEl, this.driver);
+        await wait(async () => {
+          const updatedValue = await this.getValue();
+          return updatedValue !== currentValue;
+        }, this.driver);
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/Editors/TagBox.ts
-var import_selenium_webdriver12 = require("selenium-webdriver");
-var TAGS_SELECTOR = ".dx-tag .tag-text";
-var DX_TAG_CONTAINER = "dx-tag-container";
-var DX_TEXTEDITOR_EMPTY2 = "dx-texteditor-empty";
-var BTN_OK_SELECTOR = ".dx-tagbox-popup-wrapper .dx-popup-bottom .dx-button.dx-popup-done";
-var TAG_BOX_LIST_ITEM_SELECTOR = '.dx-tagbox-popup-wrapper .dx-list-item[aria-selected="true"]';
-var TagBox = class extends AbstractDXEditorWithInput {
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-    this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), this.driver));
-  }
-  async setTagBoxInputValue(values) {
-    const lastElement = values[values.length - 1];
-    const inputEl = await this.getInputElement();
-    await inputEl.click();
-    for (const value of values) {
-      await this.selectOption(inputEl, value, lastElement);
-    }
-    await this.confirmSelection();
-  }
-  async waitOptionSelection() {
-    const option = await this.driver.findElement(import_selenium_webdriver12.By.css(TAG_BOX_LIST_ITEM_SELECTOR));
-    await wait(() => option.isDisplayed(), this.driver);
-  }
-  async selectOption(inputEl, value, lastElement) {
-    try {
-      await dropDownOptionClick(value, this.driver, false);
-    } catch {
-      await inputEl.sendKeys(value);
-      await dropDownOptionClick(value, this.driver);
-    }
-    await this.waitOptionSelection();
-    if (value !== lastElement) {
-      await inputEl.clear();
-    }
-  }
-  async confirmSelection() {
-    const btnOk = await this.driver.findElement(import_selenium_webdriver12.By.css(BTN_OK_SELECTOR));
-    await click(btnOk, this.driver);
-  }
-  async getTagBoxInputValue() {
-    if (await this.isTagBoxEmpty()) {
-      return [];
-    }
-    const tags = await this.driver.findElements(
-      import_selenium_webdriver12.By.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${TAGS_SELECTOR}`)
-    );
-    const values = [];
-    for (const tag of tags) {
-      values.push(await tag.getAttribute("textContent"));
-    }
-    return values;
-  }
-  async isTagBoxEmpty() {
-    const classAttribute = await this.getClasses();
-    return classAttribute.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");
-    }
-    await this.setTagBoxInputValue(values);
-  }
-  async remove(itemText) {
-    const tagValues = await this.getValue();
-    const tagExists = tagValues.includes(itemText);
-    if (!tagExists) {
-      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_webdriver12.By.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${clearBtnTestId}`)
-    );
-    await click(clearBtn, this.driver);
+var import_selenium_webdriver16, TAGS_SELECTOR, DX_TAG_CONTAINER, DX_TEXTEDITOR_EMPTY2, BTN_OK_SELECTOR, TAG_BOX_LIST_ITEM_SELECTOR, TagBox;
+var init_TagBox = __esm({
+  "src/pageObjects/elements/Editors/TagBox.ts"() {
+    "use strict";
+    init_AbstractEditor();
+    import_selenium_webdriver16 = require("selenium-webdriver");
+    init_actions();
+    init_locators();
+    init_SelectBoxEditor();
+    init_ClearButtonStrategy();
+    init_fixElementStaleError();
+    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";
+    TAG_BOX_LIST_ITEM_SELECTOR = '.dx-tagbox-popup-wrapper .dx-list-item[aria-selected="true"]';
+    TagBox = class extends AbstractDXEditorWithInput {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), this.driver));
+      }
+      async setTagBoxInputValue(values) {
+        const lastElement = values[values.length - 1];
+        const inputEl = await this.getInputElement();
+        await inputEl.click();
+        for (const value of values) {
+          await this.selectOption(inputEl, value, lastElement);
+        }
+        await this.confirmSelection();
+      }
+      async waitOptionSelection() {
+        await fixElementStaleError(import_selenium_webdriver16.By.css(TAG_BOX_LIST_ITEM_SELECTOR), this.driver);
+      }
+      async selectOption(inputEl, value, lastElement) {
+        try {
+          await dropDownOptionClick(value, this.driver, false);
+        } catch {
+          await inputEl.sendKeys(value);
+          await dropDownOptionClick(value, this.driver);
+        }
+        await this.waitOptionSelection();
+        if (value !== lastElement) {
+          await inputEl.clear();
+        }
+      }
+      async confirmSelection() {
+        const btnOk = await fixElementStaleError(import_selenium_webdriver16.By.css(BTN_OK_SELECTOR), this.driver);
+        await click(btnOk, this.driver);
+      }
+      async getTagBoxInputValue() {
+        if (await this.isTagBoxEmpty()) {
+          return [];
+        }
+        const tags = await this.driver.findElements(
+          import_selenium_webdriver16.By.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${TAGS_SELECTOR}`)
+        );
+        const values = [];
+        for (const tag of tags) {
+          values.push(await tag.getAttribute("textContent"));
+        }
+        return values;
+      }
+      async isTagBoxEmpty() {
+        const classAttribute = await this.getClasses();
+        return classAttribute.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");
+        }
+        await this.setTagBoxInputValue(values);
+      }
+      async remove(itemText) {
+        const tagValues = await this.getValue();
+        const tagExists = tagValues.includes(itemText);
+        if (!tagExists) {
+          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_webdriver16.By.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${clearBtnTestId}`)
+        );
+        await click(clearBtn, this.driver);
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/Editors/ButtonGroup.ts
-var import_selenium_webdriver13 = require("selenium-webdriver");
-var ITEM_CLASS = "dx-buttongroup-item";
-var SELECTED_CLASS = "dx-state-selected";
-var ButtonGroup = class extends AbstractElementWithParent {
-  getItems() {
-    return this.driver.findElements(import_selenium_webdriver13.By.css(`${this.getFullCssSelector()} .${ITEM_CLASS}`));
-  }
-  getDataValue(el) {
-    return el.getAttribute("data-value");
-  }
-  async getValue() {
-    const selectedEl = await this.driver.findElement(import_selenium_webdriver13.By.css(`${this.getFullCssSelector()} .${ITEM_CLASS}.${SELECTED_CLASS}`));
-    return this.getDataValue(selectedEl);
-  }
-  async setValue(value) {
-    const items = await this.getItems();
-    let buttonEl = void 0;
-    for (const item of items) {
-      const text = await this.getDataValue(item);
-      if (text == value) {
-        buttonEl = item;
-        break;
+var import_selenium_webdriver17, ITEM_CLASS, SELECTED_CLASS, ButtonGroup;
+var init_ButtonGroup = __esm({
+  "src/pageObjects/elements/Editors/ButtonGroup.ts"() {
+    "use strict";
+    init_actions();
+    import_selenium_webdriver17 = require("selenium-webdriver");
+    init_AbstractElementWithParent();
+    ITEM_CLASS = "dx-buttongroup-item";
+    SELECTED_CLASS = "dx-state-selected";
+    ButtonGroup = class extends AbstractElementWithParent {
+      getItems() {
+        return this.driver.findElements(import_selenium_webdriver17.By.css(`${this.getFullCssSelector()} .${ITEM_CLASS}`));
       }
-    }
-    if (!buttonEl)
-      throw new Error(`Cannot find item in button group with text: ${value}`);
-    await click(buttonEl, this.driver);
+      getDataValue(el) {
+        return el.getAttribute("data-value");
+      }
+      async getValue() {
+        const selectedEl = await this.driver.findElement(import_selenium_webdriver17.By.css(`${this.getFullCssSelector()} .${ITEM_CLASS}.${SELECTED_CLASS}`));
+        return this.getDataValue(selectedEl);
+      }
+      async setValue(value) {
+        const items = await this.getItems();
+        let buttonEl = void 0;
+        for (const item of items) {
+          const text = await this.getDataValue(item);
+          if (text == value) {
+            buttonEl = item;
+            break;
+          }
+        }
+        if (!buttonEl)
+          throw new Error(`Cannot find item in button group with text: ${value}`);
+        await click(buttonEl, this.driver);
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/Editors/BooleanSelector.ts
-var BooleanSelector = class extends ButtonGroup {
-  // @ts-ignore
-  async getValue() {
-    const value = await super.getValue();
-    return value === "null" ? null : value === "1" ? 1 : 0;
-  }
-  // @ts-ignore
-  async setValue(value) {
-    const val = value == null ? "null" : value ? "1" : "0";
-    await super.setValue(val);
+var BooleanSelector;
+var init_BooleanSelector = __esm({
+  "src/pageObjects/elements/Editors/BooleanSelector.ts"() {
+    "use strict";
+    init_ButtonGroup();
+    BooleanSelector = class extends ButtonGroup {
+      // @ts-ignore
+      async getValue() {
+        const value = await super.getValue();
+        return value === "null" ? null : value === "1" ? 1 : 0;
+      }
+      // @ts-ignore
+      async setValue(value) {
+        const val = value == null ? "null" : value ? "1" : "0";
+        await super.setValue(val);
+      }
+    };
   }
-};
-
-// src/pageObjects/elements/Editors/Date/SingleDateEditor.ts
-var import_selenium_webdriver15 = require("selenium-webdriver");
-
-// src/pageObjects/elements/Editors/Date/BaseDateEditor.ts
-var import_selenium_webdriver14 = require("selenium-webdriver");
+});
 
 // src/pageObjects/elements/Editors/Date/utils.ts
-var formatDMYDate = (date) => {
-  const [year, month, day] = date.toJSON().split("T")[0].split("-");
-  return `${day}${month}${year}`;
-};
+var formatDMYDate;
+var init_utils2 = __esm({
+  "src/pageObjects/elements/Editors/Date/utils.ts"() {
+    "use strict";
+    formatDMYDate = (date) => {
+      const [year, month, day] = date.toJSON().split("T")[0].split("-");
+      return `${day}${month}${year}`;
+    };
+  }
+});
 
 // src/pageObjects/elements/Editors/Date/BaseDateEditor.ts
-var BTN_CALENDAR_POPOVER_OPEN_SELECTOR = "calendar-popover-open-button";
-var BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR = "DateRange__inputs-item--dateFrom";
-var BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR = "DateRange__inputs-item--dateTo";
-var BTN_SAVE_SELECTOR = "DateRange__button-save";
-var BaseDateEditor = class extends AbstractDXEditorWithInput {
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-    this.setClearStrategy(new InputClearStrategy());
-  }
-  async setDateValue(value) {
-    const actions = this.driver.actions({ async: true });
-    const dateField = await this.driver.findElement(import_selenium_webdriver14.By.css(`${this.getFullCssSelector()}`));
-    const dateFieldDataTestID = await this.getDataTestId();
-    const calendarPopoverSelector = byTestIdCssSelector(`${dateFieldDataTestID}-calendar-popover`);
-    const dateInputEl = await this.getInputElement();
-    await dateInputEl.clear();
-    if (Array.isArray(value)) {
-      const formattedDates = value.map(formatDMYDate);
-      const button = await dateField.findElement(import_selenium_webdriver14.By.css(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`));
-      await button.click();
-      const calendarPopoverElement = await this.driver.findElement(import_selenium_webdriver14.By.css(calendarPopoverSelector));
-      const dateFromInput = await calendarPopoverElement.findElement(import_selenium_webdriver14.By.css(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .dx-texteditor-input`));
-      const dateToInput = await calendarPopoverElement.findElement(import_selenium_webdriver14.By.css(`.${BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR} .dx-texteditor-input`));
-      await dateFromInput.click();
-      await dateFromInput.sendKeys(formattedDates[0]);
-      await dateToInput.click();
-      await actions.move({ origin: dateInputEl }).sendKeys(import_selenium_webdriver14.Key.HOME).perform();
-      await dateToInput.sendKeys(formattedDates[1]);
-      await actions.move({ origin: dateInputEl }).sendKeys(import_selenium_webdriver14.Key.ENTER).perform();
-      const btnOk = await this.driver.findElement(import_selenium_webdriver14.By.css(`.${BTN_SAVE_SELECTOR}`));
-      await btnOk.click();
-    } else {
-      const formattedDate = formatDMYDate(value);
-      await click(dateInputEl, this.driver);
-      await actions.move({ origin: dateInputEl }).sendKeys(import_selenium_webdriver14.Key.HOME).perform();
-      await actions.move({ origin: dateInputEl }).sendKeys(formattedDate, import_selenium_webdriver14.Key.ENTER).perform();
-    }
+var import_selenium_webdriver18, BTN_CALENDAR_POPOVER_OPEN_SELECTOR, BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR, BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR, BTN_SAVE_SELECTOR, BaseDateEditor;
+var init_BaseDateEditor = __esm({
+  "src/pageObjects/elements/Editors/Date/BaseDateEditor.ts"() {
+    "use strict";
+    init_AbstractEditor();
+    init_InputClearStrategy();
+    import_selenium_webdriver18 = require("selenium-webdriver");
+    init_locators();
+    init_actions();
+    init_utils2();
+    BTN_CALENDAR_POPOVER_OPEN_SELECTOR = "calendar-popover-open-button";
+    BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR = "DateRange__inputs-item--dateFrom";
+    BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR = "DateRange__inputs-item--dateTo";
+    BTN_SAVE_SELECTOR = "DateRange__button-save";
+    BaseDateEditor = class extends AbstractDXEditorWithInput {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new InputClearStrategy());
+      }
+      async setDateValue(value) {
+        const actions = this.driver.actions({ async: true });
+        const dateField = await this.driver.findElement(import_selenium_webdriver18.By.css(`${this.getFullCssSelector()}`));
+        const dateFieldDataTestID = await this.getDataTestId();
+        const calendarPopoverSelector = byTestIdCssSelector(`${dateFieldDataTestID}-calendar-popover`);
+        const dateInputEl = await this.getInputElement();
+        await dateInputEl.clear();
+        if (Array.isArray(value)) {
+          const formattedDates = value.map(formatDMYDate);
+          const button = await dateField.findElement(import_selenium_webdriver18.By.css(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`));
+          await button.click();
+          const calendarPopoverElement = await this.driver.findElement(import_selenium_webdriver18.By.css(calendarPopoverSelector));
+          const dateFromInput = await calendarPopoverElement.findElement(import_selenium_webdriver18.By.css(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .dx-texteditor-input`));
+          const dateToInput = await calendarPopoverElement.findElement(import_selenium_webdriver18.By.css(`.${BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR} .dx-texteditor-input`));
+          await dateFromInput.click();
+          await dateFromInput.sendKeys(formattedDates[0]);
+          await dateToInput.click();
+          await actions.move({ origin: dateInputEl }).sendKeys(import_selenium_webdriver18.Key.HOME).perform();
+          await dateToInput.sendKeys(formattedDates[1]);
+          await actions.move({ origin: dateInputEl }).sendKeys(import_selenium_webdriver18.Key.ENTER).perform();
+          const btnOk = await this.driver.findElement(import_selenium_webdriver18.By.css(`.${BTN_SAVE_SELECTOR}`));
+          await btnOk.click();
+        } else {
+          const formattedDate = formatDMYDate(value);
+          await click(dateInputEl, this.driver);
+          await actions.move({ origin: dateInputEl }).sendKeys(import_selenium_webdriver18.Key.HOME).perform();
+          await actions.move({ origin: dateInputEl }).sendKeys(formattedDate, import_selenium_webdriver18.Key.ENTER).perform();
+        }
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/Editors/Date/SingleDateEditor.ts
-var SingleDateEditor = class extends BaseDateEditor {
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-    this.setClearStrategy(new InputClearStrategy());
-  }
-  async getDateElement() {
-    return this.driver.findElement(import_selenium_webdriver15.By.css(this.getFullCssSelector() + " .dx-dropdowneditor-input-wrapper input[type=hidden]"));
-  }
-  async getDateValue() {
-    const inputEl = await this.getDateElement();
-    return inputEl.getAttribute("value");
-  }
-  async getValue() {
-    const value = await this.getDateValue();
-    return value == "" ? null : new Date(value);
-  }
-  setValue(value) {
-    if (typeof value === "object") {
-      return this.setDateValue(value);
-    }
-    throw new Error(`Value is incorrect. It should be Object`);
+var import_selenium_webdriver19, SingleDateEditor;
+var init_SingleDateEditor = __esm({
+  "src/pageObjects/elements/Editors/Date/SingleDateEditor.ts"() {
+    "use strict";
+    import_selenium_webdriver19 = require("selenium-webdriver");
+    init_InputClearStrategy();
+    init_BaseDateEditor();
+    SingleDateEditor = class extends BaseDateEditor {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new InputClearStrategy());
+      }
+      async getDateElement() {
+        return this.driver.findElement(import_selenium_webdriver19.By.css(this.getFullCssSelector() + " .dx-dropdowneditor-input-wrapper input[type=hidden]"));
+      }
+      async getDateValue() {
+        const inputEl = await this.getDateElement();
+        return inputEl.getAttribute("value");
+      }
+      async getValue() {
+        const value = await this.getDateValue();
+        return value == "" ? null : new Date(value);
+      }
+      setValue(value) {
+        if (typeof value === "object") {
+          return this.setDateValue(value);
+        }
+        throw new Error(`Value is incorrect. It should be Object`);
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/Editors/Date/DateRangeEditor.ts
-var import_selenium_webdriver16 = require("selenium-webdriver");
-var DateRangeEditor = class extends BaseDateEditor {
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-    this.setClearStrategy(new InputClearStrategy());
-  }
-  async getDateElement() {
-    return this.driver.findElement(import_selenium_webdriver16.By.css(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];
-  }
-  async getValue() {
-    const values = await this.getDateValue();
-    return !values.length ? null : values;
-  }
-  setValue(value) {
-    if (typeof value === "object") {
-      return this.setDateValue(value);
-    }
-    throw new Error(`Value is incorrect. It should be Object`);
+var import_selenium_webdriver20, DateRangeEditor;
+var init_DateRangeEditor = __esm({
+  "src/pageObjects/elements/Editors/Date/DateRangeEditor.ts"() {
+    "use strict";
+    import_selenium_webdriver20 = require("selenium-webdriver");
+    init_InputClearStrategy();
+    init_BaseDateEditor();
+    DateRangeEditor = class extends BaseDateEditor {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new InputClearStrategy());
+      }
+      async getDateElement() {
+        return this.driver.findElement(import_selenium_webdriver20.By.css(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];
+      }
+      async getValue() {
+        const values = await this.getDateValue();
+        return !values.length ? null : values;
+      }
+      setValue(value) {
+        if (typeof value === "object") {
+          return this.setDateValue(value);
+        }
+        throw new Error(`Value is incorrect. It should be Object`);
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/Editors/Date/DateEditor.ts
-var DateEditor = class extends AbstractDXEditorWithInput {
-  editorInstance = null;
-  initPromise;
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-    this.initPromise = this.init(parentCssSelector, elementCssSelector, driver);
-  }
-  async init(parentCssSelector, elementCssSelector, driver) {
-    await this.updateEditorInstance(parentCssSelector, elementCssSelector, driver);
-  }
-  async updateEditorInstance(parentCssSelector, elementCssSelector, driver) {
-    const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
-    const classString = await elementInstance.getClasses();
-    switch (true) {
-      case classString.includes("date-control" /* Date */):
-        this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, driver);
-        break;
-      case classString.includes("single-date-range-control" /* SingleDateRange */):
-        this.editorInstance = new DateRangeEditor(parentCssSelector, elementCssSelector, driver);
-        break;
-      default:
-        this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, driver);
-    }
-  }
-  async ensureInitialized() {
-    if (!this.editorInstance) {
-      await this.initPromise;
-    }
-  }
-  async setValue(value) {
-    await this.ensureInitialized();
-    if (this.editorInstance) {
-      await this.editorInstance.setValue(value);
-      return await this.updateEditorInstance(this.parentCssSelector, this.elementCssSelector, this.driver);
-    }
-    throw new Error("Editor instance is not initialized.");
-  }
-  async getValue() {
-    await this.ensureInitialized();
-    if (this.editorInstance) {
-      return this.editorInstance.getValue();
-    }
-    throw new Error("Editor instance is not initialized.");
+var DateEditor;
+var init_DateEditor = __esm({
+  "src/pageObjects/elements/Editors/Date/DateEditor.ts"() {
+    "use strict";
+    init_SingleDateEditor();
+    init_DateRangeEditor();
+    init_AbstractFormElement();
+    init_AbstractEditor();
+    init_types3();
+    DateEditor = class extends AbstractDXEditorWithInput {
+      editorInstance = null;
+      initPromise;
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.initPromise = this.init(parentCssSelector, elementCssSelector, driver);
+      }
+      async init(parentCssSelector, elementCssSelector, driver) {
+        await this.updateEditorInstance(parentCssSelector, elementCssSelector, driver);
+      }
+      async updateEditorInstance(parentCssSelector, elementCssSelector, driver) {
+        const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
+        const classString = await elementInstance.getClasses();
+        switch (true) {
+          case classString.includes("date-control" /* Date */):
+            this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, driver);
+            break;
+          case classString.includes("single-date-range-control" /* SingleDateRange */):
+            this.editorInstance = new DateRangeEditor(parentCssSelector, elementCssSelector, driver);
+            break;
+          default:
+            this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, driver);
+        }
+      }
+      async ensureInitialized() {
+        if (!this.editorInstance) {
+          await this.initPromise;
+        }
+      }
+      async setValue(value) {
+        await this.ensureInitialized();
+        if (this.editorInstance) {
+          await this.editorInstance.setValue(value);
+          return await this.updateEditorInstance(this.parentCssSelector, this.elementCssSelector, this.driver);
+        }
+        throw new Error("Editor instance is not initialized.");
+      }
+      async getValue() {
+        await this.ensureInitialized();
+        if (this.editorInstance) {
+          return this.editorInstance.getValue();
+        }
+        throw new Error("Editor instance is not initialized.");
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/Editors/editorFactory.ts
-var 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);
-  throw new Error("Unknown type of editor. Please write ticket to the support");
-};
-
-// src/pageObjects/elements/AbstractEditor.ts
-var AbstractEditor = class extends AbstractElementWithParent {
-  editor;
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-  }
-  async initEditor() {
-    if (!this.editor) {
-      this.editor = await editorFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
-    }
-  }
-  /**
-   * Возвращает значение в поле
-   * @example
-   * expect(await formEdit.field('NumberFld').getValue()).toBe(10);
-   * expect(await formEdit.field('TextFld').getValue()).toBe('TestValue');
-   */
-  async getValue() {
-    await this.initEditor();
-    return this.editor.getValue();
-  }
-  /**
-   * Устанавливает значение в поле
-   * @example
-   * await formEdit.field('NumberFld').setValue(123);
-   * await formEdit.field('TextFld').setValue('TestValue');
-   */
-  async setValue(value) {
-    await this.initEditor();
-    return this.editor.setValue(value);
-  }
-  /**
-   * Очищает значение в поле
-   * @example
-   * await formEdit.field('NumberFld').clear();
-   */
-  async clear() {
-    await this.initEditor();
-    if (!this.editor.clear) {
-      throw new Error("The clear method is not available for this field type.");
-    }
-    return this.editor.clear();
+var editorFactory;
+var init_editorFactory = __esm({
+  "src/pageObjects/elements/Editors/editorFactory.ts"() {
+    "use strict";
+    init_types3();
+    init_AbstractFormElement();
+    init_TextEditor();
+    init_NumberEditor();
+    init_CheckBox();
+    init_SelectBoxEditor();
+    init_SwitchEditor();
+    init_TagBox();
+    init_BooleanSelector();
+    init_ButtonGroup();
+    init_DateEditor();
+    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);
+      throw new Error("Unknown type of editor. Please write ticket to the support");
+    };
   }
-  /**
-   * Удаляет тег по переданному тексту
-   * @example
-   * await formEdit.field('TagBox').remove('test');
-   */
-  async remove(itemText) {
-    await this.initEditor();
-    if (!this.editor.remove) {
-      throw new Error("This method is only available for the TagBox field.");
-    }
-    return this.editor.remove(itemText);
+});
+
+// src/pageObjects/elements/Editors/index.ts
+var init_Editors = __esm({
+  "src/pageObjects/elements/Editors/index.ts"() {
+    "use strict";
+    init_TextEditor();
+    init_NumberEditor();
+    init_editorFactory();
+    init_types3();
   }
-  /**
-   * Возвращает значение true|false в зависимости readOnly поле или нет
-   * @example
-   * expect(await formEdit.field('NumberFld').isReadonly()).toBe(true);
-   * expect(await formEdit.field('TextFld').isReadonly()).toBe(false);
-   */
-  async isReadonly() {
-    await this.initEditor();
-    return this.editor.isReadonly();
+});
+
+// src/pageObjects/elements/AbstractEditor.ts
+var AbstractEditor;
+var init_AbstractEditor2 = __esm({
+  "src/pageObjects/elements/AbstractEditor.ts"() {
+    "use strict";
+    init_AbstractElementWithParent();
+    init_Editors();
+    AbstractEditor = class extends AbstractElementWithParent {
+      editor;
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+      }
+      async initEditor() {
+        if (!this.editor) {
+          this.editor = await editorFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
+        }
+      }
+      /**
+       * Возвращает значение в поле
+       * @example
+       * expect(await formEdit.field('NumberFld').getValue()).toBe(10);
+       * expect(await formEdit.field('TextFld').getValue()).toBe('TestValue');
+       */
+      async getValue() {
+        await this.initEditor();
+        return this.editor.getValue();
+      }
+      /**
+       * Устанавливает значение в поле
+       * @example
+       * await formEdit.field('NumberFld').setValue(123);
+       * await formEdit.field('TextFld').setValue('TestValue');
+       */
+      async setValue(value) {
+        await this.initEditor();
+        return this.editor.setValue(value);
+      }
+      /**
+       * Очищает значение в поле
+       * @example
+       * await formEdit.field('NumberFld').clear();
+       */
+      async clear() {
+        await this.initEditor();
+        if (!this.editor.clear) {
+          throw new Error("The clear method is not available for this field type.");
+        }
+        return this.editor.clear();
+      }
+      /**
+       * Удаляет тег по переданному тексту
+       * @example
+       * await formEdit.field('TagBox').remove('test');
+       */
+      async remove(itemText) {
+        await this.initEditor();
+        if (!this.editor.remove) {
+          throw new Error("This method is only available for the TagBox field.");
+        }
+        return this.editor.remove(itemText);
+      }
+      /**
+       * Возвращает значение true|false в зависимости readOnly поле или нет
+       * @example
+       * expect(await formEdit.field('NumberFld').isReadonly()).toBe(true);
+       * expect(await formEdit.field('TextFld').isReadonly()).toBe(false);
+       */
+      async isReadonly() {
+        await this.initEditor();
+        return this.editor.isReadonly();
+      }
+    };
   }
-};
+});
 
 // src/pageObjects/elements/FormField.ts
-var FormField = class extends AbstractEditor {
-  constructor(parentCssSelector, formName, name, driver) {
-    super(parentCssSelector, byTestIdCssSelector(createFieldTestId(formName, name)), driver);
+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/pageObjects/elements/Groups/AbstractGroup.ts
-var AbstractGroup = class extends AbstractElementWithParent {
-  async isDisplayed() {
-    const groupElement = await this.getElement();
-    return await groupElement.isDisplayed();
+// src/pageObjects/elements/Table/Table.ts
+var import_selenium_webdriver21, Table;
+var init_Table = __esm({
+  "src/pageObjects/elements/Table/Table.ts"() {
+    "use strict";
+    import_selenium_webdriver21 = require("selenium-webdriver");
+    init_createDataTestId();
+    init_AbstractElementWithParent();
+    init_Row();
+    init_Column();
+    init_FormField();
+    Table = class extends AbstractElementWithParent {
+      formName;
+      headerCssSelector;
+      constructor(parentCssSelector, headerCssSelector, formName, driver) {
+        super(parentCssSelector, `#${createTableId(formName)}`, driver);
+        this.formName = formName;
+        this.headerCssSelector = headerCssSelector;
+      }
+      getColumnBy = (args) => {
+        if (args.title) {
+          return this.getColumnByTitle(args.title);
+        }
+        return this.getColumnByName(args.name);
+      };
+      getRowByIndex(index) {
+        return new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
+      }
+      getColumnByIndex(index) {
+        return new Column({
+          parentCssSelector: this.getFullCssSelector(),
+          driver: this.driver,
+          index
+        });
+      }
+      getColumnByTitle = (title) => {
+        return new Column({
+          parentCssSelector: this.getFullCssSelector(),
+          headerCssSelector: this.headerCssSelector,
+          caption: title,
+          driver: this.driver
+        });
+      };
+      getColumnByName = (name) => {
+        return new Column({
+          parentCssSelector: this.getFullCssSelector(),
+          headerCssSelector: this.headerCssSelector,
+          name,
+          driver: this.driver
+        });
+      };
+      selectRowByIndex(index) {
+        return this.getRowByIndex(index).select();
+      }
+      async getRows() {
+        const rows = await this.driver.findElements(import_selenium_webdriver21.By.css(`${this.getFullCssSelector()} .dx-row.dx-data-row`));
+        const result = [];
+        rows.forEach((_, index) => {
+          const newRow = new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
+          result.push(newRow);
+        });
+        return result;
+      }
+      async getColumns() {
+        const columns = await this.driver.findElements(
+          import_selenium_webdriver21.By.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"]`)
+        );
+        const result = [];
+        columns.forEach((_, index) => {
+          const newCol = new Column({
+            parentCssSelector: this.getFullCssSelector(),
+            index,
+            driver: this.driver
+          });
+          result.push(newCol);
+        });
+        return result;
+      }
+      element() {
+        return this.getElement();
+      }
+      /**
+       * Находит поле когда форма находится в состоянии редактирования
+       * @example
+       * const form = new MyForm();
+       * //...
+       * expect(await form.field('Name').getValue()).toBe('test value');
+       */
+      field(name) {
+        return new FormField(this.getFullCssSelector(), this.formName, name, this.driver);
+      }
+    };
   }
-};
-
-// src/pageObjects/elements/Groups/Panel.ts
-var Panel = class extends AbstractGroup {
-};
-
-// src/pageObjects/elements/Groups/groupFactory.ts
-var groupFactory = async (parentCssSelector, elementCssSelector, driver) => {
-  const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
-  const classSting = await elementInstance.getClasses();
-  if (classSting.includes("panel-group"))
-    return new Panel(parentCssSelector, elementCssSelector, driver);
-  throw new Error("Unknown type of group. Please write ticket to the support");
-};
+});
 
-// src/pageObjects/elements/FormGroup.ts
-var FormGroup = class extends AbstractElementWithParent {
-  editor;
-  constructor(parentCssSelector, formName, name, driver) {
-    super(parentCssSelector, byTestIdCssSelector(createGroupTestId(formName, name)), driver);
-  }
-  async initEditor() {
-    if (!this.editor) {
-      this.editor = await groupFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
-    }
+// src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts
+var ToolbarGroupButton;
+var init_ToolbarGroupButton = __esm({
+  "src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts"() {
+    "use strict";
+    init_AbstractButton();
+    ToolbarGroupButton = class extends AbstractButton {
+      name;
+      constructor(parentCssSelector, name, driver) {
+        super(parentCssSelector, ``, driver);
+        this.name = name;
+      }
+      buttonNotDisplayedError() {
+        return `Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
+      }
+    };
   }
-  /**
-   * Возвращает булевое значение доступна ли группа
-   * @example
-   * expect(await tableList.group('MainSuperPanel').isDisplayed();
-   */
-  async isDisplayed() {
-    try {
-      await this.initEditor();
-      return this.editor.isDisplayed();
-    } catch {
-      return false;
-    }
+});
+
+// src/pageObjects/elements/TableToolbar/ToolbarButton.ts
+var TOOLBAR_BUTTON_CLASS, ToolbarButton;
+var init_ToolbarButton = __esm({
+  "src/pageObjects/elements/TableToolbar/ToolbarButton.ts"() {
+    "use strict";
+    init_AbstractButton();
+    TOOLBAR_BUTTON_CLASS = "toolbar-button";
+    ToolbarButton = class extends AbstractButton {
+      name;
+      constructor(parentCssSelector, name, driver) {
+        super(parentCssSelector, `#${TOOLBAR_BUTTON_CLASS}-${name}`, driver);
+        this.name = name;
+      }
+      buttonNotDisplayedError() {
+        return `Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
+      }
+    };
   }
-};
+});
 
-// src/pageObjects/elements/Forms/FormEdit.ts
-var FormEdit = class extends AbstractForm {
-  saveButtonBy = import_selenium_webdriver17.By.id("button-save");
-  closeButtonBy = import_selenium_webdriver17.By.id("button-cancel");
-  constructor(driver) {
-    super(driver);
-    this.popupContainerCssSelector = `.popup .form-edit-${this.formName}`;
+// src/utils/typesUtil.ts
+var types, type, isArray, isString;
+var init_typesUtil = __esm({
+  "src/utils/typesUtil.ts"() {
+    "use strict";
+    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";
+    };
   }
-  /**
-   * Находит поле формы редактирования по имени
-   * @example
-   * const formEdit = new MyForm();
-   * //...
-   * expect(await formEdit.field('Name').getValue()).toBe('test value');
-   */
-  field(name) {
-    return new FormField(this.containerCssSelector, this.formName, name, this.driver);
+});
+
+// src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
+var import_selenium_webdriver22, SPINDOWN_CLASS, buttonGroupItemSelector, getFullCssSelector, buttonByTextXpath, ToolbarMenu;
+var init_ToolbarMenu = __esm({
+  "src/pageObjects/elements/TableToolbar/ToolbarMenu.ts"() {
+    "use strict";
+    import_selenium_webdriver22 = require("selenium-webdriver");
+    init_typesUtil();
+    init_AbstractElementWithParent();
+    init_locators();
+    init_actions();
+    init_waitElementIsClickable();
+    init_fixElementStaleError();
+    SPINDOWN_CLASS = ".dx-icon-spindown";
+    buttonGroupItemSelector = (formName, name) => byTestIdCssSelector(`ftb-${formName}-${name}`);
+    getFullCssSelector = (formName, name) => `${buttonGroupItemSelector(formName, name)} ${SPINDOWN_CLASS}`;
+    buttonByTextXpath = (text) => `.//span[contains(@class, "dx-menu-item-text") and contains(text(), "${text}")]`;
+    ToolbarMenu = class extends AbstractElementWithParent {
+      _formName;
+      constructor(parentCssSelector, formName, name, driver) {
+        super(parentCssSelector, getFullCssSelector(formName, name), driver);
+        this._formName = formName;
+      }
+      async openDropdownMenu() {
+        const dropdown = await this.getElement();
+        await click(dropdown, this.driver);
+      }
+      getCssSelectorToButton(name) {
+        return byTestId(`ftb-${this._formName}-${name}`);
+      }
+      buttonNotDisplayedError(name) {
+        return `Toolbar menu button ${name} cannot be clicked. It is not displayed or it is disabled`;
+      }
+      async goToButton(name, by) {
+        const toolbarMenuItem = await fixElementStaleError(by, this.driver);
+        await waitElementIsClickable({
+          element: toolbarMenuItem,
+          errorMessage: this.buttonNotDisplayedError(name),
+          driver: this.driver
+        });
+        await click(toolbarMenuItem, this.driver);
+      }
+      async clickButton(name) {
+        await this.openDropdownMenu();
+        if (!isString(name) && !isArray(name))
+          throw new Error(`"name" must be a string or array of string`);
+        let lName = isString(name) ? [name] : name;
+        for (let n of lName) {
+          await this.goToButton(n, this.getCssSelectorToButton(n));
+        }
+      }
+      async clickButtonByTitle(title) {
+        await this.openDropdownMenu();
+        if (!isString(title) && !isArray(title))
+          throw new Error(`"title" must be a string or array of string`);
+        let lTitle = isString(title) ? [title] : title;
+        for (let t of lTitle) {
+          await this.goToButton(t, import_selenium_webdriver22.By.xpath(buttonByTextXpath(t)));
+        }
+      }
+    };
   }
-  /**
-   * Проверяет не отключена ли кнопка Сохранить
-   * @example
-   * const formEdit = new MyForm();
-   * //...
-   * await formEdit.isSaveButtonDisabled();
-   */
-  async isSaveButtonDisabled() {
-    const saveButton = await this.driver.findElement(this.saveButtonBy);
-    const result = await saveButton.getAttribute("aria-disabled");
-    return result === "true";
+});
+
+// src/pageObjects/elements/TableToolbar/ToolbarItem.ts
+var GROUP_BUTTON_CLASS, toolbarItemSelector, ToolbarItem;
+var init_ToolbarItem = __esm({
+  "src/pageObjects/elements/TableToolbar/ToolbarItem.ts"() {
+    "use strict";
+    init_AbstractElementWithParent();
+    init_ToolbarGroupButton();
+    init_ToolbarButton();
+    init_locators();
+    init_ToolbarMenu();
+    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);
+        this._itemName = itemName;
+        this._formName = formName;
+      }
+      async init() {
+        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);
+          return;
+        }
+        this._button = new ToolbarButton(this.parentCssSelector, this._itemName, this.driver);
+      }
+      async click() {
+        await this.init();
+        await this._button.click();
+      }
+      async isDisabled() {
+        await this.init();
+        return await this._button.isDisabled();
+      }
+      get menu() {
+        return new ToolbarMenu(this.parentCssSelector, this._formName, this._itemName, this.driver);
+      }
+    };
   }
-  /**
-   * Находит группу формы редактирования по имени
-   * @example
-   * const formEdit = new MyForm();
-   * //...
-   * expect(await formEdit.group('Name');
-   */
-  group(name) {
-    return new FormGroup(this.containerCssSelector, this.formName, name, this.driver);
+});
+
+// src/pageObjects/elements/TableToolbar/FormToolbar.ts
+var TABLE_TOOLBAR_CLASS, FormToolbar;
+var init_FormToolbar = __esm({
+  "src/pageObjects/elements/TableToolbar/FormToolbar.ts"() {
+    "use strict";
+    init_AbstractElementWithParent();
+    init_ToolbarItem();
+    TABLE_TOOLBAR_CLASS = "d5-table-toolbar";
+    FormToolbar = class extends AbstractElementWithParent {
+      formName;
+      constructor(parentCssSelector, formName, driver) {
+        super(parentCssSelector, `#${TABLE_TOOLBAR_CLASS}-${formName}`, driver);
+        this.formName = formName;
+      }
+      button(name) {
+        return new ToolbarItem(this.getFullCssSelector(), this.formName, name, this.driver);
+      }
+    };
   }
-  /**
-   * Нажатие на кнопку Сохранить
-   * @example
-   * const formEdit = new MyForm();
-   * //...
-   * await formEdit.saveButtonClick();
-   */
-  async saveButtonClick() {
-    const saveButton = await this.driver.findElement(this.saveButtonBy);
-    await wait(async () => !await this.isSaveButtonDisabled(), this.driver, "Button is disabled");
-    await click(saveButton, this.driver);
+});
+
+// src/pageObjects/elements/Filters/FormFilterField.ts
+var FormFilterField;
+var init_FormFilterField = __esm({
+  "src/pageObjects/elements/Filters/FormFilterField.ts"() {
+    "use strict";
+    init_locators();
+    init_createDataTestId();
+    init_AbstractEditor2();
+    FormFilterField = class extends AbstractEditor {
+      constructor(parentCssSelector, formName, name, driver) {
+        super(parentCssSelector, byTestIdCssSelector(createLayoutFilterTestId(formName, name)), driver);
+      }
+      /**
+       * Возвращает значение в поле
+       * @example
+       * expect(await form.formFilter('NumberFld').getValue()).toBe(10);
+       * expect(await form.formFilter('TextFld').getValue()).toBe('TestValue');
+       */
+      async getValue() {
+        return super.getValue();
+      }
+      /**
+       * Устанавливает значение в поле
+       * @example
+       * await form.formFilter('NumberFld').setValue(123);
+       * await form.formFilter('TextFld').setValue('TestValue');
+       */
+      async setValue(value) {
+        return super.setValue(value);
+      }
+      /**
+       * Очищает значение в поле
+       * @example
+       * await form.formFilter('NumberFld').clear();
+       */
+      async clear() {
+        return super.clear();
+      }
+      /**
+       * Удаляет тег по переданному тексту
+       * @example
+       * await form.formFilter('TagBox').remove('test');
+       */
+      async remove(itemText) {
+        return super.remove(itemText);
+      }
+    };
   }
-  /**
-   * Нажатие на кнопку Закрить
-   * @example
-   * const formEdit = new MyForm();
-   * //...
-   * await formEdit.closeButtonClick();
-   */
-  async closeButtonClick() {
-    const closeButton = await this.driver.findElement(this.closeButtonBy);
-    await click(closeButton, this.driver);
+});
+
+// src/pageObjects/elements/Filters/PanelFilterField.ts
+var PanelFilterField;
+var init_PanelFilterField = __esm({
+  "src/pageObjects/elements/Filters/PanelFilterField.ts"() {
+    "use strict";
+    init_locators();
+    init_createDataTestId();
+    init_AbstractEditor2();
+    PanelFilterField = class extends AbstractEditor {
+      constructor(parentCssSelector, formName, name, driver) {
+        super(parentCssSelector, byTestIdCssSelector(createDocFilterTestId(formName, name)), driver);
+      }
+      /**
+       * Возвращает значение в поле
+       * @example
+       * expect(await form.filterPanel.filterField('NumberFld').getValue()).toBe(10);
+       * expect(await form.filterPanel.filterField('TextFld').getValue()).toBe('TestValue');
+       */
+      async getValue() {
+        return super.getValue();
+      }
+      /**
+       * Устанавливает значение в поле
+       * @example
+       * await form.filterPanel.filterField('NumberFld').setValue(123);
+       * await form.filterPanel.filterField('TextFld').setValue('TestValue');
+       */
+      async setValue(value) {
+        return super.setValue(value);
+      }
+      /**
+       * Очищает значение в поле
+       * @example
+       * await form.filterPanel.filterField('NumberFld').clear();
+       */
+      async clear() {
+        return super.clear();
+      }
+      /**
+       * Удаляет тег по переданному тексту
+       * @example
+       * await form.filterPanel.filterField('TagBox').remove('test');
+       */
+      async remove(itemText) {
+        return super.remove(itemText);
+      }
+    };
   }
-};
+});
 
-// src/pageObjects/elements/Table/Table.ts
-var import_selenium_webdriver22 = require("selenium-webdriver");
+// src/pageObjects/elements/Filters/FilterPanel.ts
+var import_selenium_webdriver23, drawerSelector, FILTER_PANEL_SELECTOR, CLOSE_SELECTOR, FilterPanel;
+var init_FilterPanel = __esm({
+  "src/pageObjects/elements/Filters/FilterPanel.ts"() {
+    "use strict";
+    import_selenium_webdriver23 = 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";
+    FilterPanel = class extends AbstractElement {
+      _formName;
+      get filterPanelSelector() {
+        return `${this.elementCssSelector} ${FILTER_PANEL_SELECTOR}`;
+      }
+      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_webdriver23.By.css(selector));
+      }
+      constructor(formName, driver) {
+        super(driver, drawerSelector(formName));
+        this._formName = formName;
+      }
+      /**
+       * Возвращает фильтр на панели фильтрации
+       * @returns {PanelFilterField}
+       * @example
+       * await form.filterPanel.filterField('NumberFld');
+       */
+      filterField(name) {
+        return new PanelFilterField(this.filterPanelSelector, this._formName, name, this.driver);
+      }
+      async apply() {
+        const btn = await this.findButtonByTitle("\u0417\u0430\u0441\u0442\u043E\u0441\u0443\u0432\u0430\u0442\u0438");
+        await click(btn, this.driver);
+      }
+      async findButtonByTitle(title) {
+        const buttons = await this.filterPanelButtons();
+        for (const btn of buttons) {
+          if (await btn.getText() === 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);
+      }
+      async close() {
+        const btn = await this.driver.findElement(import_selenium_webdriver23.By.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
+        await click(btn, this.driver);
+      }
+    };
+  }
+});
 
-// src/pageObjects/elements/Table/elements/Row.ts
-var import_selenium_webdriver20 = require("selenium-webdriver");
+// src/pageObjects/elements/Forms/ListForm.ts
+var ListForm_exports = {};
+__export(ListForm_exports, {
+  default: () => ListForm
+});
+var DATAGRID_HEADER_CSS_SELECTOR, ListForm;
+var init_ListForm = __esm({
+  "src/pageObjects/elements/Forms/ListForm.ts"() {
+    "use strict";
+    init_Form();
+    init_Table();
+    init_FormToolbar();
+    init_FormFilterField();
+    init_FilterPanel();
+    DATAGRID_HEADER_CSS_SELECTOR = ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
+    ListForm = class extends Form {
+      headerCssSelector;
+      constructor(driver) {
+        super(driver);
+        this.popupContainerCssSelector = `.popup .form-inline-${this.formName}`;
+        this.headerCssSelector = DATAGRID_HEADER_CSS_SELECTOR;
+      }
+      /**
+       * Находит таблицу
+       * @example
+       * const listForm = new MyForm();
+       * //...
+       * expect(listForm.table());
+       */
+      table() {
+        return new Table(this.containerCssSelector, this.headerCssSelector, this.formName, this.driver);
+      }
+      /**
+       * Находит таблицу
+       * @example
+       * const listForm = new MyForm();
+       * //...
+       * expect(listForm.toolbarButton());
+       */
+      toolbarButton(name) {
+        const toolbar = new FormToolbar(this.containerCssSelector, this.formName, this.driver);
+        return toolbar.button(name);
+      }
+      /**
+       * Фильтр который расположен на форме
+       * @example
+       * const listForm = new MyForm();
+       * //...
+       * expect(listForm.formFilter());
+       */
+      formFilter(name) {
+        return new FormFilterField(this.containerCssSelector, this.formName, name, this.driver);
+      }
+      /**
+       * Модель панели фильтрации
+       * @returns {FilterPanel}
+       * @example
+       * const listForm = new MyForm();
+       * //...
+       * expect(listForm.filterPanel());
+       */
+      get filterPanel() {
+        return new FilterPanel(this.formName, this.driver);
+      }
+    };
+  }
+});
 
-// src/pageObjects/elements/Table/elements/Cell.ts
-var import_selenium_webdriver19 = require("selenium-webdriver");
+// src/pageObjects/elements/Forms/TreeView.ts
+var TreeView_exports = {};
+__export(TreeView_exports, {
+  default: () => TreeView
+});
+var TREELIST_HEADER_CSS_SELECTOR, TreeView;
+var init_TreeView = __esm({
+  "src/pageObjects/elements/Forms/TreeView.ts"() {
+    "use strict";
+    init_ListForm();
+    TREELIST_HEADER_CSS_SELECTOR = ".dx-treelist-headers .dx-treelist-content:not(.dx-datagrid-content-fixed)";
+    TreeView = class extends ListForm {
+      constructor(driver) {
+        super(driver);
+        this.popupContainerCssSelector = `.popup .wrapper-tree-view-${this.formName}`;
+        this.headerCssSelector = TREELIST_HEADER_CSS_SELECTOR;
+      }
+    };
+  }
+});
 
-// src/pageObjects/elements/Table/utils.ts
-var import_selenium_webdriver18 = require("selenium-webdriver");
-function getCssRowByIndexSelector(index) {
-  return `tr[aria-rowindex="${transformInputIndex(index)}"]`;
+// src/pageObjects/elements/Forms/createSubFormInstance.ts
+function subformCssSelector(parentCssSelector, testId) {
+  return `${parentCssSelector} ${byTestIdCssSelector(testId)}`;
 }
-var getColumnByIndexCssSelector = (columnIndex) => `td[aria-colindex="${transformInputIndex(columnIndex)}"]`;
-var getColumnByCaptionCssSelector = (caption) => `td[role="columnheader"][aria-label="Column ${caption}"]`;
-var getColumnByNameCssSelector = (name) => `td[role="columnheader"][data-fieldname="${name}"]`;
-function getCssCellByIndexSelector(index) {
-  return `td[role="gridcell"][aria-colindex="${transformInputIndex(index)}"]`;
+async function classDependencyInjector(formType) {
+  let SubFormFactoryClass;
+  switch (formType) {
+    case "1" /* LIST */:
+      SubFormFactoryClass = (await Promise.resolve().then(() => (init_ListForm(), ListForm_exports))).default;
+      break;
+    case "3" /* TREE */:
+      SubFormFactoryClass = (await Promise.resolve().then(() => (init_TreeView(), TreeView_exports))).default;
+      break;
+    case "2" /* EDIT */:
+    case "99" /* FREE_FORM */:
+    case "4" /* REPORT */:
+      SubFormFactoryClass = (await Promise.resolve().then(() => (init_FormEdit(), FormEdit_exports))).default;
+      break;
+    default:
+      throw new Error(`Unsupported form type ${formType}`);
+  }
+  return SubFormFactoryClass;
 }
-var transformInputIndex = (index) => index + 1;
-var transformOutputIndex = (index) => +index - 1;
-
-// src/pageObjects/elements/Table/elements/Cell.ts
-var Cell = class extends AbstractElementWithParent {
-  _index;
-  getCellIndex;
-  constructor(parentCssSelector, getCellIndex, index, driver) {
-    super(parentCssSelector, getCssCellByIndexSelector(index), driver);
-    this.getCellIndex = getCellIndex;
-    this._index = index;
-  }
-  set index(index) {
-    this._index = index;
-    this.elementCssSelector = getCssCellByIndexSelector(index);
-  }
-  async getBooleanValue(cellEl) {
-    const booleanEl = await cellEl.findElement(import_selenium_webdriver19.By.className("boolean-widget"));
-    return await booleanEl.getAttribute("aria-checked") === "true" ? 1 : 0;
-  }
-  async getTagsValue(cellEl) {
-    const tagsCssSelector = ".multiselect-container .multiselect-cell";
-    const tags = await cellEl.findElements(import_selenium_webdriver19.By.css(tagsCssSelector));
-    const values = [];
-    for (const tag of tags) {
-      values.push(await tag.getAttribute("textContent"));
-    }
-    return values;
-  }
-  async getElement() {
-    if (this._index == null) {
-      this.index = await this.getCellIndex();
-    }
-    return super.getElement();
-  }
-  async getValue() {
-    const cellEl = await this.getElement();
-    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);
-    return cellEl.getText();
+var subFormTestId;
+var init_createSubFormInstance = __esm({
+  "src/pageObjects/elements/Forms/createSubFormInstance.ts"() {
+    "use strict";
+    init_locators();
+    init_types();
+    subFormTestId = (name) => `subform-${name}`;
   }
-  getIndex() {
-    return this._index;
-  }
-};
+});
 
-// src/pageObjects/elements/Table/elements/Row.ts
-var DX_SELECTION_CLASS = "dx-selection";
-var DX_ROW_EDIT_CLASS = "dx-edit-row";
-var DX_DATA_ROW_CLASS = "dx-data-row";
-var Row = class extends AbstractElementWithParent {
-  index;
-  getColumnBy;
-  constructor(parentCssSelector, index, driver, getColumnBy) {
-    super(parentCssSelector, getCssRowByIndexSelector(index), driver);
-    this.index = index;
-    this.getColumnBy = getColumnBy;
-  }
-  _getCell({ index, name, title }) {
-    return new Cell(
-      this.getFullCssSelector(),
-      () => {
-        return this.getColumnBy({ title, name }).getIndex();
-      },
-      index,
-      this.driver
-    );
-  }
-  getCellByIndex(index) {
-    return this._getCell({ index });
-  }
-  getCell(name) {
-    return this._getCell({ name });
-  }
-  getCellByTitle(title) {
-    return this._getCell({ title });
-  }
-  async select() {
-    const rowEl = await this.getElement();
-    await click(rowEl, this.driver);
-    await wait(
-      async () => {
-        const classes = await this.getClasses();
-        return classes.includes(DX_SELECTION_CLASS);
-      },
-      this.driver,
-      "Cannot select row"
-    );
-  }
-  async isSelected() {
-    const result = await this.getAttribute("aria-selected");
-    return result === "true";
-  }
-  getIndex() {
-    return this.index;
-  }
-  async getCells() {
-    const cells = await this.driver.findElements(import_selenium_webdriver20.By.css(`${this.getFullCssSelector()} td[role="gridcell"]`));
-    const result = [];
-    cells.forEach((_, index) => {
-      const newCell = this.getCellByIndex(index);
-      result.push(newCell);
-    });
-    return result;
-  }
-  async clickInlineButton(buttonClass) {
-    const FIXED_TABLE_CSS_SELECTOR = ".dx-fixed-columns .dx-datagrid-content.dx-datagrid-content-fixed";
-    const buttonCssSelector = `.${DX_DATA_ROW_CLASS}[aria-rowindex="${transformInputIndex(
-      this.index
-    )}"] .${buttonClass}`;
-    const button = await this.driver.findElement(
-      import_selenium_webdriver20.By.css(`${this.parentCssSelector} ${FIXED_TABLE_CSS_SELECTOR} ${buttonCssSelector}`)
-    );
-    return click(button, this.driver);
-  }
-  async checkEditingMode(isEditing, msg) {
-    await wait(
-      async () => {
-        return (await this.getClasses()).includes(DX_ROW_EDIT_CLASS) === isEditing;
-      },
-      this.driver,
-      msg
-    );
-  }
-  async edit() {
-    await this.clickInlineButton("edit");
-    await this.checkEditingMode(true, "Row did not switch to edit mode");
-  }
-  async save() {
-    await this.clickInlineButton("save");
-    await this.checkEditingMode(false, "Row did not saved");
-  }
-  async cancel() {
-    await this.clickInlineButton("cancel");
-    await this.checkEditingMode(false, "Row did not switch to normal mode");
+// src/pageObjects/elements/Forms/Form.ts
+var import_selenium_webdriver24, formTestId, Form;
+var init_Form = __esm({
+  "src/pageObjects/elements/Forms/Form.ts"() {
+    "use strict";
+    init_locators();
+    import_selenium_webdriver24 = require("selenium-webdriver");
+    init_AbstractForm();
+    init_waitElementIsVisible();
+    init_createSubFormInstance();
+    formTestId = (formName) => `form-content-wrapper-${formName}`;
+    Form = class extends AbstractForm {
+      popupContainerCssSelector;
+      constructor(driver) {
+        super(driver);
+        this.setSubFormMode();
+      }
+      async isModal() {
+        const el = await this.getContainerElement();
+        const value = await el.getAttribute("data-ismodal");
+        return value === "true";
+      }
+      /**
+       * Получение заголовка на формы
+       * @example
+       * const listForm = new MyForm();
+       * //...
+       * expect(await listForm.getTitleText()).toBe('MyFormTitle');
+       */
+      async getTitleText() {
+        if (await this.isModal()) {
+          const titleEl2 = await this.driver.findElement(import_selenium_webdriver24.By.css(`${this.popupContainerCssSelector} .popup-title`));
+          return titleEl2.getText();
+        }
+        let titleEl = await this.driver.findElement(import_selenium_webdriver24.By.className("main-toolbar-form-title"));
+        return titleEl.getText();
+      }
+      setSubFormMode() {
+        const testId = formTestId(this.formName);
+        this.containerBy = byTestId(testId);
+        this.containerCssSelector = byTestIdCssSelector(testId);
+      }
+      /**
+       * Возвращает сабформу
+       * @returns {Promise<ListForm | TreeView | FormEdit>}
+       * @example
+       * const form = new MyForm();
+       * //...
+       * expect(await form.subForm(name));
+       */
+      async subForm(name) {
+        const cssSelector = subformCssSelector(this.containerCssSelector, subFormTestId(name));
+        const byCssSelector = import_selenium_webdriver24.By.css(cssSelector);
+        const subFormEl = await this.driver.findElement(byCssSelector);
+        await waitElementIsVisible({
+          element: subFormEl,
+          driver: this.driver,
+          errorMessage: `Subform "${name}" is not visible`
+        });
+        const formType = await subFormEl.getAttribute("data-formtype");
+        const formName = await subFormEl.getAttribute("data-formname");
+        let SubFormFactoryClass = await classDependencyInjector(formType);
+        const SubForm = class extends SubFormFactoryClass {
+          setSubFormMode() {
+            this.containerCssSelector = cssSelector;
+            this.containerBy = byCssSelector;
+          }
+          get formName() {
+            return formName;
+          }
+        };
+        return new SubForm(this.driver);
+      }
+    };
   }
-};
+});
 
-// src/pageObjects/elements/Table/elements/Column.ts
-var import_selenium_webdriver21 = require("selenium-webdriver");
-var Column = class extends AbstractElementWithParent {
-  _index;
-  _caption;
-  _name;
-  headerCssSelector;
-  constructor({ parentCssSelector, headerCssSelector, name, caption, index, driver }) {
-    super(parentCssSelector, "", driver);
-    this._name = name;
-    this.index = index;
-    this._caption = caption;
-    this.headerCssSelector = headerCssSelector;
-  }
-  set index(index) {
-    this._index = index;
-    this.elementCssSelector = getColumnByIndexCssSelector(index);
-  }
-  get index() {
-    return this._index;
-  }
-  async getElement() {
-    await this.getIndex();
-    return super.getElement();
-  }
-  async getColumnHeaderIndexBy(cssSelector) {
-    const column = await this.driver.findElement(
-      import_selenium_webdriver21.By.css(`${this.parentCssSelector} ${this.headerCssSelector} ${cssSelector}`)
-    );
-    return transformOutputIndex(await column.getAttribute("aria-colindex"));
-  }
-  async getIndexByCaption() {
-    return this.getColumnHeaderIndexBy(getColumnByCaptionCssSelector(this._caption));
-  }
-  async getIndexByName() {
-    return this.getColumnHeaderIndexBy(getColumnByNameCssSelector(this._name));
-  }
-  async caption() {
-    const el = await this.getElement();
-    return el.getText();
-  }
-  async getIndex() {
-    if (this.index != null) {
-      return this.index;
-    }
-    if (this._caption != null) {
-      this.index = await this.getIndexByCaption();
-      return this.index;
-    }
-    if (this._name != null) {
-      this.index = await this.getIndexByName();
-      return this.index;
-    }
-    throw new Error("Cant get the index in the column");
+// src/pageObjects/elements/Forms/FormEdit.ts
+var FormEdit_exports = {};
+__export(FormEdit_exports, {
+  default: () => FormEdit
+});
+var import_selenium_webdriver25, FormEdit;
+var init_FormEdit = __esm({
+  "src/pageObjects/elements/Forms/FormEdit.ts"() {
+    "use strict";
+    init_Form();
+    import_selenium_webdriver25 = require("selenium-webdriver");
+    init_FormField();
+    init_actions();
+    init_wait();
+    FormEdit = class extends Form {
+      saveButtonBy = import_selenium_webdriver25.By.id("button-save");
+      closeButtonBy = import_selenium_webdriver25.By.id("button-cancel");
+      constructor(driver) {
+        super(driver);
+        this.popupContainerCssSelector = `.popup .form-edit-${this.formName}`;
+      }
+      /**
+       * Находит поле формы редактирования по имени
+       * @example
+       * const formEdit = new MyForm();
+       * //...
+       * expect(await formEdit.field('Name').getValue()).toBe('test value');
+       */
+      field(name) {
+        return new FormField(this.containerCssSelector, this.formName, name, this.driver);
+      }
+      /**
+       * Проверяет не отключена ли кнопка Сохранить
+       * @example
+       * const formEdit = new MyForm();
+       * //...
+       * await formEdit.isSaveButtonDisabled();
+       */
+      async isSaveButtonDisabled() {
+        const saveButton = await this.driver.findElement(this.saveButtonBy);
+        const result = await saveButton.getAttribute("aria-disabled");
+        return result === "true";
+      }
+      /**
+       * Нажатие на кнопку Сохранить
+       * @example
+       * const formEdit = new MyForm();
+       * //...
+       * await formEdit.saveButtonClick();
+       */
+      async saveButtonClick() {
+        const saveButton = await this.driver.findElement(this.saveButtonBy);
+        await wait(async () => !await this.isSaveButtonDisabled(), this.driver, "Button is disabled");
+        await click(saveButton, this.driver);
+      }
+      /**
+       * Нажатие на кнопку Закрить
+       * @example
+       * const formEdit = new MyForm();
+       * //...
+       * await formEdit.closeButtonClick();
+       */
+      async closeButtonClick() {
+        const closeButton = await this.driver.findElement(this.closeButtonBy);
+        await click(closeButton, this.driver);
+      }
+    };
   }
-};
+});
 
-// src/pageObjects/elements/Table/Table.ts
-var Table = class extends AbstractElementWithParent {
-  formName;
-  headerCssSelector;
-  constructor(parentCssSelector, headerCssSelector, formName, driver) {
-    super(parentCssSelector, `#${createTableId(formName)}`, driver);
-    this.formName = formName;
-    this.headerCssSelector = headerCssSelector;
-  }
-  getColumnBy = (args) => {
-    if (args.title) {
-      return this.getColumnByTitle(args.title);
-    }
-    return this.getColumnByName(args.name);
-  };
-  getRowByIndex(index) {
-    return new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
-  }
-  getColumnByIndex(index) {
-    return new Column({
-      parentCssSelector: this.getFullCssSelector(),
-      driver: this.driver,
-      index
-    });
-  }
-  getColumnByTitle = (title) => {
-    return new Column({
-      parentCssSelector: this.getFullCssSelector(),
-      headerCssSelector: this.headerCssSelector,
-      caption: title,
-      driver: this.driver
-    });
-  };
-  getColumnByName = (name) => {
-    return new Column({
-      parentCssSelector: this.getFullCssSelector(),
-      headerCssSelector: this.headerCssSelector,
-      name,
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AbstractPage: () => AbstractPage,
+  ControlClass: () => ControlClass,
+  Dialog: () => Dialog,
+  FilterPanel: () => FilterPanel,
+  FormEdit: () => FormEdit,
+  FormField: () => FormField,
+  FormFilterField: () => FormFilterField,
+  ListForm: () => ListForm,
+  LoginPage: () => LoginPage,
+  NumberEditor: () => NumberEditor,
+  PanelFilterField: () => PanelFilterField,
+  ReportForm: () => ReportForm,
+  SubsystemsPanel: () => SubsystemsPanel,
+  TextEditor: () => TextEditor,
+  TreeView: () => TreeView,
+  byTestId: () => byTestId,
+  byTestIdCssSelector: () => byTestIdCssSelector,
+  click: () => click,
+  config: () => config,
+  createDriver: () => createDriver,
+  editorFactory: () => editorFactory,
+  elementIsNotPresent: () => elementIsNotPresent,
+  readonlyLocator: () => readonlyLocator,
+  signIn: () => signIn,
+  wait: () => wait,
+  waitElementIsVisible: () => waitElementIsVisible
+});
+module.exports = __toCommonJS(src_exports);
+init_config();
+
+// src/pageObjects/pages/LoginPage.ts
+init_AbstractPage();
+init_config();
+init_waitElementIsVisible();
+init_actions();
+init_locators();
+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({
+      element: login,
       driver: this.driver
     });
-  };
-  selectRowByIndex(index) {
-    return this.getRowByIndex(index).select();
-  }
-  async getRows() {
-    const rows = await this.driver.findElements(import_selenium_webdriver22.By.css(`${this.getFullCssSelector()} .dx-row.dx-data-row`));
-    const result = [];
-    rows.forEach((_, index) => {
-      const newRow = new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
-      result.push(newRow);
-    });
-    return result;
-  }
-  async getColumns() {
-    const columns = await this.driver.findElements(
-      import_selenium_webdriver22.By.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"]`)
-    );
-    const result = [];
-    columns.forEach((_, index) => {
-      const newCol = new Column({
-        parentCssSelector: this.getFullCssSelector(),
-        index,
-        driver: this.driver
-      });
-      result.push(newCol);
-    });
-    return result;
   }
-  element() {
-    return this.getElement();
+  get path() {
+    return LOGIN_PATH;
   }
-  /**
-   * Находит поле когда форма находится в состоянии редактирования
-   * @example
-   * const form = new MyForm();
-   * //...
-   * expect(await form.field('Name').getValue()).toBe('test value');
-   */
-  field(name) {
-    return new FormField(this.getFullCssSelector(), this.formName, name, this.driver);
+  async enterUsername(username) {
+    await this.driver.findElement(this.usernameField).sendKeys(username);
   }
-};
-
-// src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts
-var ToolbarGroupButton = class extends AbstractButton {
-  name;
-  constructor(parentCssSelector, name, driver) {
-    super(parentCssSelector, ``, driver);
-    this.name = name;
+  async enterPassword(password) {
+    await this.driver.findElement(this.passwordField).sendKeys(password);
   }
-  buttonNotDisplayedError() {
-    return `Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
+  async clickLoginButton() {
+    await click(await this.driver.findElement(this.loginButton), this.driver);
   }
-};
-
-// src/pageObjects/elements/TableToolbar/ToolbarButton.ts
-var TOOLBAR_BUTTON_CLASS = "toolbar-button";
-var ToolbarButton = class extends AbstractButton {
-  name;
-  constructor(parentCssSelector, name, driver) {
-    super(parentCssSelector, `#${TOOLBAR_BUTTON_CLASS}-${name}`, driver);
-    this.name = name;
+  async loginWith(username, password) {
+    await this.enterUsername(username);
+    await this.enterPassword(password);
+    await this.clickLoginButton();
   }
-  buttonNotDisplayedError() {
-    return `Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
+  async authorize() {
+    await this.loginWith(config().auth.login, config().auth.password);
   }
 };
 
-// src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
-var import_selenium_webdriver23 = require("selenium-webdriver");
+// src/index.ts
+init_locators();
 
-// src/utils/typesUtil.ts
-var types = {
-  "[object Array]": "array",
-  "[object Date]": "date",
-  "[object Object]": "object",
-  "[object String]": "string",
-  "[object Null]": "null"
-};
-var type = function(object) {
-  const typeOfObject = Object.prototype.toString.call(object);
-  return typeof object === "object" ? types[typeOfObject] || "object" : typeof object;
-};
-var isArray = function(value) {
-  return type(value) === "array";
-};
-var isString = function(object) {
-  return typeof object === "string";
+// src/utils/createDriver.ts
+var import_selenium_webdriver4 = require("selenium-webdriver");
+init_config();
+var createDriver = async (browser) => {
+  const driver = await new import_selenium_webdriver4.Builder().forBrowser(browser ?? config().browser).build();
+  const manage = driver.manage();
+  await manage.setTimeouts({ implicit: config().timeout });
+  await manage.window().maximize();
+  return driver;
 };
 
-// src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
-var SPINDOWN_CLASS = ".dx-icon-spindown";
-var buttonGroupItemSelector = (formName, name) => byTestIdCssSelector(`ftb-${formName}-${name}`);
-var getFullCssSelector = (formName, name) => `${buttonGroupItemSelector(formName, name)} ${SPINDOWN_CLASS}`;
-var buttonByTextXpath = (text) => `.//span[contains(@class, "dx-menu-item-text") and contains(text(), "${text}")]`;
-var ToolbarMenu = class extends AbstractElementWithParent {
-  _formName;
-  constructor(parentCssSelector, formName, name, driver) {
-    super(parentCssSelector, getFullCssSelector(formName, name), driver);
-    this._formName = formName;
-  }
-  async toggle() {
-    const dropdown = await this.getElement();
-    await click(dropdown, this.driver);
-  }
-  getCssSelectorToButton(name) {
-    return byTestId(`ftb-${this._formName}-${name}`);
-  }
-  buttonNotDisplayedError(name) {
-    return `Toolbar menu button ${name} cannot be clicked. It is not displayed or it is disabled`;
-  }
-  async goToButton(name, selector) {
-    const toolbarMenuItem = this.driver.findElement(selector);
-    await waitElementIsClickable({
-      element: toolbarMenuItem,
-      errorMessage: this.buttonNotDisplayedError(name),
-      driver: this.driver
-    });
-    await click(toolbarMenuItem, this.driver);
-  }
-  async clickButton(name) {
-    await this.toggle();
-    if (isString(name)) {
-      const selector = this.getCssSelectorToButton(name);
-      await this.goToButton(name, selector);
-    }
-    if (isArray(name)) {
-      for (let n of name) {
-        const selector = this.getCssSelectorToButton(n);
-        await this.goToButton(n, selector);
-      }
-    }
-  }
-  async clickButtonByTitle(title) {
-    await this.toggle();
-    if (isString(title)) {
-      const selector = import_selenium_webdriver23.By.xpath(buttonByTextXpath(title));
-      await this.goToButton(title, selector);
-    }
-    if (isArray(title)) {
-      for (let t of title) {
-        const selector = import_selenium_webdriver23.By.xpath(buttonByTextXpath(t));
-        await this.goToButton(t, selector);
-      }
-    }
-  }
+// 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/pageObjects/elements/TableToolbar/ToolbarItem.ts
-var GROUP_BUTTON_CLASS = "toolbar-group-button";
-var toolbarItemSelector = (form, name) => byTestIdCssSelector(`ftb-${form}-${name}`);
-var ToolbarItem = class extends AbstractElementWithParent {
-  _button;
-  _formName;
-  _itemName;
-  constructor(parentCssSelector, formName, itemName, driver) {
-    super(parentCssSelector, toolbarItemSelector(formName, itemName), driver);
-    this._itemName = itemName;
-    this._formName = formName;
-  }
-  async init() {
-    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);
-      return;
-    }
-    this._button = new ToolbarButton(this.parentCssSelector, this._itemName, this.driver);
-  }
-  async click() {
-    await this.init();
-    await this._button.click();
-  }
-  async isDisabled() {
-    await this.init();
-    return await this._button.isDisabled();
-  }
-  get menu() {
-    return new ToolbarMenu(this.parentCssSelector, this._formName, this._itemName, this.driver);
-  }
-};
+// src/index.ts
+init_waitElementIsVisible();
+init_wait();
 
-// src/pageObjects/elements/TableToolbar/FormToolbar.ts
-var TABLE_TOOLBAR_CLASS = "d5-table-toolbar";
-var FormToolbar = class extends AbstractElementWithParent {
-  formName;
-  constructor(parentCssSelector, formName, driver) {
-    super(parentCssSelector, `#${TABLE_TOOLBAR_CLASS}-${formName}`, driver);
-    this.formName = formName;
-  }
-  button(name) {
-    return new ToolbarItem(this.getFullCssSelector(), this.formName, name, this.driver);
-  }
-};
+// src/utils/signIn.ts
+init_config();
+async function signIn(driver) {
+  const webDriver = driver ?? await createDriver();
+  config().driver = webDriver;
+  const loginPage = new LoginPage(webDriver);
+  await loginPage.locate();
+  await loginPage.authorize();
+  return webDriver;
+}
 
-// src/pageObjects/elements/Filters/FormFilterField.ts
-var FormFilterField = class extends AbstractEditor {
-  constructor(parentCssSelector, formName, name, driver) {
-    super(parentCssSelector, byTestIdCssSelector(createLayoutFilterTestId(formName, name)), driver);
-  }
-  /**
-   * Возвращает значение в поле
-   * @example
-   * expect(await form.formFilter('NumberFld').getValue()).toBe(10);
-   * expect(await form.formFilter('TextFld').getValue()).toBe('TestValue');
-   */
-  async getValue() {
-    return super.getValue();
-  }
-  /**
-   * Устанавливает значение в поле
-   * @example
-   * await form.formFilter('NumberFld').setValue(123);
-   * await form.formFilter('TextFld').setValue('TestValue');
-   */
-  async setValue(value) {
-    return super.setValue(value);
-  }
-  /**
-   * Очищает значение в поле
-   * @example
-   * await form.formFilter('NumberFld').clear();
-   */
-  async clear() {
-    return super.clear();
-  }
-  /**
-   * Удаляет тег по переданному тексту
-   * @example
-   * await form.formFilter('TagBox').remove('test');
-   */
-  async remove(itemText) {
-    return super.remove(itemText);
-  }
-};
+// src/index.ts
+init_actions();
+init_AbstractPage();
 
-// src/pageObjects/elements/Filters/FilterPanel.ts
-var import_selenium_webdriver24 = require("selenium-webdriver");
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
+init_AbstractElement();
 
-// src/pageObjects/elements/Filters/PanelFilterField.ts
-var PanelFilterField = class extends AbstractEditor {
-  constructor(parentCssSelector, formName, name, driver) {
-    super(parentCssSelector, byTestIdCssSelector(createDocFilterTestId(formName, name)), driver);
-  }
-  /**
-   * Возвращает значение в поле
-   * @example
-   * expect(await form.filterPanel.filterField('NumberFld').getValue()).toBe(10);
-   * expect(await form.filterPanel.filterField('TextFld').getValue()).toBe('TestValue');
-   */
-  async getValue() {
-    return super.getValue();
-  }
-  /**
-   * Устанавливает значение в поле
-   * @example
-   * await form.filterPanel.filterField('NumberFld').setValue(123);
-   * await form.filterPanel.filterField('TextFld').setValue('TestValue');
-   */
-  async setValue(value) {
-    return super.setValue(value);
-  }
-  /**
-   * Очищает значение в поле
-   * @example
-   * await form.filterPanel.filterField('NumberFld').clear();
-   */
-  async clear() {
-    return super.clear();
-  }
-  /**
-   * Удаляет тег по переданному тексту
-   * @example
-   * await form.filterPanel.filterField('TagBox').remove('test');
-   */
-  async remove(itemText) {
-    return super.remove(itemText);
+// 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/Filters/FilterPanel.ts
-var drawerSelector = (formName) => `.secondary-drawer-side-panel.form-${formName}`;
-var FILTER_PANEL_SELECTOR = ".filter-panel";
-var CLOSE_SELECTOR = ".button-close";
-var FilterPanel = class extends AbstractElement {
-  _formName;
-  get filterPanelSelector() {
-    return `${this.elementCssSelector} ${FILTER_PANEL_SELECTOR}`;
-  }
-  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_webdriver24.By.css(selector));
-  }
-  constructor(formName, driver) {
-    super(driver, drawerSelector(formName));
-    this._formName = formName;
-  }
-  /**
-   * Возвращает фильтр на панели фильтрации
-   * @returns {PanelFilterField}
-   * @example
-   * await form.filterPanel.filterField('NumberFld');
-   */
-  filterField(name) {
-    return new PanelFilterField(this.filterPanelSelector, this._formName, name, this.driver);
-  }
-  async apply() {
-    const btn = await this.findButtonByTitle("\u0417\u0430\u0441\u0442\u043E\u0441\u0443\u0432\u0430\u0442\u0438");
-    await click(btn, this.driver);
-  }
-  async findButtonByTitle(title) {
-    const buttons = await this.filterPanelButtons();
-    for (const btn of buttons) {
-      if (await btn.getText() === 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);
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
+init_wait();
+init_locators();
+var SubsystemsPanel = class extends AbstractElement {
+  header;
+  constructor(driver) {
+    super(driver);
+    this.header = new SubsystemsPanelHeader("#aside", byTestIdCssSelector("subsystems-panel-title", "span"), this.driver);
   }
-  async close() {
-    const btn = await this.driver.findElement(import_selenium_webdriver24.By.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
-    await click(btn, this.driver);
+  async headerTitle() {
+    const title = await this.header.title();
+    await wait(async () => await title.getText() != "", this.driver);
+    return title.getText();
   }
 };
 
-// src/pageObjects/elements/Forms/ListForm.ts
-var DATAGRID_HEADER_CSS_SELECTOR = ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
-var ListForm = class extends AbstractForm {
-  headerCssSelector;
+// src/index.ts
+init_FormEdit();
+init_ListForm();
+init_TreeView();
+
+// src/pageObjects/elements/Forms/ReportForm.ts
+var import_selenium_webdriver26 = require("selenium-webdriver");
+init_FormEdit();
+var ReportForm = class extends FormEdit {
   constructor(driver) {
     super(driver);
-    this.popupContainerCssSelector = `.popup .form-inline-${this.formName}`;
-    this.headerCssSelector = DATAGRID_HEADER_CSS_SELECTOR;
+    this.popupContainerCssSelector = `.popup .form-report-${this.formName}`;
+    this.saveButtonBy = import_selenium_webdriver26.By.id("button-apply");
   }
   /**
-   * Находит таблицу
+   * Знаходить поле/фільтр у формі репорту за ім'ям
    * @example
-   * const listForm = new MyForm();
+   * const formReport = new MyForm();
    * //...
-   * expect(listForm.table());
+   * expect(await formReport.filterField('Name').getValue()).toBe('test value');
    */
-  table() {
-    return new Table(this.containerCssSelector, this.headerCssSelector, this.formName, this.driver);
-  }
-  /**
-   * Находит группу на лист форме по имени
-   * @example
-   * const formEdit = new MyForm();
-   * //...
-   * expect(await formEdit.group('Name');
-   */
-  group(name) {
-    return new FormGroup(this.containerCssSelector, this.formName, name, this.driver);
-  }
-  /**
-   * Находит таблицу
-   * @example
-   * const listForm = new MyForm();
-   * //...
-   * expect(listForm.toolbarButton());
-   */
-  toolbarButton(name) {
-    const toolbar = new FormToolbar(this.containerCssSelector, this.formName, this.driver);
-    return toolbar.button(name);
-  }
-  /**
-   * Фильтр который расположен на форме
-   * @example
-   * const listForm = new MyForm();
-   * //...
-   * expect(listForm.formFilter());
-   */
-  formFilter(name) {
-    return new FormFilterField(this.containerCssSelector, this.formName, name, this.driver);
-  }
-  /**
-   * Модель панели фильтрации
-   * @returns {FilterPanel}
-   * @example
-   * const listForm = new MyForm();
-   * //...
-   * expect(listForm.filterPanel());
-   */
-  get filterPanel() {
-    return new FilterPanel(this.formName, this.driver);
+  filterField(name) {
+    return super.field(name);
   }
 };
 
-// src/pageObjects/elements/Forms/TreeView.ts
-var TREELIST_HEADER_CSS_SELECTOR = ".dx-treelist-headers .dx-treelist-content:not(.dx-datagrid-content-fixed)";
-var TreeView = class extends ListForm {
-  constructor(driver) {
-    super(driver);
-    this.popupContainerCssSelector = `.popup .wrapper-tree-view-${this.formName}`;
-    this.headerCssSelector = TREELIST_HEADER_CSS_SELECTOR;
-  }
-};
+// src/index.ts
+init_Editors();
+init_FormField();
+init_FormFilterField();
+init_PanelFilterField();
+init_FilterPanel();
 
 // src/pageObjects/elements/Dialog.ts
-var import_selenium_webdriver25 = require("selenium-webdriver");
+init_AbstractElement();
+var import_selenium_webdriver27 = require("selenium-webdriver");
+init_AbstractButton();
 var DIALOG_CLASS = ".d5-dialog";
 var DIALOG_TITLE_CLASS = ".dialog__title";
 var DIALOG_TEXT_CLASS = ".dialog__text";
@@ -1851,7 +2643,7 @@ var DialogButton = class extends AbstractButton {
   }
   async getElement() {
     const panel = await super.getElement();
-    return panel.findElement(import_selenium_webdriver25.By.xpath(buttonByTextXpath2(this.text)));
+    return panel.findElement(import_selenium_webdriver27.By.xpath(buttonByTextXpath2(this.text)));
   }
   buttonNotDisplayedError() {
     return `Dialog button ${this.text} cannot be clicked. It is not displayed or it is disabled`;
@@ -1871,11 +2663,11 @@ var Dialog = class extends AbstractElement {
     return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_BUTTONS_PANEL_CLASS]);
   }
   async title() {
-    const el = await this.driver.findElement(import_selenium_webdriver25.By.css(this.titleSelector));
+    const el = await this.driver.findElement(import_selenium_webdriver27.By.css(this.titleSelector));
     return await el.getText();
   }
   async text() {
-    const el = await this.driver.findElement(import_selenium_webdriver25.By.css(this.textSelector));
+    const el = await this.driver.findElement(import_selenium_webdriver27.By.css(this.textSelector));
     return await el.getText();
   }
   button(text) {
@@ -1895,6 +2687,7 @@ var Dialog = class extends AbstractElement {
   LoginPage,
   NumberEditor,
   PanelFilterField,
+  ReportForm,
   SubsystemsPanel,
   TextEditor,
   TreeView,