d5-testing-library 1.5.0 → 1.7.0-alpha.0

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

@@ -275,126 +275,120 @@ var init_AbstractElementWithParent = __esm({
   }
 });
 
-// src/utils/createDataTestId.ts
-function createDataTestId(formName, itemType, itemName) {
-  return `${formName}-${itemType}-${itemName}`;
-}
-function createFieldTestId(formName, itemName) {
-  return createDataTestId(formName, "form_field" /* FORM_FIELD */, itemName);
-}
-function createGroupTestId(formName, itemName) {
-  return createDataTestId(formName, "group" /* GROUP */, itemName);
-}
-function createFilterTestId(formName, itemName, layout) {
-  return createDataTestId(formName, "filter" /* FILTER */, itemName) + `-${layout}`;
-}
-function createDocFilterTestId(formName, itemName) {
-  return createFilterTestId(formName, itemName, "dock-panel-filter" /* DOCK_PANEL */);
-}
-function createLayoutFilterTestId(formName, itemName) {
-  return createFilterTestId(formName, itemName, "layout-filter" /* LAYOUT */);
-}
-function createTableId(formName) {
-  return `${"table" /* TABLE */}-${formName}`;
-}
-function createFormButtonTestId(formName, itemName) {
-  return createDataTestId(formName, "button" /* BUTTON */, itemName);
-}
-var init_createDataTestId = __esm({
-  "src/utils/createDataTestId.ts"() {
+// 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/utils/waitElementIsClickable.ts
-async function waitElementIsClickable({
-  element,
-  timeout,
-  errorMessage,
-  driver
-}) {
-  driver = driver ?? config().driver;
-  await wait(async () => {
-    const isDisabled = await element.getCssValue("pointer-events") === "none";
-    return await element.isDisplayed() && !isDisabled;
-  }, driver, errorMessage, timeout ?? config().timeout);
-}
-var init_waitElementIsClickable = __esm({
-  "src/utils/waitElementIsClickable.ts"() {
+// src/pageObjects/elements/Editors/AbstractEditor.ts
+var import_selenium_webdriver7, AbstractDXEditorWithInput;
+var init_AbstractEditor = __esm({
+  "src/pageObjects/elements/Editors/AbstractEditor.ts"() {
     "use strict";
-    init_config();
-    init_wait();
+    import_selenium_webdriver7 = 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_webdriver7.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_webdriver7.Key.ENTER);
+      }
+      async clear() {
+        await this.clearStrategy.clear(this);
+      }
+    };
   }
 });
 
-// src/pageObjects/elements/TableToolbar/AbstractButton.ts
-var AbstractButton;
-var init_AbstractButton = __esm({
-  "src/pageObjects/elements/TableToolbar/AbstractButton.ts"() {
+// src/pageObjects/elements/Editors/TextEditor.ts
+var TextEditor;
+var init_TextEditor = __esm({
+  "src/pageObjects/elements/Editors/TextEditor.ts"() {
     "use strict";
-    init_AbstractElementWithParent();
-    init_actions();
-    init_waitElementIsClickable();
-    AbstractButton = class extends AbstractElementWithParent {
+    init_AbstractEditor();
+    init_InputClearStrategy();
+    TextEditor = class extends AbstractDXEditorWithInput {
       constructor(parentCssSelector, elementCssSelector, driver) {
         super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new InputClearStrategy());
       }
-      async click() {
-        const button = await this.getElement();
-        await waitElementIsClickable({
-          element: button,
-          errorMessage: this.buttonNotDisplayedError(),
-          driver: this.driver
-        });
-        await click(button, this.driver);
+      getValue() {
+        return this.getInputValue();
       }
-      async isDisabled() {
-        const button = await this.getElement();
-        return await button.getCssValue("pointer-events") === "none";
+      setValue(value) {
+        return this.setInputValue(value);
       }
     };
   }
 });
 
-// src/pageObjects/elements/DXComponents/DXButton.ts
-var import_selenium_webdriver7, DXButton;
-var init_DXButton = __esm({
-  "src/pageObjects/elements/DXComponents/DXButton.ts"() {
+// src/pageObjects/elements/Editors/NumberEditor.ts
+var NumberEditor;
+var init_NumberEditor = __esm({
+  "src/pageObjects/elements/Editors/NumberEditor.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();
+    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/FormButton.ts
-var FormButton;
-var init_FormButton = __esm({
-  "src/pageObjects/elements/FormButton.ts"() {
+// src/pageObjects/elements/Editors/types.ts
+var ControlClass;
+var init_types = __esm({
+  "src/pageObjects/elements/Editors/types.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`;
-      }
-    };
+    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 || {});
   }
 });
 
@@ -412,1117 +406,1260 @@ var init_AbstractFormElement = __esm({
   }
 });
 
-// src/pageObjects/elements/Groups/AbstractGroup.ts
-var AbstractGroup;
-var init_AbstractGroup = __esm({
-  "src/pageObjects/elements/Groups/AbstractGroup.ts"() {
+// src/pageObjects/elements/Editors/CheckBox.ts
+var CheckBox;
+var init_CheckBox = __esm({
+  "src/pageObjects/elements/Editors/CheckBox.ts"() {
     "use strict";
+    init_actions();
     init_AbstractElementWithParent();
-    AbstractGroup = class extends AbstractElementWithParent {
-      async isDisplayed() {
-        const groupElement = await this.getElement();
-        return await groupElement.isDisplayed();
+    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/Groups/Panel.ts
-var Panel;
-var init_Panel = __esm({
-  "src/pageObjects/elements/Groups/Panel.ts"() {
+// src/utils/xpathHelper.ts
+var XPathHelper;
+var init_xpathHelper = __esm({
+  "src/utils/xpathHelper.ts"() {
     "use strict";
-    init_AbstractGroup();
-    Panel = class extends AbstractGroup {
+    XPathHelper = class {
+      static getClassAndValueXpath(cssClass, value) {
+        return `div[contains(@class, '${cssClass}') and contains(.,'${value}')]`;
+      }
     };
   }
 });
 
-// src/pageObjects/elements/Groups/TabPanel/TabPanel.ts
-var import_selenium_webdriver8, getTabTestIdByName, TabPanel;
-var init_TabPanel = __esm({
-  "src/pageObjects/elements/Groups/TabPanel/TabPanel.ts"() {
+// src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts
+var import_selenium_webdriver8, DX_TEXTEDITOR_EMPTY, DX_CLEAR_BUTTON_AREA, ClearButtonStrategy;
+var init_ClearButtonStrategy = __esm({
+  "src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts"() {
     "use strict";
-    init_AbstractGroup();
     import_selenium_webdriver8 = require("selenium-webdriver");
-    init_locators();
-    getTabTestIdByName = (name) => `tab-caption-${name}`;
-    TabPanel = class extends AbstractGroup {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
+    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;
       }
-      _getTab(name) {
-        return this.driver.findElement(import_selenium_webdriver8.By.css(`${this.getFullCssSelector()} ${byTestIdCssSelector(getTabTestIdByName(name))}`));
+      async isEmptyEditorField() {
+        const editorContainer = await this._driver.findElement(import_selenium_webdriver8.By.css(this.editorContainerClass));
+        const classAttribute = await editorContainer.getAttribute("class");
+        return classAttribute.includes(DX_TEXTEDITOR_EMPTY);
       }
-      async tabClick(name) {
-        const tabEl = this._getTab(name);
-        await tabEl.click();
+      async clear() {
+        if (await this.isEmptyEditorField()) {
+          throw new Error("This field is already empty");
+        }
+        const clearBtnSelector = `${this.editorContainerClass} .${DX_CLEAR_BUTTON_AREA}`;
+        const clearBtn = await this._driver.findElement(import_selenium_webdriver8.By.css(clearBtnSelector));
+        await click(clearBtn, this._driver);
       }
     };
   }
 });
 
-// src/pageObjects/elements/Groups/groupFactory.ts
-var groupFactory;
-var init_groupFactory = __esm({
-  "src/pageObjects/elements/Groups/groupFactory.ts"() {
+// src/pageObjects/elements/Editors/SelectBoxEditor.ts
+var import_selenium_webdriver9, SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS, combinedValueXpath, dropDownOptionClick, SelectBoxEditor;
+var init_SelectBoxEditor = __esm({
+  "src/pageObjects/elements/Editors/SelectBoxEditor.ts"() {
     "use strict";
-    init_AbstractFormElement();
-    init_Panel();
-    init_TabPanel();
-    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("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;
-var init_FormGroup = __esm({
-  "src/pageObjects/elements/FormGroup.ts"() {
-    "use strict";
-    init_AbstractElementWithParent();
-    init_locators();
-    init_createDataTestId();
-    init_groupFactory();
-    FormGroup = class extends AbstractElementWithParent {
-      editor;
-      constructor(parentCssSelector, formName, name, driver) {
-        super(parentCssSelector, byTestIdCssSelector(createGroupTestId(formName, name)), driver);
+    init_AbstractEditor();
+    import_selenium_webdriver9 = 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_webdriver9.By.xpath(combinedValueXpath(optionValue)));
+        await click(optElement, driver);
+      } catch (e) {
+        err = new Error(`Item not found: "${optionValue}"`);
+      } finally {
+        await driver.manage().setTimeouts({ implicit });
       }
-      async initEditor() {
-        if (!this.editor) {
-          this.editor = await groupFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
-        }
+      if (err)
+        throw err;
+    };
+    SelectBoxEditor = class extends AbstractDXEditorWithInput {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), this.driver));
       }
-      /**
-       * Возвращает булевое значение доступна ли группа
-       * @example
-       * expect(await tableList.group('MainSuperPanel').isDisplayed();
-       */
-      async isDisplayed() {
+      async setSelectInputValue(value) {
+        const inputEl = await this.getInputElement();
+        await click(inputEl, this.driver);
         try {
-          await this.initEditor();
-          return this.editor.isDisplayed();
+          await dropDownOptionClick(value, this.driver, false);
         } catch {
-          return false;
+          await inputEl.sendKeys(value, import_selenium_webdriver9.Key.ENTER);
+          await dropDownOptionClick(value, this.driver);
         }
       }
-      /**
-       * Происходит клик по табе
-       * @example
-       * expect(await tableList.group('TabPanel').tabClick(tabName);
-       */
-      async tabClick(name) {
-        await this.initEditor();
-        await this.editor.tabClick(name);
+      async getValue() {
+        const value = await super.getInputValue();
+        return value == "" ? null : value;
+      }
+      setValue(value) {
+        return this.setSelectInputValue(value);
       }
     };
   }
 });
 
-// src/pageObjects/elements/Forms/AbstractForm.ts
-var AbstractForm;
-var init_AbstractForm = __esm({
-  "src/pageObjects/elements/Forms/AbstractForm.ts"() {
+// src/pageObjects/elements/Editors/SwitchEditor.ts
+var SwitchEditor;
+var init_SwitchEditor = __esm({
+  "src/pageObjects/elements/Editors/SwitchEditor.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;
+    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;
       }
-      /**
-       * Возвращает 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;
+      async setValue(value) {
+        if (value !== 0 && value !== 1) {
+          value = value ? 1 : 0;
         }
-      }
-      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);
+        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/Forms/types.ts
-var init_types = __esm({
-  "src/pageObjects/elements/Forms/types.ts"() {
-    "use strict";
-  }
-});
-
-// 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;
-  }
-});
-
-// src/pageObjects/elements/Table/types.ts
-var init_types2 = __esm({
-  "src/pageObjects/elements/Table/types.ts"() {
-    "use strict";
-  }
-});
-
-// src/pageObjects/elements/Table/elements/Cell.ts
-var import_selenium_webdriver10, Cell;
-var init_Cell = __esm({
-  "src/pageObjects/elements/Table/elements/Cell.ts"() {
+// src/pageObjects/elements/Editors/TagBox.ts
+var import_selenium_webdriver10, 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_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;
+    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));
       }
-      set index(index) {
-        this._index = index;
-        this.elementCssSelector = getCssCellByIndexSelector(index);
+      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 getBooleanValue(cellEl) {
-        const booleanEl = await cellEl.findElement(import_selenium_webdriver10.By.className("boolean-widget"));
-        return await booleanEl.getAttribute("aria-checked") === "true" ? 1 : 0;
+      async waitOptionSelection() {
+        await fixElementStaleError(import_selenium_webdriver10.By.css(TAG_BOX_LIST_ITEM_SELECTOR), this.driver);
       }
-      async getTagsValue(cellEl) {
-        const tagsCssSelector = ".multiselect-container .multiselect-cell";
-        const tags = await cellEl.findElements(import_selenium_webdriver10.By.css(tagsCssSelector));
+      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_webdriver10.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_webdriver10.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 getElement() {
-        if (this._index == null) {
-          this.index = await this.getCellIndex();
-        }
-        return super.getElement();
+      async isTagBoxEmpty() {
+        const classAttribute = await this.getClasses();
+        return classAttribute.includes(DX_TEXTEDITOR_EMPTY2);
       }
       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();
+        const value = await this.getTagBoxInputValue();
+        return value.length ? value : null;
       }
-      getIndex() {
-        return this._index;
+      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_webdriver10.By.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${clearBtnTestId}`)
+        );
+        await click(clearBtn, this.driver);
       }
     };
   }
 });
 
-// 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"() {
+// src/pageObjects/elements/Editors/ButtonGroup.ts
+var import_selenium_webdriver11, ITEM_CLASS, SELECTED_CLASS, ButtonGroup;
+var init_ButtonGroup = __esm({
+  "src/pageObjects/elements/Editors/ButtonGroup.ts"() {
     "use strict";
+    init_actions();
     import_selenium_webdriver11 = require("selenium-webdriver");
-    init_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
-        );
+    ITEM_CLASS = "dx-buttongroup-item";
+    SELECTED_CLASS = "dx-state-selected";
+    ButtonGroup = class extends AbstractElementWithParent {
+      getItems() {
+        return this.driver.findElements(import_selenium_webdriver11.By.css(`${this.getFullCssSelector()} .${ITEM_CLASS}`));
       }
-      getCellByIndex(index) {
-        return this._getCell({ index });
+      getDataValue(el) {
+        return el.getAttribute("data-value");
       }
-      getCell(name) {
-        return this._getCell({ name });
+      async getValue() {
+        const selectedEl = await this.driver.findElement(import_selenium_webdriver11.By.css(`${this.getFullCssSelector()} .${ITEM_CLASS}.${SELECTED_CLASS}`));
+        return this.getDataValue(selectedEl);
       }
-      getCellByTitle(title) {
-        return this._getCell({ title });
+      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);
       }
-      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"
-        );
+    };
+  }
+});
+
+// src/pageObjects/elements/Editors/BooleanSelector.ts
+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;
       }
-      async isSelected() {
-        const result = await this.getAttribute("aria-selected");
-        return result === "true";
+      // @ts-ignore
+      async setValue(value) {
+        const val = value == null ? "null" : value ? "1" : "0";
+        await super.setValue(val);
       }
-      getIndex() {
-        return this.index;
+    };
+  }
+});
+
+// src/pageObjects/elements/Editors/Date/utils.ts
+var formatDMYDate;
+var init_utils = __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 import_selenium_webdriver12, BTN_CALENDAR_POPOVER_OPEN_SELECTOR, BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR, BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR, BTN_SAVE_SELECTOR, BaseDateEditor;
+var init_BaseDateEditor = __esm({
+  "src/pageObjects/elements/Editors/Date/BaseDateEditor.ts"() {
+    "use strict";
+    init_AbstractEditor();
+    init_InputClearStrategy();
+    import_selenium_webdriver12 = require("selenium-webdriver");
+    init_locators();
+    init_actions();
+    init_utils();
+    BTN_CALENDAR_POPOVER_OPEN_SELECTOR = "calendar-popover-open-button";
+    BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR = "DateRange__inputs-item--dateFrom";
+    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 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 setDateValue(value) {
+        const actions = this.driver.actions({ async: true });
+        const dateField = await this.driver.findElement(import_selenium_webdriver12.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_webdriver12.By.css(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`));
+          await button.click();
+          const calendarPopoverElement = await this.driver.findElement(import_selenium_webdriver12.By.css(calendarPopoverSelector));
+          const dateFromInput = await calendarPopoverElement.findElement(import_selenium_webdriver12.By.css(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .dx-texteditor-input`));
+          const dateToInput = await calendarPopoverElement.findElement(import_selenium_webdriver12.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_webdriver12.Key.HOME).perform();
+          await dateToInput.sendKeys(formattedDates[1]);
+          await actions.move({ origin: dateInputEl }).sendKeys(import_selenium_webdriver12.Key.ENTER).perform();
+          const btnOk = await this.driver.findElement(import_selenium_webdriver12.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_webdriver12.Key.HOME).perform();
+          await actions.move({ origin: dateInputEl }).sendKeys(formattedDate, import_selenium_webdriver12.Key.ENTER).perform();
+        }
       }
-      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);
+    };
+  }
+});
+
+// src/pageObjects/elements/Editors/Date/SingleDateEditor.ts
+var import_selenium_webdriver13, SingleDateEditor;
+var init_SingleDateEditor = __esm({
+  "src/pageObjects/elements/Editors/Date/SingleDateEditor.ts"() {
+    "use strict";
+    import_selenium_webdriver13 = require("selenium-webdriver");
+    init_InputClearStrategy();
+    init_BaseDateEditor();
+    SingleDateEditor = class extends BaseDateEditor {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new InputClearStrategy());
       }
-      async checkEditingMode(isEditing, msg) {
-        await wait(
-          async () => {
-            return (await this.getClasses()).includes(DX_ROW_EDIT_CLASS) === isEditing;
-          },
-          this.driver,
-          msg
-        );
+      async getDateElement() {
+        return this.driver.findElement(import_selenium_webdriver13.By.css(this.getFullCssSelector() + " .dx-dropdowneditor-input-wrapper input[type=hidden]"));
       }
-      async edit() {
-        await this.clickInlineButton("edit");
-        await this.checkEditingMode(true, "Row did not switch to edit mode");
+      async getDateValue() {
+        const inputEl = await this.getDateElement();
+        return inputEl.getAttribute("value");
       }
-      async save() {
-        await this.clickInlineButton("save");
-        await this.checkEditingMode(false, "Row did not saved");
+      async getValue() {
+        const value = await this.getDateValue();
+        return value == "" ? null : new Date(value);
       }
-      async cancel() {
-        await this.clickInlineButton("cancel");
-        await this.checkEditingMode(false, "Row did not switch to normal mode");
+      setValue(value) {
+        if (typeof value === "object") {
+          return this.setDateValue(value);
+        }
+        throw new Error(`Value is incorrect. It should be Object`);
       }
     };
   }
 });
 
-// src/pageObjects/elements/Table/elements/Column.ts
-var import_selenium_webdriver12, Column;
-var init_Column = __esm({
-  "src/pageObjects/elements/Table/elements/Column.ts"() {
+// src/pageObjects/elements/Editors/Date/DateRangeEditor.ts
+var import_selenium_webdriver14, DateRangeEditor;
+var init_DateRangeEditor = __esm({
+  "src/pageObjects/elements/Editors/Date/DateRangeEditor.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;
+    import_selenium_webdriver14 = require("selenium-webdriver");
+    init_InputClearStrategy();
+    init_BaseDateEditor();
+    DateRangeEditor = class extends BaseDateEditor {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.setClearStrategy(new InputClearStrategy());
       }
-      set index(index) {
-        this._index = index;
-        this.elementCssSelector = getColumnByIndexCssSelector(index);
+      async getDateElement() {
+        return this.driver.findElement(import_selenium_webdriver14.By.css(this.getFullCssSelector() + " .dx-texteditor-input"));
       }
-      get index() {
-        return this._index;
+      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 getElement() {
-        await this.getIndex();
-        return super.getElement();
+      async getValue() {
+        const values = await this.getDateValue();
+        return !values.length ? null : values;
       }
-      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"));
+      setValue(value) {
+        if (typeof value === "object") {
+          return this.setDateValue(value);
+        }
+        throw new Error(`Value is incorrect. It should be Object`);
       }
-      async getIndexByCaption() {
-        return this.getColumnHeaderIndexBy(getColumnByCaptionCssSelector(this._caption));
+    };
+  }
+});
+
+// src/pageObjects/elements/Editors/Date/DateEditor.ts
+var DateEditor;
+var init_DateEditor = __esm({
+  "src/pageObjects/elements/Editors/Date/DateEditor.ts"() {
+    "use strict";
+    init_SingleDateEditor();
+    init_DateRangeEditor();
+    init_AbstractFormElement();
+    init_AbstractEditor();
+    init_types();
+    DateEditor = class extends AbstractDXEditorWithInput {
+      editorInstance = null;
+      initPromise;
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
+        this.initPromise = this.init(parentCssSelector, elementCssSelector, driver);
       }
-      async getIndexByName() {
-        return this.getColumnHeaderIndexBy(getColumnByNameCssSelector(this._name));
+      async init(parentCssSelector, elementCssSelector, driver) {
+        await this.updateEditorInstance(parentCssSelector, elementCssSelector, driver);
       }
-      async caption() {
-        const el = await this.getElement();
-        return el.getText();
+      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 getIndex() {
-        if (this.index != null) {
-          return this.index;
+      async ensureInitialized() {
+        if (!this.editorInstance) {
+          await this.initPromise;
         }
-        if (this._caption != null) {
-          this.index = await this.getIndexByCaption();
-          return this.index;
+      }
+      async setValue(value) {
+        await this.ensureInitialized();
+        if (this.editorInstance) {
+          await this.editorInstance.setValue(value);
+          return await this.updateEditorInstance(this.parentCssSelector, this.elementCssSelector, this.driver);
         }
-        if (this._name != null) {
-          this.index = await this.getIndexByName();
-          return this.index;
+        throw new Error("Editor instance is not initialized.");
+      }
+      async getValue() {
+        await this.ensureInitialized();
+        if (this.editorInstance) {
+          return this.editorInstance.getValue();
         }
-        throw new Error("Cant get the index in the column");
+        throw new Error("Editor instance is not initialized.");
       }
     };
   }
 });
 
-// src/pageObjects/elements/Editors/ClearStrategy/InputClearStrategy.ts
-var InputClearStrategy;
-var init_InputClearStrategy = __esm({
-  "src/pageObjects/elements/Editors/ClearStrategy/InputClearStrategy.ts"() {
+// src/pageObjects/elements/Editors/editorFactory.ts
+var editorFactory;
+var init_editorFactory = __esm({
+  "src/pageObjects/elements/Editors/editorFactory.ts"() {
+    "use strict";
+    init_types();
+    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");
+    };
+  }
+});
+
+// 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_types();
+  }
+});
+
+// src/utils/createDataTestId.ts
+function createDataTestId(formName, itemType, itemName) {
+  return `${formName}-${itemType}-${itemName}`;
+}
+function createFieldTestId(formName, itemName) {
+  return createDataTestId(formName, "form_field" /* FORM_FIELD */, itemName);
+}
+function createGroupTestId(formName, itemName) {
+  return createDataTestId(formName, "group" /* GROUP */, itemName);
+}
+function createFilterTestId(formName, itemName, layout) {
+  return createDataTestId(formName, "filter" /* FILTER */, itemName) + `-${layout}`;
+}
+function createDocFilterTestId(formName, itemName) {
+  return createFilterTestId(formName, itemName, "dock-panel-filter" /* DOCK_PANEL */);
+}
+function createHeaderFilterTestId(formName, itemName) {
+  return createFilterTestId(formName, itemName, "header-filter" /* HEADER_FILTER */);
+}
+function createLayoutFilterTestId(formName, itemName) {
+  return createFilterTestId(formName, itemName, "layout-filter" /* LAYOUT */);
+}
+function createTableId(formName) {
+  return `${"table" /* TABLE */}-${formName}`;
+}
+function createFormButtonTestId(formName, itemName) {
+  return createDataTestId(formName, "button" /* BUTTON */, itemName);
+}
+function createSubSystemTestId(itemName) {
+  return `${"subsystem-item" /* SUBSYSTEM_ITEM */}-${itemName}`;
+}
+var init_createDataTestId = __esm({
+  "src/utils/createDataTestId.ts"() {
     "use strict";
-    InputClearStrategy = class {
-      async clear(editor) {
-        const inputEl = await editor.getInputElement();
-        await inputEl.clear();
-      }
-    };
   }
 });
 
-// src/pageObjects/elements/Editors/AbstractEditor.ts
-var import_selenium_webdriver13, AbstractDXEditorWithInput;
-var init_AbstractEditor = __esm({
-  "src/pageObjects/elements/Editors/AbstractEditor.ts"() {
+// src/utils/waitElementIsClickable.ts
+async function waitElementIsClickable({
+  element,
+  timeout,
+  errorMessage,
+  driver
+}) {
+  driver = driver ?? config().driver;
+  await wait(async () => {
+    const isDisabled = await element.getCssValue("pointer-events") === "none";
+    return await element.isDisplayed() && !isDisabled;
+  }, driver, errorMessage, timeout ?? config().timeout);
+}
+var init_waitElementIsClickable = __esm({
+  "src/utils/waitElementIsClickable.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);
-      }
-    };
+    init_config();
+    init_wait();
   }
 });
 
-// src/pageObjects/elements/Editors/TextEditor.ts
-var TextEditor;
-var init_TextEditor = __esm({
-  "src/pageObjects/elements/Editors/TextEditor.ts"() {
+// src/pageObjects/elements/TableToolbar/AbstractButton.ts
+var AbstractButton;
+var init_AbstractButton = __esm({
+  "src/pageObjects/elements/TableToolbar/AbstractButton.ts"() {
     "use strict";
-    init_AbstractEditor();
-    init_InputClearStrategy();
-    TextEditor = class extends AbstractDXEditorWithInput {
+    init_AbstractElementWithParent();
+    init_actions();
+    init_waitElementIsClickable();
+    AbstractButton = class extends AbstractElementWithParent {
       constructor(parentCssSelector, elementCssSelector, driver) {
         super(parentCssSelector, elementCssSelector, driver);
-        this.setClearStrategy(new InputClearStrategy());
       }
-      getValue() {
-        return this.getInputValue();
+      async click() {
+        const button = await this.getElement();
+        await waitElementIsClickable({
+          element: button,
+          errorMessage: this.buttonNotDisplayedError(),
+          driver: this.driver
+        });
+        await click(button, this.driver);
       }
-      setValue(value) {
-        return this.setInputValue(value);
+      async isDisabled() {
+        const button = await this.getElement();
+        return await button.getCssValue("pointer-events") === "none";
       }
     };
   }
 });
 
-// src/pageObjects/elements/Editors/NumberEditor.ts
-var NumberEditor;
-var init_NumberEditor = __esm({
-  "src/pageObjects/elements/Editors/NumberEditor.ts"() {
+// src/pageObjects/elements/DXComponents/DXButton.ts
+var import_selenium_webdriver16, DXButton;
+var init_DXButton = __esm({
+  "src/pageObjects/elements/DXComponents/DXButton.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);
+    init_AbstractButton();
+    import_selenium_webdriver16 = 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_webdriver16.By.className("dx-button-text"));
+        return await textEl.getText();
       }
     };
   }
 });
 
-// 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"() {
+// src/pageObjects/elements/FormButton.ts
+var FormButton;
+var init_FormButton = __esm({
+  "src/pageObjects/elements/FormButton.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;
+    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;
       }
-      async setValue(value) {
-        const inputEl = await this.getElement();
-        const currentValue = await this.getValue();
-        if (currentValue !== value) {
-          await click(inputEl, this.driver);
-        }
+      buttonNotDisplayedError() {
+        return `Form Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
       }
     };
   }
 });
 
-// src/utils/xpathHelper.ts
-var XPathHelper;
-var init_xpathHelper = __esm({
-  "src/utils/xpathHelper.ts"() {
+// src/pageObjects/elements/Groups/AbstractGroup.ts
+var AbstractGroup;
+var init_AbstractGroup = __esm({
+  "src/pageObjects/elements/Groups/AbstractGroup.ts"() {
     "use strict";
-    XPathHelper = class {
-      static getClassAndValueXpath(cssClass, value) {
-        return `div[contains(@class, '${cssClass}') and contains(.,'${value}')]`;
+    init_AbstractElementWithParent();
+    AbstractGroup = class extends AbstractElementWithParent {
+      async isDisplayed() {
+        const groupElement = await this.getElement();
+        return await groupElement.isDisplayed();
       }
     };
   }
 });
 
-// src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts
-var import_selenium_webdriver14, DX_TEXTEDITOR_EMPTY, DX_CLEAR_BUTTON_AREA, ClearButtonStrategy;
-var init_ClearButtonStrategy = __esm({
-  "src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts"() {
+// src/pageObjects/elements/Groups/Panel.ts
+var Panel;
+var init_Panel = __esm({
+  "src/pageObjects/elements/Groups/Panel.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);
-      }
+    init_AbstractGroup();
+    Panel = class extends AbstractGroup {
     };
   }
 });
 
-// src/pageObjects/elements/Editors/SelectBoxEditor.ts
-var import_selenium_webdriver15, SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS, combinedValueXpath, dropDownOptionClick, SelectBoxEditor;
-var init_SelectBoxEditor = __esm({
-  "src/pageObjects/elements/Editors/SelectBoxEditor.ts"() {
+// src/pageObjects/elements/Groups/TabPanel.ts
+var import_selenium_webdriver17, TabPanelItem, TabPanel;
+var init_TabPanel = __esm({
+  "src/pageObjects/elements/Groups/TabPanel.ts"() {
     "use strict";
-    init_AbstractEditor();
-    import_selenium_webdriver15 = require("selenium-webdriver");
-    init_xpathHelper();
+    init_AbstractGroup();
+    import_selenium_webdriver17 = require("selenium-webdriver");
     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 {
+    TabPanelItem = class extends AbstractGroup {
       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 click() {
+        await click(await this.getElement(), this.driver);
       }
-      async getValue() {
-        const value = await super.getInputValue();
-        return value == "" ? null : value;
+      async isActive() {
+        const tabPanelItemElement = await this.getElement();
+        const grandparentTab = await tabPanelItemElement.findElement(import_selenium_webdriver17.By.xpath('ancestor::div[@role="tab"][1]'));
+        return await grandparentTab.getAttribute("aria-selected") === "true";
       }
-      setValue(value) {
-        return this.setSelectInputValue(value);
+      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 "";
       }
     };
   }
 });
 
-// src/pageObjects/elements/Editors/SwitchEditor.ts
-var SwitchEditor;
-var init_SwitchEditor = __esm({
-  "src/pageObjects/elements/Editors/SwitchEditor.ts"() {
+// src/pageObjects/elements/Groups/Accordion/AccordionItem.ts
+var import_selenium_webdriver18, ACCORDION_TITLE_CONTAINER, AccordionItem;
+var init_AccordionItem = __esm({
+  "src/pageObjects/elements/Groups/Accordion/AccordionItem.ts"() {
     "use strict";
+    init_AbstractGroup();
+    import_selenium_webdriver18 = require("selenium-webdriver");
     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;
+    ACCORDION_TITLE_CONTAINER = "accordion-title-container";
+    AccordionItem = class extends AbstractGroup {
+      constructor(parentCssSelector, elementCssSelector, driver) {
+        super(parentCssSelector, elementCssSelector, driver);
       }
-      async setValue(value) {
-        if (value !== 0 && value !== 1) {
-          value = value ? 1 : 0;
+      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_webdriver18.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();
         }
-        const inputEl = await this.getElement();
-        const currentValue = await this.getValue();
-        if (currentValue === value) {
-          return;
+      }
+      async collapse() {
+        if (await this.isExpanded()) {
+          await this.clickAccordionItemTitle();
         }
-        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_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"() {
+// src/pageObjects/elements/Groups/Accordion/Accordion.ts
+var Accordion;
+var init_Accordion = __esm({
+  "src/pageObjects/elements/Groups/Accordion/Accordion.ts"() {
     "use strict";
-    init_AbstractEditor();
-    import_selenium_webdriver16 = require("selenium-webdriver");
-    init_actions();
-    init_locators();
-    init_SelectBoxEditor();
-    init_ClearButtonStrategy();
-    init_wait();
-    TAGS_SELECTOR = ".dx-tag .tag-text";
-    DX_TAG_CONTAINER = "dx-tag-container";
-    DX_TEXTEDITOR_EMPTY2 = "dx-texteditor-empty";
-    BTN_OK_SELECTOR = ".dx-tagbox-popup-wrapper .dx-popup-bottom .dx-button.dx-popup-done";
-    TAG_BOX_LIST_ITEM_SELECTOR = '.dx-tagbox-popup-wrapper .dx-list-item[aria-selected="true"]';
-    TagBox = class extends AbstractDXEditorWithInput {
+    init_AbstractGroup();
+    init_AccordionItem();
+    Accordion = class extends AbstractGroup {
       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();
+      item(name) {
+        return new AccordionItem(this.getFullCssSelector(), `.d5-accordion-item[data-groupname="${name}"]`, this.driver);
       }
-      async waitOptionSelection() {
-        const option = await this.driver.findElement(import_selenium_webdriver16.By.css(TAG_BOX_LIST_ITEM_SELECTOR));
-        await wait(() => option.isDisplayed(), this.driver);
+    };
+  }
+});
+
+// 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");
+    };
+  }
+});
+
+// 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();
+    init_TabPanel();
+    FormGroup = class extends AbstractElementWithParent {
+      groupInstance;
+      constructor(parentCssSelector, formName, name, driver) {
+        super(parentCssSelector, byTestIdCssSelector(createGroupTestId(formName, name)), driver);
       }
-      async selectOption(inputEl, value, lastElement) {
+      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 dropDownOptionClick(value, this.driver, false);
+          await this.initInstance();
+          return this.groupInstance.isDisplayed();
         } catch {
-          await inputEl.sendKeys(value);
-          await dropDownOptionClick(value, this.driver);
-        }
-        await this.waitOptionSelection();
-        if (value !== lastElement) {
-          await inputEl.clear();
+          return false;
         }
       }
-      async confirmSelection() {
-        const btnOk = await this.driver.findElement(import_selenium_webdriver16.By.css(BTN_OK_SELECTOR));
-        await click(btnOk, this.driver);
+      /**
+       * Клик по элементам группы.
+       * Метод работает если у группы есть дочерние элементы, например элементы аккордеона или вкладки таб панели.
+       * @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();
       }
-      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"));
+      /**
+       * Метод работает если группа - это элемент аккордеона или вкладка таб панели
+       * @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();
         }
-        return values;
       }
-      async isTagBoxEmpty() {
-        const classAttribute = await this.getClasses();
-        return classAttribute.includes(DX_TEXTEDITOR_EMPTY2);
+      async expand() {
+        await this.initInstance();
+        if (this.groupInstance instanceof AccordionItem) {
+          await this.groupInstance.expand();
+        }
       }
-      async getValue() {
-        const value = await this.getTagBoxInputValue();
-        return value.length ? value : null;
+      async isExpanded() {
+        await this.initInstance();
+        if (this.groupInstance instanceof AccordionItem) {
+          return await this.groupInstance.isExpanded();
+        }
+        return false;
       }
-      async setValue(values) {
-        if (!Array.isArray(values)) {
-          throw new Error("The provided value is not an array");
+      async isCollapsed() {
+        await this.initInstance();
+        if (this.groupInstance instanceof AccordionItem) {
+          return await this.groupInstance.isCollapsed();
         }
-        await this.setTagBoxInputValue(values);
+        return false;
       }
-      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`);
+      async isActive() {
+        await this.initInstance();
+        if (this.groupInstance instanceof TabPanelItem) {
+          return await this.groupInstance.isActive();
         }
-        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);
+        return false;
       }
     };
   }
 });
 
-// src/pageObjects/elements/Editors/ButtonGroup.ts
-var import_selenium_webdriver17, ITEM_CLASS, SELECTED_CLASS, ButtonGroup;
-var init_ButtonGroup = __esm({
-  "src/pageObjects/elements/Editors/ButtonGroup.ts"() {
+// src/pageObjects/elements/Forms/AbstractForm.ts
+var AbstractForm;
+var init_AbstractForm = __esm({
+  "src/pageObjects/elements/Forms/AbstractForm.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}`));
-      }
-      getDataValue(el) {
-        return el.getAttribute("data-value");
+    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;
       }
-      async getValue() {
-        const selectedEl = await this.driver.findElement(import_selenium_webdriver17.By.css(`${this.getFullCssSelector()} .${ITEM_CLASS}.${SELECTED_CLASS}`));
-        return this.getDataValue(selectedEl);
+      get formName() {
+        return this._formName;
       }
-      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;
-          }
+      /**
+       * Возвращает 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;
         }
-        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;
-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;
+      button(name) {
+        return new FormButton(this.containerCssSelector, this.formName, name, this.driver);
       }
-      // @ts-ignore
-      async setValue(value) {
-        const val = value == null ? "null" : value ? "1" : "0";
-        await super.setValue(val);
+      /**
+       * Находит группу на форме по имени
+       * @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/Date/utils.ts
-var formatDMYDate;
+// src/pageObjects/elements/Forms/types.ts
+var init_types2 = __esm({
+  "src/pageObjects/elements/Forms/types.ts"() {
+    "use strict";
+  }
+});
+
+// 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_webdriver19, getColumnByIndexCssSelector, getColumnByCaptionCssSelector, getColumnByNameCssSelector, transformInputIndex, transformOutputIndex;
 var init_utils2 = __esm({
-  "src/pageObjects/elements/Editors/Date/utils.ts"() {
+  "src/pageObjects/elements/Table/utils.ts"() {
     "use strict";
-    formatDMYDate = (date) => {
-      const [year, month, day] = date.toJSON().split("T")[0].split("-");
-      return `${day}${month}${year}`;
-    };
+    import_selenium_webdriver19 = 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;
   }
 });
 
-// src/pageObjects/elements/Editors/Date/BaseDateEditor.ts
-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"() {
+// src/pageObjects/elements/Table/types.ts
+var init_types3 = __esm({
+  "src/pageObjects/elements/Table/types.ts"() {
     "use strict";
-    init_AbstractEditor();
-    init_InputClearStrategy();
-    import_selenium_webdriver18 = require("selenium-webdriver");
-    init_locators();
-    init_actions();
+  }
+});
+
+// src/pageObjects/elements/Table/elements/Cell.ts
+var import_selenium_webdriver20, Cell;
+var init_Cell = __esm({
+  "src/pageObjects/elements/Table/elements/Cell.ts"() {
+    "use strict";
+    import_selenium_webdriver20 = require("selenium-webdriver");
+    init_AbstractElementWithParent();
     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());
+    init_types3();
+    Cell = class extends AbstractElementWithParent {
+      _index;
+      getCellIndex;
+      constructor(parentCssSelector, getCellIndex, index, driver) {
+        super(parentCssSelector, getCssCellByIndexSelector(index), driver);
+        this.getCellIndex = getCellIndex;
+        this._index = index;
       }
-      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();
+      set index(index) {
+        this._index = index;
+        this.elementCssSelector = getCssCellByIndexSelector(index);
+      }
+      async getBooleanValue(cellEl) {
+        const booleanEl = await cellEl.findElement(import_selenium_webdriver20.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_webdriver20.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;
       }
     };
   }
 });
 
-// src/pageObjects/elements/Editors/Date/SingleDateEditor.ts
-var import_selenium_webdriver19, SingleDateEditor;
-var init_SingleDateEditor = __esm({
-  "src/pageObjects/elements/Editors/Date/SingleDateEditor.ts"() {
+// src/pageObjects/elements/Table/elements/Row.ts
+var import_selenium_webdriver21, 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_webdriver19 = require("selenium-webdriver");
-    init_InputClearStrategy();
-    init_BaseDateEditor();
-    SingleDateEditor = class extends BaseDateEditor {
-      constructor(parentCssSelector, elementCssSelector, driver) {
-        super(parentCssSelector, elementCssSelector, driver);
-        this.setClearStrategy(new InputClearStrategy());
+    import_selenium_webdriver21 = require("selenium-webdriver");
+    init_Cell();
+    init_utils2();
+    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;
       }
-      async getDateElement() {
-        return this.driver.findElement(import_selenium_webdriver19.By.css(this.getFullCssSelector() + " .dx-dropdowneditor-input-wrapper input[type=hidden]"));
+      _getCell({ index, name, title }) {
+        return new Cell(
+          this.getFullCssSelector(),
+          () => {
+            return this.getColumnBy({ title, name }).getIndex();
+          },
+          index,
+          this.driver
+        );
       }
-      async getDateValue() {
-        const inputEl = await this.getDateElement();
-        return inputEl.getAttribute("value");
+      getCellByIndex(index) {
+        return this._getCell({ index });
       }
-      async getValue() {
-        const value = await this.getDateValue();
-        return value == "" ? null : new Date(value);
+      getCell(name) {
+        return this._getCell({ name });
       }
-      setValue(value) {
-        if (typeof value === "object") {
-          return this.setDateValue(value);
-        }
-        throw new Error(`Value is incorrect. It should be Object`);
+      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_webdriver21.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_webdriver21.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/Editors/Date/DateRangeEditor.ts
-var import_selenium_webdriver20, DateRangeEditor;
-var init_DateRangeEditor = __esm({
-  "src/pageObjects/elements/Editors/Date/DateRangeEditor.ts"() {
+// src/pageObjects/elements/Table/elements/Column.ts
+var import_selenium_webdriver22, Column;
+var init_Column = __esm({
+  "src/pageObjects/elements/Table/elements/Column.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());
+    import_selenium_webdriver22 = require("selenium-webdriver");
+    init_utils2();
+    init_AbstractElementWithParent();
+    init_fixElementStaleError();
+    Column = class extends AbstractElementWithParent {
+      _index;
+      _caption;
+      _name;
+      headerCssSelector;
+      constructor({ parentCssSelector, headerCssSelector, name, caption, index, driver }) {
+        super(parentCssSelector, "", driver);
+        this._name = name;
+        this.index = index;
+        this._caption = caption;
+        this.headerCssSelector = headerCssSelector;
       }
-      async getDateElement() {
-        return this.driver.findElement(import_selenium_webdriver20.By.css(this.getFullCssSelector() + " .dx-texteditor-input"));
+      set index(index) {
+        this._index = index;
+        this.elementCssSelector = getColumnByIndexCssSelector(index);
       }
-      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];
+      get index() {
+        return this._index;
       }
-      async getValue() {
-        const values = await this.getDateValue();
-        return !values.length ? null : values;
+      async getElement() {
+        await this.getIndex();
+        return super.getElement();
       }
-      setValue(value) {
-        if (typeof value === "object") {
-          return this.setDateValue(value);
-        }
-        throw new Error(`Value is incorrect. It should be Object`);
+      async getColumnHeaderIndexBy(cssSelector) {
+        const column = await fixElementStaleError(import_selenium_webdriver22.By.css(`${this.parentCssSelector} ${this.headerCssSelector} ${cssSelector}`), this.driver);
+        return transformOutputIndex(await column.getAttribute("aria-colindex"));
       }
-    };
-  }
-});
-
-// src/pageObjects/elements/Editors/Date/DateEditor.ts
-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 getIndexByCaption() {
+        return this.getColumnHeaderIndexBy(getColumnByCaptionCssSelector(this._caption));
       }
-      async init(parentCssSelector, elementCssSelector, driver) {
-        await this.updateEditorInstance(parentCssSelector, elementCssSelector, driver);
+      async getIndexByName() {
+        return this.getColumnHeaderIndexBy(getColumnByNameCssSelector(this._name));
       }
-      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 caption() {
+        const el = await this.getElement();
+        return el.getText();
       }
-      async ensureInitialized() {
-        if (!this.editorInstance) {
-          await this.initPromise;
+      async getIndex() {
+        if (this.index != null) {
+          return this.index;
         }
-      }
-      async setValue(value) {
-        await this.ensureInitialized();
-        if (this.editorInstance) {
-          await this.editorInstance.setValue(value);
-          return await this.updateEditorInstance(this.parentCssSelector, this.elementCssSelector, this.driver);
+        if (this._caption != null) {
+          this.index = await this.getIndexByCaption();
+          return this.index;
         }
-        throw new Error("Editor instance is not initialized.");
-      }
-      async getValue() {
-        await this.ensureInitialized();
-        if (this.editorInstance) {
-          return this.editorInstance.getValue();
+        if (this._name != null) {
+          this.index = await this.getIndexByName();
+          return this.index;
         }
-        throw new Error("Editor instance is not initialized.");
-      }
-    };
-  }
-});
-
-// src/pageObjects/elements/Editors/editorFactory.ts
-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);
+        throw new Error("Cant get the index in the column");
       }
-      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/Editors/index.ts
-var init_Editors = __esm({
-  "src/pageObjects/elements/Editors/index.ts"() {
-    "use strict";
-    init_TextEditor();
-    init_NumberEditor();
-    init_editorFactory();
-    init_types3();
-  }
-});
-
 // src/pageObjects/elements/AbstractEditor.ts
 var AbstractEditor;
 var init_AbstractEditor2 = __esm({
@@ -1615,11 +1752,11 @@ var init_FormField = __esm({
 });
 
 // src/pageObjects/elements/Table/Table.ts
-var import_selenium_webdriver21, Table;
+var import_selenium_webdriver23, Table;
 var init_Table = __esm({
   "src/pageObjects/elements/Table/Table.ts"() {
     "use strict";
-    import_selenium_webdriver21 = require("selenium-webdriver");
+    import_selenium_webdriver23 = require("selenium-webdriver");
     init_createDataTestId();
     init_AbstractElementWithParent();
     init_Row();
@@ -1669,7 +1806,7 @@ var init_Table = __esm({
         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 rows = await this.driver.findElements(import_selenium_webdriver23.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);
@@ -1679,7 +1816,7 @@ var init_Table = __esm({
       }
       async getColumns() {
         const columns = await this.driver.findElements(
-          import_selenium_webdriver21.By.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"]`)
+          import_selenium_webdriver23.By.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"]`)
         );
         const result = [];
         columns.forEach((_, index) => {
@@ -1774,11 +1911,11 @@ var init_typesUtil = __esm({
 });
 
 // src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
-var import_selenium_webdriver22, SPINDOWN_CLASS, buttonGroupItemSelector, getFullCssSelector, buttonByTextXpath, ToolbarMenu;
+var import_selenium_webdriver24, SPINDOWN_CLASS, buttonGroupItemSelector, getFullCssSelector, buttonByTextXpath, ToolbarMenu;
 var init_ToolbarMenu = __esm({
   "src/pageObjects/elements/TableToolbar/ToolbarMenu.ts"() {
     "use strict";
-    import_selenium_webdriver22 = require("selenium-webdriver");
+    import_selenium_webdriver24 = require("selenium-webdriver");
     init_typesUtil();
     init_AbstractElementWithParent();
     init_locators();
@@ -1829,7 +1966,7 @@ var init_ToolbarMenu = __esm({
           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)));
+          await this.goToButton(t, import_selenium_webdriver24.By.xpath(buttonByTextXpath(t)));
         }
       }
     };
@@ -2004,11 +2141,11 @@ var init_PanelFilterField = __esm({
 });
 
 // src/pageObjects/elements/Filters/FilterPanel.ts
-var import_selenium_webdriver23, drawerSelector, FILTER_PANEL_SELECTOR, CLOSE_SELECTOR, FilterPanel;
+var import_selenium_webdriver25, 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");
+    import_selenium_webdriver25 = require("selenium-webdriver");
     init_AbstractElement();
     init_PanelFilterField();
     init_actions();
@@ -2023,7 +2160,7 @@ var init_FilterPanel = __esm({
       async filterPanelButtons() {
         const selector = `${this.elementCssSelector} ${FILTER_PANEL_SELECTOR} .filter-panel__buttons-panel .dx-button-text`;
         const el = await this.getElement();
-        return el.findElements(import_selenium_webdriver23.By.css(selector));
+        return el.findElements(import_selenium_webdriver25.By.css(selector));
       }
       constructor(formName, driver) {
         super(driver, drawerSelector(formName));
@@ -2056,9 +2193,142 @@ var init_FilterPanel = __esm({
         await this.driver.sleep(300);
       }
       async close() {
-        const btn = await this.driver.findElement(import_selenium_webdriver23.By.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
+        const btn = await this.driver.findElement(import_selenium_webdriver25.By.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
+        await click(btn, this.driver);
+      }
+    };
+  }
+});
+
+// src/pageObjects/elements/Filters/HeaderFilterField.ts
+var HeaderFilterField;
+var init_HeaderFilterField = __esm({
+  "src/pageObjects/elements/Filters/HeaderFilterField.ts"() {
+    "use strict";
+    init_locators();
+    init_createDataTestId();
+    init_AbstractEditor2();
+    HeaderFilterField = class extends AbstractEditor {
+      constructor(parentCssSelector, formName, name, driver) {
+        super(parentCssSelector, byTestIdCssSelector(createHeaderFilterTestId(formName, name)), driver);
+      }
+      async getValue() {
+        return super.getValue();
+      }
+      async setValue(value) {
+        return super.setValue(value);
+      }
+      async clear() {
+        return super.clear();
+      }
+      async remove(itemText) {
+        return super.remove(itemText);
+      }
+    };
+  }
+});
+
+// src/pageObjects/elements/Filters/ColumnFilter.ts
+var import_selenium_webdriver26, APPLY_SELECTOR, CANCEL_SELECTOR, HEADER_FILTER_ICON, HEADER_FILTER_CONTAINER, HEADER_FILTER_BUTTONS, ColumnFilter;
+var init_ColumnFilter = __esm({
+  "src/pageObjects/elements/Filters/ColumnFilter.ts"() {
+    "use strict";
+    init_actions();
+    import_selenium_webdriver26 = require("selenium-webdriver");
+    init_HeaderFilterField();
+    init_waitElementIsVisible();
+    init_AbstractElement();
+    APPLY_SELECTOR = ".apply-button";
+    CANCEL_SELECTOR = ".cancel-button";
+    HEADER_FILTER_ICON = ".dx-column-indicators .dx-header-filter";
+    HEADER_FILTER_CONTAINER = ".header-filter";
+    HEADER_FILTER_BUTTONS = ".header-filter-buttons";
+    ColumnFilter = class extends AbstractElement {
+      _formName;
+      _name;
+      _column;
+      constructor(formName, name, column, driver) {
+        super(driver, HEADER_FILTER_CONTAINER);
+        this._formName = formName;
+        this._name = name;
+        this._column = column;
+        this.driver = driver;
+      }
+      async getApplyButton() {
+        const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${APPLY_SELECTOR}`;
+        return this.driver.findElement(import_selenium_webdriver26.By.css(selector));
+      }
+      async getCancelButton() {
+        const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${CANCEL_SELECTOR}`;
+        return this.driver.findElement(import_selenium_webdriver26.By.css(selector));
+      }
+      async apply() {
+        const btn = await this.getApplyButton();
+        await click(btn, this.driver);
+      }
+      async cancel() {
+        const btn = await this.getCancelButton();
         await click(btn, this.driver);
       }
+      async initFilter() {
+        const columnEl = await this._column.getElement();
+        const actions = this.driver.actions({ async: true });
+        await actions.move({ origin: columnEl }).perform();
+        const elements = await columnEl.findElements(import_selenium_webdriver26.By.css(HEADER_FILTER_ICON));
+        const headerFilterIcon = elements[1];
+        await waitElementIsVisible({
+          element: headerFilterIcon,
+          driver: this.driver,
+          errorMessage: `HeaderFilter "${this._name}" is not visible`
+        });
+        if (!headerFilterIcon)
+          throw new Error(`HeaderFilter "${this._name}" is not visible`);
+        await headerFilterIcon.click();
+        return new HeaderFilterField("", this._formName, this._name, this.driver);
+      }
+      /**
+       * Возвращает значение в поле
+       * @example
+       * expect(await form.columnFilter('NumberFld').getValue()).toBe(10);
+       * expect(await form.columnFilter('TextFld').getValue()).toBe('TestValue');
+       */
+      async getValue() {
+        const filter = await this.initFilter();
+        const result = await filter.getValue();
+        await this.cancel();
+        return result;
+      }
+      /**
+       * Устанавливает значение в поле
+       * @example
+       * await form.columnFilter('NumberFld').setValue(123);
+       * await form.columnFilter('TextFld').setValue('TestValue');
+       */
+      async setValue(value) {
+        const filter = await this.initFilter();
+        await filter.setValue(value);
+        return this.apply();
+      }
+      /**
+       * Очищает значение в поле
+       * @example
+       * await form.columnFilter('NumberFld').clear();
+       */
+      async clear() {
+        const filter = await this.initFilter();
+        await filter.clear();
+        return this.apply();
+      }
+      /**
+       * Удаляет тег по переданному тексту
+       * @example
+       * await form.columnFilter('TagBox').remove('test');
+       */
+      async remove(itemText) {
+        const filter = await this.initFilter();
+        await filter.remove(itemText);
+        return this.apply();
+      }
     };
   }
 });
@@ -2077,6 +2347,7 @@ var init_ListForm = __esm({
     init_FormToolbar();
     init_FormFilterField();
     init_FilterPanel();
+    init_ColumnFilter();
     DATAGRID_HEADER_CSS_SELECTOR = ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
     ListForm = class extends Form {
       headerCssSelector;
@@ -2116,6 +2387,10 @@ var init_ListForm = __esm({
       formFilter(name) {
         return new FormFilterField(this.containerCssSelector, this.formName, name, this.driver);
       }
+      columnFilter(name) {
+        const column = this.table().getColumnByName(name);
+        return new ColumnFilter(this.formName, name, column, this.driver);
+      }
       /**
        * Модель панели фильтрации
        * @returns {FilterPanel}
@@ -2180,18 +2455,18 @@ var init_createSubFormInstance = __esm({
   "src/pageObjects/elements/Forms/createSubFormInstance.ts"() {
     "use strict";
     init_locators();
-    init_types();
+    init_types2();
     subFormTestId = (name) => `subform-${name}`;
   }
 });
 
 // src/pageObjects/elements/Forms/Form.ts
-var import_selenium_webdriver24, formTestId, Form;
+var import_selenium_webdriver27, formTestId, Form;
 var init_Form = __esm({
   "src/pageObjects/elements/Forms/Form.ts"() {
     "use strict";
     init_locators();
-    import_selenium_webdriver24 = require("selenium-webdriver");
+    import_selenium_webdriver27 = require("selenium-webdriver");
     init_AbstractForm();
     init_waitElementIsVisible();
     init_createSubFormInstance();
@@ -2216,10 +2491,10 @@ var init_Form = __esm({
        */
       async getTitleText() {
         if (await this.isModal()) {
-          const titleEl2 = await this.driver.findElement(import_selenium_webdriver24.By.css(`${this.popupContainerCssSelector} .popup-title`));
+          const titleEl2 = await this.driver.findElement(import_selenium_webdriver27.By.css(`${this.popupContainerCssSelector} .popup-title`));
           return titleEl2.getText();
         }
-        let titleEl = await this.driver.findElement(import_selenium_webdriver24.By.className("main-toolbar-form-title"));
+        let titleEl = await this.driver.findElement(import_selenium_webdriver27.By.className("main-toolbar-form-title"));
         return titleEl.getText();
       }
       setSubFormMode() {
@@ -2237,7 +2512,7 @@ var init_Form = __esm({
        */
       async subForm(name) {
         const cssSelector = subformCssSelector(this.containerCssSelector, subFormTestId(name));
-        const byCssSelector = import_selenium_webdriver24.By.css(cssSelector);
+        const byCssSelector = import_selenium_webdriver27.By.css(cssSelector);
         const subFormEl = await this.driver.findElement(byCssSelector);
         await waitElementIsVisible({
           element: subFormEl,
@@ -2267,18 +2542,18 @@ var FormEdit_exports = {};
 __export(FormEdit_exports, {
   default: () => FormEdit
 });
-var import_selenium_webdriver25, FormEdit;
+var import_selenium_webdriver28, FormEdit;
 var init_FormEdit = __esm({
   "src/pageObjects/elements/Forms/FormEdit.ts"() {
     "use strict";
     init_Form();
-    import_selenium_webdriver25 = require("selenium-webdriver");
+    import_selenium_webdriver28 = 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");
+      saveButtonBy = import_selenium_webdriver28.By.id("button-save");
+      closeButtonBy = import_selenium_webdriver28.By.id("button-cancel");
       constructor(driver) {
         super(driver);
         this.popupContainerCssSelector = `.popup .form-edit-${this.formName}`;
@@ -2346,6 +2621,7 @@ __export(src_exports, {
   LoginPage: () => LoginPage,
   NumberEditor: () => NumberEditor,
   PanelFilterField: () => PanelFilterField,
+  ReportForm: () => ReportForm,
   SubsystemsPanel: () => SubsystemsPanel,
   TextEditor: () => TextEditor,
   TreeView: () => TreeView,
@@ -2460,8 +2736,45 @@ var SubsystemsPanelHeader = class extends AbstractElementWithParent {
 };
 
 // src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
+var import_selenium_webdriver15 = require("selenium-webdriver");
 init_wait();
 init_locators();
+init_Editors();
+
+// src/pageObjects/elements/SubsystemsPanel/SubsystemItem.ts
+init_actions();
+init_fixElementStaleError();
+var SubsystemItem = class {
+  bySelector;
+  driver;
+  constructor({ driver, bySelector }) {
+    this.bySelector = bySelector;
+    this.driver = driver;
+  }
+  async getElement() {
+    return fixElementStaleError(this.bySelector, this.driver);
+  }
+  async getTitle() {
+    const el = await this.getElement();
+    return await el.getAttribute("data-title");
+  }
+  async click() {
+    const el = await this.getElement();
+    await click(el, this.driver);
+  }
+};
+
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
+init_createDataTestId();
+init_actions();
+init_ClearButtonStrategy();
+init_waitElementIsVisible();
+var SEARCH_ITEM_SELECTOR = "search-item";
+var BACK_BUTTON_SELECTOR = "subsystem-back-item";
+var SEARCH_INPUT_SELECTOR = "search-subsystem-input";
+var byTitleCssSelector = (title) => {
+  return `span[data-title="${title}"]`;
+};
 var SubsystemsPanel = class extends AbstractElement {
   header;
   constructor(driver) {
@@ -2473,12 +2786,110 @@ var SubsystemsPanel = class extends AbstractElement {
     await wait(async () => await title.getText() != "", this.driver);
     return title.getText();
   }
+  getSearchComponent() {
+    return new TextEditor("#aside", byTestIdCssSelector(SEARCH_INPUT_SELECTOR));
+  }
+  /**
+   * Находит сабсистему по заголовку
+   * @example
+   * const subsystemsPanel= new SubsystemsPanel();
+   * //...
+   * await subsystemsPanel.search('SubSystemTitle');
+   */
+  async search(title) {
+    const searchComponent = this.getSearchComponent();
+    await searchComponent.setValue(title);
+    await wait(
+      async () => {
+        const findElement = await this.itemByTitle(title).getElement();
+        const classes = await findElement.getAttribute("class");
+        return classes.includes(SEARCH_ITEM_SELECTOR);
+      },
+      this.driver,
+      `Cannot find element: ${title}`
+    );
+  }
+  /**
+   * Очищает поиск сабсистем
+   * @example
+   * const subsystemsPanel= new SubsystemsPanel();
+   * //...
+   * await subsystemsPanel.searchClear();
+   */
+  async searchClear() {
+    const clearBtnSelector = `#aside ${byTestIdCssSelector(SEARCH_INPUT_SELECTOR)} .${DX_CLEAR_BUTTON_AREA}`;
+    const clearBtn = await this.driver.findElement(import_selenium_webdriver15.By.css(clearBtnSelector));
+    if (await clearBtn.isDisplayed()) {
+      await click(clearBtn, this.driver);
+    }
+  }
+  /**
+   * Возвращает сабсистему по имени
+   * @example
+   * const subsystemsPanel= new SubsystemsPanel();
+   * //...
+   * const subsystem = subsystemsPanel.item('SubSystemName');
+   */
+  item(name) {
+    const elementCSS = createSubSystemTestId(name);
+    return new SubsystemItem({ driver: this.driver, bySelector: import_selenium_webdriver15.By.css(`${byTestIdCssSelector(elementCSS, "span")}`) });
+  }
+  /**
+   * Возвращает сабсистему по заголовку
+   * @example
+   * const subsystemsPanel= new SubsystemsPanel();
+   * //...
+   * const subsystem = subsystemsPanel.itemByTitle('SubSystemTitle');
+   */
+  itemByTitle(title) {
+    return new SubsystemItem({ driver: this.driver, bySelector: import_selenium_webdriver15.By.css(byTitleCssSelector(title)) });
+  }
+  /**
+   * Возвращается на уровень выше по сабсистемам
+   * @example
+   * const subsystemsPanel= new SubsystemsPanel();
+   * //...
+   * wait subsystemsPanel.back();
+   */
+  async back() {
+    const backButton = this.driver.findElement(import_selenium_webdriver15.By.css(`#aside .${BACK_BUTTON_SELECTOR}`));
+    await waitElementIsVisible(
+      {
+        element: backButton,
+        driver: this.driver
+      }
+    );
+    await click(backButton, this.driver);
+  }
 };
 
 // src/index.ts
 init_FormEdit();
 init_ListForm();
 init_TreeView();
+
+// src/pageObjects/elements/Forms/ReportForm.ts
+var import_selenium_webdriver29 = require("selenium-webdriver");
+init_FormEdit();
+var ReportForm = class extends FormEdit {
+  constructor(driver) {
+    super(driver);
+    this.popupContainerCssSelector = `.popup .form-report-${this.formName}`;
+    this.saveButtonBy = import_selenium_webdriver29.By.id("button-apply");
+  }
+  /**
+   * Знаходить поле/фільтр у формі репорту за ім'ям
+   * @example
+   * const formReport = new MyForm();
+   * //...
+   * expect(await formReport.filterField('Name').getValue()).toBe('test value');
+   */
+  filterField(name) {
+    return super.field(name);
+  }
+};
+
+// src/index.ts
 init_Editors();
 init_FormField();
 init_FormFilterField();
@@ -2487,7 +2898,7 @@ init_FilterPanel();
 
 // src/pageObjects/elements/Dialog.ts
 init_AbstractElement();
-var import_selenium_webdriver26 = require("selenium-webdriver");
+var import_selenium_webdriver30 = require("selenium-webdriver");
 init_AbstractButton();
 var DIALOG_CLASS = ".d5-dialog";
 var DIALOG_TITLE_CLASS = ".dialog__title";
@@ -2502,7 +2913,7 @@ var DialogButton = class extends AbstractButton {
   }
   async getElement() {
     const panel = await super.getElement();
-    return panel.findElement(import_selenium_webdriver26.By.xpath(buttonByTextXpath2(this.text)));
+    return panel.findElement(import_selenium_webdriver30.By.xpath(buttonByTextXpath2(this.text)));
   }
   buttonNotDisplayedError() {
     return `Dialog button ${this.text} cannot be clicked. It is not displayed or it is disabled`;
@@ -2522,11 +2933,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_webdriver26.By.css(this.titleSelector));
+    const el = await this.driver.findElement(import_selenium_webdriver30.By.css(this.titleSelector));
     return await el.getText();
   }
   async text() {
-    const el = await this.driver.findElement(import_selenium_webdriver26.By.css(this.textSelector));
+    const el = await this.driver.findElement(import_selenium_webdriver30.By.css(this.textSelector));
     return await el.getText();
   }
   button(text) {
@@ -2546,6 +2957,7 @@ var Dialog = class extends AbstractElement {
   LoginPage,
   NumberEditor,
   PanelFilterField,
+  ReportForm,
   SubsystemsPanel,
   TextEditor,
   TreeView,