@umbraco/playwright-testhelpers 17.1.0-beta.5 → 17.1.0-beta.7

package/dist/lib/helpers/ContentUiHelper.js

@@ -252,7 +252,7 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         this.hostnameComboBox = this.hostNameItem.locator('[label="Culture"]').locator('uui-combobox-list-option');
         this.saveModalBtn = this.sidebarModal.getByLabel('Save', { exact: true });
         this.resetFocalPointBtn = page.getByLabel('Reset focal point');
-        this.addNewHostnameBtn = page.locator('umb-property-layout[label="Hostnames"]').locator('[label="Add new hostname"]');
+        this.addNewHostnameBtn = page.getByLabel('Add new hostname');
         // List View
         this.enterNameInContainerTxt = this.container.getByTestId('input:entity-name').locator('#input');
         this.listView = page.locator('umb-document-table-collection-view');
@@ -379,32 +379,37 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         this.confirmToResetBtn = page.locator('#confirm').getByLabel('Reset', { exact: true });
     }
     async enterContentName(name) {
-        await this.enterText(this.contentNameTxt, name, { verify: true });
+        await (0, test_1.expect)(this.contentNameTxt).toBeVisible();
+        await this.contentNameTxt.clear();
+        await this.contentNameTxt.fill(name);
+        await (0, test_1.expect)(this.contentNameTxt).toHaveValue(name);
     }
     async clickSaveAndPublishButton() {
-        await this.click(this.saveAndPublishBtn);
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await (0, test_1.expect)(this.saveAndPublishBtn).toBeVisible();
+        await this.saveAndPublishBtn.click();
+        await this.page.waitForTimeout(500);
     }
     async isSuccessStateVisibleForSaveAndPublishButton(isVisible = true) {
         const saveAndPublishBtn = this.workspaceAction.filter({ has: this.saveAndPublishBtn });
-        await this.isVisible(saveAndPublishBtn.locator(this.successState), isVisible, ConstantHelper_1.ConstantHelper.timeout.long);
+        await (0, test_1.expect)(saveAndPublishBtn.locator(this.successState)).toBeVisible({ visible: isVisible, timeout: 10000 });
     }
     async clickPublishButton() {
-        await this.click(this.publishBtn);
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await this.publishBtn.click();
+        await this.page.waitForTimeout(500);
     }
     async clickUnpublishButton() {
-        await this.click(this.unpublishBtn);
+        await this.unpublishBtn.click();
     }
     async clickReloadChildrenThreeDotsButton() {
-        await this.click(this.reloadChildrenThreeDotsBtn);
+        await this.reloadChildrenThreeDotsBtn.click();
     }
     async clickActionsMenuAtRoot() {
-        await this.click(this.actionMenuForContentBtn, { force: true });
+        await this.actionMenuForContentBtn.click({ force: true });
     }
     async goToContentWithName(contentName) {
         const contentWithNameLocator = this.menuItemTree.getByText(contentName, { exact: true });
-        await this.click(contentWithNameLocator, { timeout: ConstantHelper_1.ConstantHelper.timeout.long });
+        await (0, test_1.expect)(contentWithNameLocator).toBeVisible();
+        await contentWithNameLocator.click();
     }
     async clickActionsMenuForContent(name) {
         await this.clickActionsMenuForName(name);
@@ -417,7 +422,8 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         }
     }
     async clickCaretButtonForContentName(name) {
-        await this.click(this.menuItemTree.filter({ hasText: name }).last().locator('#caret-button').last());
+        await (0, test_1.expect)(this.menuItemTree.filter({ hasText: name }).last().locator('#caret-button').last()).toBeVisible();
+        await this.menuItemTree.filter({ hasText: name }).last().locator('#caret-button').last().click();
     }
     async waitForModalVisible() {
         await this.openedModal.waitFor({ state: 'attached' });
@@ -426,11 +432,14 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         await this.openedModal.waitFor({ state: 'hidden' });
     }
     async clickSaveButtonForContent() {
-        await this.click(this.saveContentBtn);
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await (0, test_1.expect)(this.saveContentBtn).toBeVisible();
+        await this.saveContentBtn.click();
+        await this.page.waitForTimeout(500);
     }
     async enterTextstring(text) {
-        await this.enterText(this.textstringTxt, text);
+        await (0, test_1.expect)(this.textstringTxt).toBeVisible();
+        await this.textstringTxt.clear();
+        await this.textstringTxt.fill(text);
     }
     async isTextstringPropertyVisible(isVisible = true) {
         if (isVisible) {
@@ -441,162 +450,170 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         }
     }
     async doesContentTreeHaveName(contentName) {
-        await this.containsText(this.contentTree, contentName);
+        await (0, test_1.expect)(this.contentTree).toContainText(contentName);
     }
     async enterRichTextArea(value) {
-        await this.waitForVisible(this.richTextAreaTxt);
+        await (0, test_1.expect)(this.richTextAreaTxt).toBeVisible();
         await this.richTextAreaTxt.fill(value);
     }
     async enterTextArea(value) {
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.minimal);
-        await this.enterText(this.textAreaTxt, value);
+        await (0, test_1.expect)(this.textAreaTxt).toBeVisible();
+        await this.page.waitForTimeout(200);
+        await this.textAreaTxt.clear();
+        await this.textAreaTxt.fill(value);
     }
     async clickConfirmToUnpublishButton() {
-        await this.click(this.confirmToUnpublishBtn);
+        await this.confirmToUnpublishBtn.click();
     }
     async clickCreateDocumentBlueprintButton() {
-        await this.click(this.createDocumentBlueprintBtn);
+        await this.createDocumentBlueprintBtn.click();
     }
     // Info Tab
     async clickInfoTab() {
-        await this.click(this.infoTab);
+        await (0, test_1.expect)(this.infoTab).toBeVisible();
+        await this.infoTab.click();
     }
     async doesDocumentHaveLink(link) {
-        await this.containsText(this.linkContent, link);
+        await (0, test_1.expect)(this.linkContent).toContainText(link);
     }
     async doesHistoryHaveText(text) {
-        await this.hasText(this.historyItems, text);
+        await (0, test_1.expect)(this.historyItems).toHaveText(text);
     }
     async doesDocumentStateHaveText(text) {
-        await this.hasText(this.documentState, text);
+        await (0, test_1.expect)(this.documentState).toHaveText(text);
     }
     async doesCreatedDateHaveText(text) {
-        await this.hasText(this.createdDate, text);
+        await (0, test_1.expect)(this.createdDate).toHaveText(text);
     }
     async doesIdHaveText(text) {
-        await this.hasText(this.id, text);
+        await (0, test_1.expect)(this.id).toHaveText(text);
     }
     async clickEditDocumentTypeButton() {
-        await this.click(this.editDocumentTypeBtn);
+        await this.editDocumentTypeBtn.click();
     }
     async clickAddTemplateButton() {
-        await this.click(this.addTemplateBtn);
+        await this.addTemplateBtn.click();
     }
     async waitForContentToBeCreated() {
-        await this.waitForLoadState();
-        // Extra wait as content creation seems to take a bit longer sometimes
-        await this.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await this.page.waitForLoadState();
     }
     async waitForContentToBeDeleted() {
-        await this.waitForLoadState();
+        await this.page.waitForLoadState();
     }
     async waitForContentToBeRenamed() {
-        await this.waitForLoadState();
+        await this.page.waitForLoadState();
     }
     async waitForDomainToBeCreated() {
-        await this.waitForLoadState();
+        await this.page.waitForLoadState();
     }
     async waitForDomainToBeUpdated() {
-        await this.waitForLoadState();
+        await this.page.waitForLoadState();
     }
     async waitForDomainToBeDeleted() {
-        await this.waitForLoadState();
+        await this.page.waitForLoadState();
     }
     async waitForContentToBeTrashed() {
-        await this.waitForLoadState();
+        await this.page.waitForLoadState();
     }
     async clickDocumentTypeByName(documentTypeName) {
-        await this.click(this.page.locator(`uui-ref-node-document-type[name="${documentTypeName}"]`));
+        await this.page.locator('uui-ref-node-document-type[name="' + documentTypeName + '"]').click();
     }
     async clickTemplateByName(templateName) {
-        await this.click(this.page.locator(`uui-ref-node[name="${templateName}"]`));
+        await this.page.locator('uui-ref-node[name="' + templateName + '"]').click();
     }
     async isDocumentTypeModalVisible(documentTypeName) {
-        await this.isVisible(this.documentTypeWorkspace.filter({ hasText: documentTypeName }));
+        await (0, test_1.expect)(this.documentTypeWorkspace.filter({ hasText: documentTypeName })).toBeVisible();
     }
     async isTemplateModalVisible(templateName) {
-        await this.isVisible(this.breadcrumbsTemplateModal.getByText(templateName));
+        await (0, test_1.expect)(this.breadcrumbsTemplateModal.getByText(templateName)).toBeVisible();
     }
     async clickEditTemplateByName(templateName) {
-        await this.click(this.page.locator(`uui-ref-node[name="${templateName}"]`).getByLabel('Choose'));
+        await this.page.locator('uui-ref-node[name="' + templateName + '"]').getByLabel('Choose').click();
     }
     async changeTemplate(oldTemplate, newTemplate) {
         await this.clickEditTemplateByName(oldTemplate);
-        await this.click(this.sidebarModal.getByLabel(newTemplate));
+        await this.sidebarModal.getByLabel(newTemplate).click();
         await this.clickChooseModalButton();
     }
     async isTemplateNameDisabled(templateName) {
-        await this.isVisible(this.sidebarModal.getByLabel(templateName));
-        await this.isDisabled(this.sidebarModal.getByLabel(templateName));
+        await (0, test_1.expect)(this.sidebarModal.getByLabel(templateName)).toBeVisible();
+        await (0, test_1.expect)(this.sidebarModal.getByLabel(templateName)).toBeDisabled();
     }
     // Culture and Hostnames
     async clickCultureAndHostnamesButton() {
-        await this.click(this.cultureAndHostnamesBtn);
+        await this.cultureAndHostnamesBtn.click();
     }
     async clickAddNewHostnameButton() {
-        await this.click(this.addNewHostnameBtn);
+        await (0, test_1.expect)(this.addNewHostnameBtn).toBeVisible();
+        await this.addNewHostnameBtn.click();
     }
     async selectCultureLanguageOption(option) {
-        await this.click(this.cultureLanguageDropdownBox);
-        await this.click(this.page.getByText(option, { exact: true }));
+        await (0, test_1.expect)(this.cultureLanguageDropdownBox).toBeVisible();
+        await this.cultureLanguageDropdownBox.click();
+        await (0, test_1.expect)(this.page.getByText(option, { exact: true })).toBeVisible();
+        await this.page.getByText(option, { exact: true }).click();
     }
     async selectHostnameLanguageOption(option, index = 0) {
-        await this.click(this.hostnameLanguageDropdownBox.nth(index));
-        await this.click(this.hostnameComboBox.getByText(option).nth(index));
+        await this.hostnameLanguageDropdownBox.nth(index).click();
+        await this.hostnameComboBox.getByText(option).nth(index).click();
     }
     async enterDomain(value, index = 0) {
-        await this.enterText(this.hostnameTxt.nth(index), value, { verify: true });
+        await (0, test_1.expect)(this.hostnameTxt.nth(index)).toBeVisible();
+        await this.hostnameTxt.nth(index).clear();
+        await this.hostnameTxt.nth(index).fill(value);
+        await (0, test_1.expect)(this.hostnameTxt.nth(index)).toHaveValue(value);
     }
     async clickDeleteHostnameButton() {
-        await this.click(this.deleteHostnameBtn.first());
+        await this.deleteHostnameBtn.first().click();
     }
     async clickSaveModalButton() {
-        await this.click(this.saveModalBtn);
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await this.saveModalBtn.click();
+        await this.page.waitForTimeout(500);
     }
     async chooseDocumentType(documentTypeName) {
-        await this.click(this.documentTypeNode.filter({ hasText: documentTypeName }));
+        await this.documentTypeNode.filter({ hasText: documentTypeName }).click();
     }
     // Approved Color
     async clickApprovedColorByValue(value) {
-        await this.click(this.page.locator(`uui-color-swatch[value="#${value}"] #swatch`));
+        await this.page.locator('uui-color-swatch[value="#' + value + '"] #swatch').click();
     }
     // Checkbox list
     async chooseCheckboxListOption(optionValue) {
-        await this.click(this.page.locator(`uui-checkbox[value="${optionValue}"] svg`));
+        await this.page.locator('uui-checkbox[value="' + optionValue + '"] svg').click();
     }
     // Content Picker
     async addContentPicker(contentName) {
         await this.clickChooseButton();
-        await this.click(this.sidebarModal.getByText(contentName));
-        await this.click(this.chooseModalBtn);
+        await this.sidebarModal.getByText(contentName).click();
+        await this.chooseModalBtn.click();
     }
     async isOpenButtonVisibleInContentPicker(contentPickerName, isVisible = true) {
-        return await this.isVisible(this.page.getByLabel('Open ' + contentPickerName), isVisible);
+        return (0, test_1.expect)(this.page.getByLabel('Open ' + contentPickerName)).toBeVisible({ visible: isVisible });
     }
     async clickContentPickerOpenButton(contentPickerName) {
-        await this.click(this.page.getByLabel('Open ' + contentPickerName));
+        await this.page.getByLabel('Open ' + contentPickerName).click();
     }
     async isNodeOpenForContentPicker(contentPickerName) {
-        return await this.isVisible(this.openedModal.getByText(contentPickerName));
+        return (0, test_1.expect)(this.openedModal.getByText(contentPickerName)).toBeVisible();
     }
     async isContentNameVisible(contentName, isVisible = true) {
-        return await this.isVisible(this.sidebarModal.getByText(contentName), isVisible);
+        return (0, test_1.expect)(this.sidebarModal.getByText(contentName)).toBeVisible({ visible: isVisible });
     }
     async isContentInTreeVisible(name, isVisible = true) {
-        await this.isVisible(this.documentTreeItem.getByLabel(name, { exact: true }).first(), isVisible);
+        await (0, test_1.expect)(this.documentTreeItem.getByLabel(name, { exact: true }).first()).toBeVisible({ visible: isVisible });
     }
     async isChildContentInTreeVisible(parentName, childName, isVisible = true) {
-        await this.isVisible(this.documentTreeItem.locator('[label="' + parentName + '"]').locator('uui-menu-item[label="' + childName + '"]'), isVisible);
+        await (0, test_1.expect)(this.documentTreeItem.locator('[label="' + parentName + '"]').getByLabel(childName)).toBeVisible({ visible: isVisible });
     }
     async removeContentPicker(contentPickerName) {
-        const contentPickerLocator = this.entityItem.filter({ has: this.page.locator(`[name="${contentPickerName}"]`) });
-        await this.hoverAndClick(contentPickerLocator, contentPickerLocator.getByLabel('Remove'));
+        const contentPickerLocator = this.entityItem.filter({ has: this.page.locator('[name="' + contentPickerName + '"]') });
+        await contentPickerLocator.hover();
+        await contentPickerLocator.getByLabel('Remove').click();
         await this.clickConfirmRemoveButton();
     }
     // Dropdown
     async chooseDropdownOption(optionValues) {
-        await this.selectMultiple(this.dropdown, optionValues);
+        await this.dropdown.selectOption(optionValues);
     }
     // Date Picker
     async enterADate(date) {
@@ -604,7 +621,7 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
     }
     // Media Picker
     async clickChooseMediaPickerButton() {
-        await this.click(this.chooseMediaPickerBtn);
+        await this.chooseMediaPickerBtn.click();
     }
     async clickChooseButtonAndSelectMediaWithName(mediaName) {
         await this.clickChooseMediaPickerButton();
@@ -615,17 +632,17 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         await this.selectMediaWithTestId(mediaKey);
     }
     async removeMediaPickerByName(mediaPickerName) {
-        await this.click(this.page.locator(`[name="${mediaPickerName}"] [label="Remove"] svg`));
+        await this.page.locator('[name="' + mediaPickerName + '"] [label="Remove"] svg').click();
         await this.clickConfirmRemoveButton();
     }
     async isMediaNameVisible(mediaName, isVisible = true) {
-        return await this.isVisible(this.mediaCardItems.filter({ hasText: mediaName }), isVisible);
+        return (0, test_1.expect)(this.mediaCardItems.filter({ hasText: mediaName })).toBeVisible({ visible: isVisible });
     }
     async clickResetFocalPointButton() {
-        await this.click(this.resetFocalPointBtn);
+        await this.resetFocalPointBtn.click();
     }
     async setFocalPoint(widthPercentage = 50, heightPercentage = 50) {
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.medium);
+        await this.page.waitForTimeout(1000);
         const element = await this.page.locator('#image').boundingBox();
         if (!element) {
             throw new Error('Element not found');
@@ -634,104 +651,111 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         const centerY = element.y + element.height / 2;
         const x = element.x + (element.width * widthPercentage) / 100;
         const y = element.y + (element.height * heightPercentage) / 100;
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.minimal);
+        await this.page.waitForTimeout(200);
         await this.page.mouse.move(centerX, centerY, { steps: 5 });
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.minimal);
+        await this.page.waitForTimeout(200);
         await this.page.mouse.down();
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.minimal);
+        await this.page.waitForTimeout(200);
         await this.page.mouse.move(x, y);
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.minimal);
+        await this.page.waitForTimeout(200);
         await this.page.mouse.up();
     }
     // Member Picker
     async clickChooseMemberPickerButton() {
-        await this.click(this.chooseMemberPickerBtn);
+        await this.chooseMemberPickerBtn.click();
     }
     async selectMemberByName(memberName) {
-        await this.click(this.sidebarModal.getByText(memberName, { exact: true }));
+        await this.sidebarModal.getByText(memberName, { exact: true }).click();
     }
     async removeMemberPickerByName(memberName) {
-        const mediaPickerLocator = this.entityItem.filter({ has: this.page.locator(`[name="${memberName}"]`) });
-        await this.hoverAndClick(mediaPickerLocator, mediaPickerLocator.getByLabel('Remove'));
+        const mediaPickerLocator = this.entityItem.filter({ has: this.page.locator('[name="' + memberName + '"]') });
+        await mediaPickerLocator.hover();
+        await mediaPickerLocator.getByLabel('Remove').click();
         await this.clickConfirmRemoveButton();
     }
     // Numeric
     async enterNumeric(number) {
-        await this.enterText(this.numericTxt, number.toString());
+        await this.numericTxt.clear();
+        await this.numericTxt.fill(number.toString());
     }
     // Radiobox
     async chooseRadioboxOption(optionValue) {
-        await this.click(this.page.locator(`uui-radio[value="${optionValue}"] #button`));
+        await this.page.locator('uui-radio[value="' + optionValue + '"] #button').click();
     }
     // Tags
     async clickPlusIconButton() {
-        await this.click(this.plusIconBtn);
+        await this.plusIconBtn.click();
     }
     async enterTag(tagName) {
-        await this.enterText(this.enterTagTxt, tagName);
-        await this.pressKey(this.enterTagTxt, 'Enter');
+        await this.enterTagTxt.fill(tagName);
+        await this.enterTagTxt.press('Enter');
     }
     async removeTagByName(tagName) {
-        await this.click(this.tagItems.filter({ hasText: tagName }).locator('svg'));
+        await (0, test_1.expect)(this.tagItems.filter({ hasText: tagName }).locator('svg')).toBeVisible();
+        await this.tagItems.filter({ hasText: tagName }).locator('svg').click();
     }
     // Multi URL Picker
     async clickAddMultiURLPickerButton() {
-        await this.click(this.addMultiURLPickerBtn);
+        await this.addMultiURLPickerBtn.click();
     }
     async selectLinkByName(linkName) {
-        await this.click(this.sidebarModal.getByText(linkName, { exact: true }));
+        await (0, test_1.expect)(this.sidebarModal.getByText(linkName, { exact: true })).toBeVisible();
+        await this.sidebarModal.getByText(linkName, { exact: true }).click();
     }
     async enterLink(value, toPress = false) {
+        await this.linkTxt.clear();
         if (toPress) {
-            await this.enterText(this.linkTxt, '');
-            await this.pressKey(this.linkTxt, value);
+            await this.linkTxt.press(value);
         }
         else {
-            await this.enterText(this.linkTxt, value);
+            await this.linkTxt.fill(value);
         }
     }
     async enterAnchorOrQuerystring(value, toPress = false) {
+        await this.anchorQuerystringTxt.clear();
         if (toPress) {
-            await this.enterText(this.anchorQuerystringTxt, '');
-            await this.pressKey(this.anchorQuerystringTxt, value);
+            await this.anchorQuerystringTxt.press(value);
         }
         else {
-            await this.enterText(this.anchorQuerystringTxt, value);
+            await this.anchorQuerystringTxt.fill(value);
         }
     }
     async enterLinkTitle(value, toPress = false) {
+        await this.linkTitleTxt.clear();
         if (toPress) {
-            await this.enterText(this.linkTitleTxt, '');
-            await this.pressKey(this.linkTitleTxt, value);
+            await this.linkTitleTxt.press(value);
         }
         else {
-            await this.enterText(this.linkTitleTxt, value);
+            await this.linkTitleTxt.fill(value);
         }
     }
     async removeUrlPickerByName(linkName) {
-        await this.click(this.page.locator(`[name="${linkName}"]`).getByLabel('Remove'));
+        await this.page.locator('[name="' + linkName + '"]').getByLabel('Remove').click();
         await this.clickConfirmRemoveButton();
     }
     async clickEditUrlPickerButtonByName(linkName) {
-        await this.click(this.page.locator(`[name="${linkName}"]`).getByLabel('Edit'));
+        await this.page.locator('[name="' + linkName + '"]').getByLabel('Edit').click();
     }
     // Upload
     async clickRemoveFilesButton() {
-        await this.click(this.removeFilesBtn);
+        await (0, test_1.expect)(this.removeFilesBtn).toBeVisible();
+        await this.removeFilesBtn.click();
     }
     // True/false
     async clickToggleButton() {
-        await this.click(this.toggleBtn, { force: true });
+        await (0, test_1.expect)(this.toggleBtn).toBeVisible();
+        await this.toggleBtn.click({ force: true });
     }
     async doesToggleHaveLabel(label) {
-        await this.hasText(this.toggleInput, label);
+        return await (0, test_1.expect)(this.toggleInput).toHaveText(label);
     }
     // Multiple Text String
     async clickAddMultipleTextStringButton() {
-        await this.click(this.addMultipleTextStringBtn);
+        await this.addMultipleTextStringBtn.click();
     }
     async enterMultipleTextStringValue(value) {
-        await this.enterText(this.multipleTextStringValueTxt, value);
+        await this.multipleTextStringValueTxt.clear();
+        await this.multipleTextStringValueTxt.fill(value);
     }
     async addMultipleTextStringItem(value) {
         await this.clickAddMultipleTextStringButton();
@@ -750,119 +774,134 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         await this.sliderInput.fill(value);
     }
     async isDocumentTypeNameVisible(contentName, isVisible = true) {
-        return await this.isVisible(this.sidebarModal.getByText(contentName), isVisible);
+        return (0, test_1.expect)(this.sidebarModal.getByText(contentName)).toBeVisible({ visible: isVisible });
     }
     async doesModalHaveText(text) {
-        await this.containsText(this.openedModal, text);
+        return (0, test_1.expect)(this.openedModal).toContainText(text);
     }
     // Collection tab
     async isTabNameVisible(tabName) {
-        return await this.isVisible(this.tabItems.filter({ hasText: tabName }));
+        return (0, test_1.expect)(this.tabItems.filter({ hasText: tabName })).toBeVisible();
     }
     async clickTabWithName(tabName) {
         const tabLocator = this.tabItems.filter({ hasText: tabName });
-        await this.click(tabLocator);
+        await (0, test_1.expect)(tabLocator).toBeVisible();
+        await tabLocator.click();
     }
     async doesDocumentHaveName(name) {
-        await this.hasValue(this.enterAName, name);
+        return (0, test_1.expect)(this.enterAName).toHaveValue(name);
     }
     async doesDocumentTableColumnNameValuesMatch(expectedValues) {
-        await this.waitForVisible(this.documentListView);
+        await (0, test_1.expect)(this.documentListView).toBeVisible();
         return expectedValues.forEach((text, index) => {
             (0, test_1.expect)(this.documentTableColumnName.nth(index)).toHaveText(text);
         });
     }
     async searchByKeywordInCollection(keyword) {
-        await this.enterText(this.searchTxt, keyword);
-        await this.pressKey(this.searchTxt, 'Enter');
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await this.searchTxt.clear();
+        await this.searchTxt.fill(keyword);
+        await this.searchTxt.press('Enter');
+        await this.page.waitForTimeout(500);
     }
     async clickSelectVariantButton() {
-        await this.click(this.selectAVariantBtn);
+        await (0, test_1.expect)(this.selectAVariantBtn).toBeVisible();
+        await this.selectAVariantBtn.click();
     }
     async clickVariantAddModeButtonForLanguageName(language) {
-        await this.click(this.variantAddModeBtn.getByText(language));
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await this.variantAddModeBtn.getByText(language).click();
+        await this.page.waitForTimeout(500);
     }
     async clickSaveAndCloseButton() {
-        await this.click(this.saveAndCloseBtn);
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await this.saveAndCloseBtn.click();
+        await this.page.waitForTimeout(500);
     }
     // List View
     async clickCreateContentWithName(name) {
-        await this.click(this.page.getByLabel(`Create ${name}`));
+        await (0, test_1.expect)(this.page.getByLabel('Create ' + name)).toBeVisible();
+        await this.page.getByLabel('Create ' + name).click();
     }
     async enterNameInContainer(name) {
-        await this.enterText(this.enterNameInContainerTxt, name);
+        await (0, test_1.expect)(this.enterNameInContainerTxt).toBeVisible();
+        await this.enterNameInContainerTxt.clear();
+        await this.enterNameInContainerTxt.fill(name);
     }
     async goToContentInListViewWithName(contentName) {
-        await this.click(this.listView.getByLabel(contentName));
+        await this.listView.getByLabel(contentName).click();
     }
     async doesListViewHaveNoItemsInList() {
-        await this.isVisible(this.listView.filter({ hasText: 'There are no items to show in the list.' }));
+        await (0, test_1.expect)(this.listView.filter({ hasText: 'There are no items to show in the list.' })).toBeVisible();
     }
     async doesContentListHaveNoItemsInList() {
-        await this.isVisible(this.umbDocumentCollection.filter({ hasText: 'No items' }));
+        await (0, test_1.expect)(this.umbDocumentCollection.filter({ hasText: 'No items' })).toBeVisible();
     }
     async clickNameButtonInListView() {
-        await this.click(this.nameBtn);
+        await this.nameBtn.click();
     }
     async doesFirstItemInListViewHaveName(name) {
         await (0, test_1.expect)(this.listViewTableRow.first()).toContainText(name);
     }
     async doesListViewContainCount(count) {
-        await this.hasCount(this.listViewTableRow, count);
+        await (0, test_1.expect)(this.listViewTableRow).toHaveCount(count);
     }
     async selectContentWithNameInListView(name) {
-        await this.click(this.listViewTableRow.filter({ hasText: name }));
+        const contentInListViewLocator = this.listViewTableRow.filter({ hasText: name });
+        await (0, test_1.expect)(contentInListViewLocator).toBeVisible();
+        await contentInListViewLocator.click();
     }
     async clickPublishSelectedListItems() {
-        await this.click(this.publishSelectedListItems);
+        await this.publishSelectedListItems.click();
     }
     async clickUnpublishSelectedListItems() {
-        await this.click(this.unpublishSelectedListItems);
+        await this.unpublishSelectedListItems.click();
     }
     async clickDuplicateToSelectedListItems() {
-        // Force click is needed
-        await this.click(this.duplicateToSelectedListItems, { force: true });
+        await (0, test_1.expect)(this.duplicateToSelectedListItems).toBeVisible();
+        // This force click is needed 
+        await this.duplicateToSelectedListItems.click({ force: true });
     }
     async clickMoveToSelectedListItems() {
-        // Force click is needed
-        await this.click(this.moveToSelectedListItems, { force: true });
+        await (0, test_1.expect)(this.moveToSelectedListItems).toBeVisible();
+        // This force click is needed
+        await this.moveToSelectedListItems.click({ force: true });
     }
     async clickTrashSelectedListItems() {
-        await this.click(this.trashSelectedListItems);
+        await this.trashSelectedListItems.click();
     }
     async selectDocumentWithNameAtRoot(name) {
         await this.openCaretButtonForName('Content');
-        await this.click(this.modalContent.getByLabel(name));
+        const documentWithNameLocator = this.modalContent.getByLabel(name);
+        await (0, test_1.expect)(documentWithNameLocator).toBeVisible();
+        await documentWithNameLocator.click();
         await this.clickChooseButton();
     }
     async clickTrashButton() {
-        await this.click(this.trashBtn);
+        await (0, test_1.expect)(this.trashBtn).toBeVisible();
+        await this.trashBtn.click();
     }
     async clickExactTrashButton() {
-        await this.click(this.exactTrashBtn);
+        await this.exactTrashBtn.click();
     }
     async isDocumentListViewVisible(isVisible = true) {
-        await this.isVisible(this.documentListView, isVisible);
+        await (0, test_1.expect)(this.documentListView).toBeVisible({ visible: isVisible });
     }
     async isDocumentGridViewVisible(isVisible = true) {
-        await this.isVisible(this.documentGridView, isVisible);
+        await (0, test_1.expect)(this.documentGridView).toBeVisible({ visible: isVisible });
     }
     async changeDocumentSectionLanguage(newLanguageName) {
-        await this.click(this.documentLanguageSelect);
+        await this.documentLanguageSelect.click();
+        const documentSectionLanguageLocator = this.documentLanguageSelectPopover.getByText(newLanguageName);
+        await (0, test_1.expect)(documentSectionLanguageLocator).toBeVisible();
         // Force click is needed
-        await this.click(this.documentLanguageSelectPopover.getByText(newLanguageName), { force: true });
+        await documentSectionLanguageLocator.click({ force: true });
     }
     async doesDocumentSectionHaveLanguageSelected(languageName) {
-        await this.hasText(this.documentLanguageSelect, languageName);
+        await (0, test_1.expect)(this.documentLanguageSelect).toHaveText(languageName);
     }
     async isDocumentReadOnly(isVisible = true) {
-        await this.isVisible(this.documentReadOnly, isVisible);
+        await (0, test_1.expect)(this.documentReadOnly).toBeVisible({ visible: isVisible });
     }
     async isDocumentNameInputEditable(isEditable = true) {
-        await this.waitForVisible(this.contentNameTxt);
+        await (0, test_1.expect)(this.contentNameTxt).toBeVisible();
         await (0, test_1.expect)(this.contentNameTxt).toBeEditable({ editable: isEditable });
     }
     async isActionsMenuForRecycleBinVisible(isVisible = true) {
@@ -872,235 +911,282 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         await this.isActionsMenuForNameVisible('Content', isVisible);
     }
     async clickEmptyRecycleBinButton() {
-        await this.hover(this.recycleBinMenuItem);
+        await this.recycleBinMenuItem.hover();
+        await (0, test_1.expect)(this.emptyRecycleBinBtn).toBeVisible();
         // Force click is needed
-        await this.click(this.emptyRecycleBinBtn, { force: true });
+        await this.emptyRecycleBinBtn.click({ force: true });
     }
     async clickConfirmEmptyRecycleBinButton() {
-        await this.click(this.confirmEmptyRecycleBinBtn);
+        await this.confirmEmptyRecycleBinBtn.click();
     }
     async isDocumentPropertyEditable(propertyName, isEditable = true) {
         const propertyLocator = this.documentWorkspace.locator(this.property).filter({ hasText: propertyName }).locator('#input');
-        await this.waitForVisible(propertyLocator);
+        await (0, test_1.expect)(propertyLocator).toBeVisible();
         await (0, test_1.expect)(propertyLocator).toBeEditable({ editable: isEditable });
     }
     async doesDocumentPropertyHaveValue(propertyName, value) {
         const propertyLocator = this.documentWorkspace.locator(this.property).filter({ hasText: propertyName }).locator('#input');
-        await this.hasValue(propertyLocator, value);
+        await (0, test_1.expect)(propertyLocator).toHaveValue(value);
     }
     async clickContentTab() {
-        await this.click(this.splitView.getByRole('tab', { name: 'Content' }));
+        await this.splitView.getByRole('tab', { name: 'Content' }).click();
     }
     async isDocumentTreeEmpty() {
-        await this.hasCount(this.documentTreeItem, 0);
+        await (0, test_1.expect)(this.documentTreeItem).toHaveCount(0);
     }
     async doesDocumentWorkspaceContainName(name) {
         await (0, test_1.expect)(this.documentWorkspaceEditor.locator('#input')).toHaveValue(name);
     }
     async doesDocumentWorkspaceHaveText(text) {
-        await this.containsText(this.documentWorkspace, text);
+        return (0, test_1.expect)(this.documentWorkspace).toContainText(text);
     }
     async enterDocumentBlueprintName(name) {
-        await this.enterText(this.documentBlueprintModalEnterNameTxt, name);
+        await this.documentBlueprintModalEnterNameTxt.clear();
+        await this.documentBlueprintModalEnterNameTxt.fill(name);
     }
     async clickSaveDocumentBlueprintButton() {
-        await this.click(this.documentBlueprintSaveBtn);
+        await this.documentBlueprintSaveBtn.click();
     }
     async clickDuplicateToButton() {
-        await this.click(this.duplicateToBtn);
+        await this.duplicateToBtn.click();
     }
     async clickDuplicateButton() {
-        await this.click(this.duplicateBtn);
+        await this.duplicateBtn.click();
     }
     async clickMoveToButton() {
-        await this.click(this.moveToBtn);
+        await this.moveToBtn.click();
     }
     async moveToContentWithName(parentNames, moveTo) {
         for (const contentName of parentNames) {
-            await this.click(this.container.getByLabel(`Expand child items for ${contentName}`));
+            await this.container.getByLabel('Expand child items for ' + contentName).click();
         }
-        await this.click(this.container.getByLabel(moveTo));
+        await this.container.getByLabel(moveTo).click();
         await this.clickChooseContainerButton();
     }
     async isCaretButtonVisibleForContentName(contentName, isVisible = true) {
-        await this.isVisible(this.page.locator(`[label="${contentName}"]`).getByLabel('Expand child items for '), isVisible);
+        await (0, test_1.expect)(this.page.locator('[label="' + contentName + '"]').getByLabel('Expand child items for ')).toBeVisible({ visible: isVisible });
     }
     async reloadContentTree() {
+        await (0, test_1.expect)(this.contentTreeRefreshBtn).toBeVisible();
         // Force click is needed
-        await this.click(this.contentTreeRefreshBtn, { force: true });
+        await this.contentTreeRefreshBtn.click({ force: true });
     }
     async clickSortChildrenButton() {
-        await this.click(this.sortChildrenBtn);
+        await (0, test_1.expect)(this.sortChildrenBtn).toBeVisible();
+        await this.sortChildrenBtn.click();
     }
     async clickRollbackButton() {
-        await this.click(this.rollbackBtn);
+        await (0, test_1.expect)(this.rollbackBtn).toBeVisible();
+        await this.rollbackBtn.click();
     }
     async clickRollbackContainerButton() {
-        await this.click(this.rollbackContainerBtn);
+        await (0, test_1.expect)(this.rollbackContainerBtn).toBeVisible();
+        await this.rollbackContainerBtn.click();
     }
     async clickLatestRollBackItem() {
-        await this.click(this.rollbackItem.last());
+        await (0, test_1.expect)(this.rollbackItem.last()).toBeVisible();
+        await this.rollbackItem.last().click();
     }
     async clickPublicAccessButton() {
-        await this.click(this.publicAccessBtn);
+        await (0, test_1.expect)(this.publicAccessBtn).toBeVisible();
+        await this.publicAccessBtn.click();
     }
     async addGroupBasedPublicAccess(memberGroupName, documentName) {
-        await this.click(this.groupBasedProtectionBtn);
+        await (0, test_1.expect)(this.groupBasedProtectionBtn).toBeVisible();
+        await this.groupBasedProtectionBtn.click();
         await this.clickNextButton();
-        await this.click(this.chooseMemberGroupBtn);
-        await this.click(this.page.getByLabel(memberGroupName));
+        await this.chooseMemberGroupBtn.click();
+        await this.page.getByLabel(memberGroupName).click();
         await this.clickChooseModalButton();
-        await this.click(this.selectLoginPageDocument);
-        await this.click(this.container.getByLabel(documentName, { exact: true }));
+        await this.selectLoginPageDocument.click();
+        await this.container.getByLabel(documentName, { exact: true }).click();
         await this.clickChooseModalButton();
-        await this.click(this.selectErrorPageDocument);
-        await this.click(this.container.getByLabel(documentName, { exact: true }));
+        await this.selectErrorPageDocument.click();
+        await this.container.getByLabel(documentName, { exact: true }).click();
         await this.clickChooseModalButton();
-        await this.click(this.containerSaveBtn);
+        await this.containerSaveBtn.click();
     }
     async sortChildrenDragAndDrop(dragFromSelector, dragToSelector, verticalOffset = 0, horizontalOffset = 0, steps = 5) {
-        await this.waitForVisible(dragFromSelector);
-        await this.waitForVisible(dragToSelector);
+        await (0, test_1.expect)(dragFromSelector).toBeVisible();
+        await (0, test_1.expect)(dragToSelector).toBeVisible();
         const targetLocation = await dragToSelector.boundingBox();
         const elementCenterX = targetLocation.x + targetLocation.width / 2;
         const elementCenterY = targetLocation.y + targetLocation.height / 2;
-        await this.hover(dragFromSelector);
+        await dragFromSelector.hover();
         await this.page.mouse.move(10, 10);
-        await this.hover(dragFromSelector);
+        await dragFromSelector.hover();
         await this.page.mouse.down();
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.debounce);
+        await this.page.waitForTimeout(400);
         await this.page.mouse.move(elementCenterX + horizontalOffset, elementCenterY + verticalOffset, { steps: steps });
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.debounce);
+        await this.page.waitForTimeout(400);
         // If we do not have this, the drag and drop will not work
-        await this.hover(dragToSelector);
+        await dragToSelector.hover();
         await this.page.mouse.up();
     }
     async clickSortButton() {
-        await this.click(this.sortBtn);
+        await (0, test_1.expect)(this.sortBtn).toBeVisible();
+        await this.sortBtn.click();
     }
     async doesIndexDocumentInTreeContainName(parentName, childName, index) {
-        await (0, test_1.expect)(this.documentTreeItem.locator(`[label="${parentName}"]`).locator('umb-tree-item').nth(index).locator('#label')).toHaveText(childName);
+        await (0, test_1.expect)(this.documentTreeItem.locator('[label="' + parentName + '"]').locator('umb-tree-item').nth(index).locator('#label')).toHaveText(childName);
     }
     async selectMemberGroup(memberGroupName) {
-        await this.click(this.uuiCheckbox.getByLabel(memberGroupName));
+        await (0, test_1.expect)(this.uuiCheckbox.getByLabel(memberGroupName)).toBeVisible();
+        await this.uuiCheckbox.getByLabel(memberGroupName).click();
     }
     async isPermissionInActionsMenuVisible(permissionName, isVisible = true) {
-        await this.isVisible(this.actionsMenu.getByRole('button', {
+        await (0, test_1.expect)(this.actionsMenu.getByRole('button', {
             name: permissionName,
             exact: true
-        }), isVisible);
+        })).toBeVisible({ visible: isVisible });
     }
     async clickDocumentLinkButton() {
-        await this.click(this.linkToDocumentBtn);
+        await (0, test_1.expect)(this.linkToDocumentBtn).toBeVisible();
+        await this.linkToDocumentBtn.click();
     }
     async clickMediaLinkButton() {
-        await this.click(this.linkToMediaBtn);
+        await (0, test_1.expect)(this.linkToMediaBtn).toBeVisible();
+        await this.linkToMediaBtn.click();
     }
     async clickManualLinkButton() {
-        await this.click(this.linkToManualBtn);
+        await (0, test_1.expect)(this.linkToManualBtn).toBeVisible();
+        await this.linkToManualBtn.click();
     }
     // Block Grid - Block List
     async clickAddBlockElementButton() {
-        await this.click(this.addBlockElementBtn);
+        await (0, test_1.expect)(this.addBlockElementBtn).toBeVisible();
+        await this.addBlockElementBtn.click();
     }
     async clickAddBlockWithNameButton(name) {
-        await this.click(this.page.getByLabel(`Add ${name}`));
+        await (0, test_1.expect)(this.page.getByLabel('Add ' + name)).toBeVisible();
+        await this.page.getByLabel('Add ' + name).click();
     }
     async clickCreateForModalWithHeadline(headline) {
-        await this.click(this.page.locator(`[headline="${headline}"]`).getByLabel('Create'));
+        await (0, test_1.expect)(this.page.locator('[headline="' + headline + '"]').getByLabel('Create')).toBeVisible();
+        await this.page.locator('[headline="' + headline + '"]').getByLabel('Create').click();
     }
     async isAddBlockElementButtonVisible(isVisible = true) {
-        await this.isVisible(this.addBlockElementBtn, isVisible);
+        await (0, test_1.expect)(this.addBlockElementBtn).toBeVisible({ visible: isVisible });
     }
     async isAddBlockElementButtonWithLabelVisible(blockName, label, isVisible = true) {
-        await this.isVisible(this.property.filter({ hasText: blockName }).locator(this.addBlockElementBtn).filter({ hasText: label }), isVisible);
+        await (0, test_1.expect)(this.property.filter({ hasText: blockName }).locator(this.addBlockElementBtn).filter({ hasText: label })).toBeVisible({ visible: isVisible });
     }
     async doesFormValidationMessageContainText(text) {
-        await this.containsText(this.formValidationMessage, text);
+        await (0, test_1.expect)(this.formValidationMessage).toContainText(text);
     }
     async doesBlockElementHaveName(name) {
-        await this.containsText(this.blockName, name);
+        await (0, test_1.expect)(this.blockName).toContainText(name);
     }
     async clickAddBlockSettingsTabButton() {
-        await this.click(this.addBlockSettingsTabBtn);
+        await (0, test_1.expect)(this.addBlockSettingsTabBtn).toBeVisible();
+        await this.addBlockSettingsTabBtn.click();
     }
     async clickEditBlockGridBlockButton() {
-        await this.hoverAndClick(this.blockGridEntry, this.editBlockEntryBtn);
+        await (0, test_1.expect)(this.blockGridEntry).toBeVisible();
+        await this.blockGridEntry.hover();
+        await (0, test_1.expect)(this.editBlockEntryBtn).toBeVisible();
+        await this.editBlockEntryBtn.click();
     }
     async clickDeleteBlockGridBlockButton() {
-        await this.hoverAndClick(this.blockGridEntry, this.deleteBlockEntryBtn);
+        await (0, test_1.expect)(this.blockGridEntry).toBeVisible();
+        await this.blockGridEntry.hover();
+        await (0, test_1.expect)(this.deleteBlockEntryBtn).toBeVisible();
+        await this.deleteBlockEntryBtn.click();
     }
     async clickEditBlockListBlockButton() {
-        await this.hoverAndClick(this.blockListEntry, this.editBlockEntryBtn);
+        await (0, test_1.expect)(this.blockListEntry).toBeVisible();
+        await this.blockListEntry.hover();
+        await (0, test_1.expect)(this.editBlockEntryBtn).toBeVisible();
+        await this.editBlockEntryBtn.click();
     }
     async clickDeleteBlockListBlockButton() {
-        await this.hoverAndClick(this.blockListEntry, this.deleteBlockEntryBtn);
+        await (0, test_1.expect)(this.blockListEntry).toBeVisible();
+        await this.blockListEntry.hover();
+        await (0, test_1.expect)(this.deleteBlockEntryBtn).toBeVisible();
+        await this.deleteBlockEntryBtn.click();
     }
     async clickCopyBlockListBlockButton(groupName, propertyName, blockName, index = 0) {
         const blockListBlock = this.workspaceEditTab.filter({ hasText: groupName }).locator(this.workspaceEditProperties).filter({ hasText: propertyName }).locator(this.blockListEntry).nth(index).filter({ hasText: blockName });
-        await this.hoverAndClick(blockListBlock, blockListBlock.locator(this.copyBlockEntryBtn), { force: true });
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await blockListBlock.hover();
+        await (0, test_1.expect)(blockListBlock.locator(this.copyBlockEntryBtn)).toBeVisible();
+        await blockListBlock.locator(this.copyBlockEntryBtn).click({ force: true });
+        await this.page.waitForTimeout(500);
     }
     async clickCopyBlockGridBlockButton(groupName, propertyName, blockName, index = 0) {
         const blockGridBlock = this.workspaceEditTab.filter({ hasText: groupName }).locator(this.workspaceEditProperties).filter({ hasText: propertyName }).locator(this.blockGridEntry).nth(index).filter({ hasText: blockName });
-        await this.hoverAndClick(blockGridBlock, blockGridBlock.locator(this.copyBlockEntryBtn), { force: true });
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await blockGridBlock.hover();
+        await (0, test_1.expect)(blockGridBlock.locator(this.copyBlockEntryBtn)).toBeVisible();
+        await blockGridBlock.locator(this.copyBlockEntryBtn).click({ force: true });
+        await this.page.waitForTimeout(500);
     }
     async clickPasteFromClipboardButtonForProperty(groupName, propertyName) {
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.short);
+        await this.page.waitForTimeout(500);
         const property = this.workspaceEditTab.filter({ hasText: groupName }).locator(this.property).filter({ hasText: propertyName });
-        await this.click(property.locator(this.pasteFromClipboardBtn), { force: true });
+        await (0, test_1.expect)(property).toBeVisible();
+        await (0, test_1.expect)(property.locator(this.pasteFromClipboardBtn)).toBeVisible();
+        await property.locator(this.pasteFromClipboardBtn).click({ force: true });
     }
     async clickActionsMenuForProperty(groupName, propertyName) {
         const property = this.workspaceEditTab.filter({ hasText: groupName }).locator(this.workspaceEditProperties).filter({ hasText: propertyName });
-        await this.hoverAndClick(property, property.locator(this.openActionsMenu), { force: true });
+        await property.hover();
+        await (0, test_1.expect)(property.locator(this.openActionsMenu)).toBeVisible();
+        await property.locator(this.openActionsMenu).click({ force: true });
     }
     async clickAddBlockGridElementWithName(elementTypeName) {
-        await this.click(this.page.getByRole('link', { name: `Add ${elementTypeName}`, exact: true }));
+        await (0, test_1.expect)(this.page.getByRole('link', { name: 'Add ' + elementTypeName, exact: true })).toBeVisible();
+        await this.page.getByRole('link', { name: 'Add ' + elementTypeName, exact: true }).click();
     }
     async clickEditBlockListEntryWithName(blockListElementName) {
-        await this.click(this.blockListEntry.filter({ hasText: blockListElementName }).getByLabel('edit'), { force: true });
+        await (0, test_1.expect)(this.blockListEntry.filter({ hasText: blockListElementName }).getByLabel('edit')).toBeVisible();
+        await this.blockListEntry.filter({ hasText: blockListElementName }).getByLabel('edit').click({ force: true });
     }
     async clickEditBlockGridEntryWithName(blockGridElementName) {
-        const blockGridElementLocator = this.blockGridEntry.filter({ hasText: blockGridElementName });
-        const blockGridEditButton = blockGridElementLocator.getByLabel('edit');
-        await this.hoverAndClick(blockGridElementLocator, blockGridEditButton, { force: true });
+        await (0, test_1.expect)(this.blockGridEntry.filter({ hasText: blockGridElementName })).toBeVisible();
+        await this.blockGridEntry.filter({ hasText: blockGridElementName }).hover();
+        await (0, test_1.expect)(this.blockGridEntry.filter({ hasText: blockGridElementName }).getByLabel('edit')).toBeVisible();
+        await this.blockGridEntry.filter({ hasText: blockGridElementName }).getByLabel('edit').click({ force: true });
     }
     async goToRTEBlockWithName(groupName, propertyName, blockName, index = 0) {
         const rteProperty = this.workspaceEditTab.filter({ hasText: groupName }).locator(this.workspaceEditProperties).filter({ hasText: propertyName });
         const rteBlockLocator = rteProperty.locator(this.rteBlock).filter({ hasText: blockName }).nth(index);
-        await this.click(rteBlockLocator);
+        await (0, test_1.expect)(rteBlockLocator).toBeVisible();
+        await rteBlockLocator.click();
     }
     async clickSelectBlockElementWithName(elementTypeName) {
-        await this.click(this.page.getByRole('button', { name: elementTypeName, exact: true }));
+        await (0, test_1.expect)(this.page.getByRole('button', { name: elementTypeName, exact: true })).toBeVisible();
+        await this.page.getByRole('button', { name: elementTypeName, exact: true }).click();
     }
     async clickSelectBlockElementInAreaWithName(elementTypeName) {
-        await this.click(this.container.getByRole('button', { name: elementTypeName, exact: true }));
+        await (0, test_1.expect)(this.container.getByRole('button', { name: elementTypeName, exact: true })).toBeVisible();
+        await this.container.getByRole('button', { name: elementTypeName, exact: true }).click();
     }
     async clickBlockElementWithName(elementTypeName) {
-        await this.click(this.page.getByRole('link', { name: elementTypeName, exact: true }), { force: true });
+        await (0, test_1.expect)(this.page.getByRole('link', { name: elementTypeName, exact: true })).toBeVisible();
+        await this.page.getByRole('link', { name: elementTypeName, exact: true }).click({ force: true });
     }
     async enterPropertyValue(propertyName, value) {
         const property = this.property.filter({ hasText: propertyName });
-        await this.enterText(property.locator('input'), value);
+        await (0, test_1.expect)(property).toBeVisible();
+        await property.locator('input').clear();
+        await property.locator('input').fill(value);
     }
     async doesBlockContainBlockInAreaWithName(blockWithAreaName, areaName, blockInAreaName, index = 0) {
         const blockWithArea = this.blockGridEntry.locator(this.blockGridBlock.filter({ hasText: blockWithAreaName })).nth(index);
-        const area = blockWithArea.locator(this.blockGridAreasContainer).locator(`[data-area-alias="${areaName}"]`);
+        const area = blockWithArea.locator(this.blockGridAreasContainer).locator('[data-area-alias="' + areaName + '"]');
         const blockInArea = area.locator(this.blockGridEntry.filter({ hasText: blockInAreaName }));
-        await this.waitForVisible(blockInArea);
+        await (0, test_1.expect)(blockInArea).toBeVisible();
     }
     async doesBlockContainBlockCountInArea(blockWithAreaName, areaName, blocksInAreaCount, index = 0) {
         const blockWithArea = this.blockGridEntry.locator(this.blockGridBlock.filter({ hasText: blockWithAreaName })).nth(index);
-        const area = blockWithArea.locator(this.blockGridAreasContainer).locator(`[data-area-alias="${areaName}"]`);
+        const area = blockWithArea.locator(this.blockGridAreasContainer).locator('[data-area-alias="' + areaName + '"]');
         const blocks = area.locator(this.blockGridEntry);
-        await this.hasCount(blocks, blocksInAreaCount);
+        await (0, test_1.expect)(blocks).toHaveCount(blocksInAreaCount);
     }
     async doesBlockContainCountOfBlockInArea(blockWithAreaName, areaName, blockInAreaName, count, index = 0) {
         const blockWithArea = this.blockGridEntry.locator(this.blockGridBlock.filter({ hasText: blockWithAreaName })).nth(index);
-        const area = blockWithArea.locator(this.blockGridAreasContainer).locator(`[data-area-alias="${areaName}"]`);
+        const area = blockWithArea.locator(this.blockGridAreasContainer).locator('[data-area-alias="' + areaName + '"]');
         const blockInArea = area.locator(this.blockGridEntry.filter({ hasText: blockInAreaName }));
-        await this.hasCount(blockInArea, count);
+        await (0, test_1.expect)(blockInArea).toHaveCount(count);
     }
     async getBlockAtRootDataElementKey(blockName, index = 0) {
         const blockGridEntrySelector = 'umb-block-grid-entry';
@@ -1112,132 +1198,149 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
     }
     async getBlockDataElementKeyInArea(parentBlockName, areaName, blockName, parentIndex = 0, childIndex = 0) {
         const parentBlock = this.blockGridEntry.locator(this.blockGridBlock.filter({ hasText: parentBlockName })).nth(parentIndex);
-        const area = parentBlock.locator(this.blockGridAreasContainer).locator(`[data-area-alias="${areaName}"]`);
+        const area = parentBlock.locator(this.blockGridAreasContainer).locator('[data-area-alias="' + areaName + '"]');
         const block = area.locator(this.blockGridEntry.filter({ hasText: blockName })).nth(childIndex);
         return block.getAttribute('data-element-key');
     }
     async removeBlockFromArea(parentBlockName, areaName, blockName, parentIndex = 0, childIndex = 0) {
         const parentBlock = this.blockGridEntry.locator(this.blockGridBlock.filter({ hasText: parentBlockName })).nth(parentIndex);
-        const area = parentBlock.locator(this.blockGridAreasContainer).locator(`[data-area-alias="${areaName}"]`);
+        const area = parentBlock.locator(this.blockGridAreasContainer).locator('[data-area-alias="' + areaName + '"]');
         const block = area.locator(this.blockGridEntry.filter({ hasText: blockName })).nth(childIndex);
-        await this.hoverAndClick(block, block.getByLabel('delete'), { force: true });
+        await block.hover();
+        await block.getByLabel('delete').click({ force: true });
     }
     async doesBlockAreaContainColumnSpan(blockWithAreaName, areaName, columnSpan, index = 0) {
         const blockWithArea = this.blockGridEntry.locator(this.blockGridBlock.filter({ hasText: blockWithAreaName })).nth(index);
-        const area = blockWithArea.locator(this.blockGridAreasContainer).locator(`[data-area-alias="${areaName}"]`);
-        await this.hasAttribute(area, 'data-area-col-span', columnSpan.toString());
+        const area = blockWithArea.locator(this.blockGridAreasContainer).locator('[data-area-alias="' + areaName + '"]');
+        await (0, test_1.expect)(area).toHaveAttribute('data-area-col-span', columnSpan.toString());
     }
     async doesBlockAreaContainRowSpan(blockWithAreaName, areaName, rowSpan, index = 0) {
         const blockWithArea = this.blockGridEntry.locator(this.blockGridBlock.filter({ hasText: blockWithAreaName })).nth(index);
-        const area = blockWithArea.locator(this.blockGridAreasContainer).locator(`[data-area-alias="${areaName}"]`);
-        await this.hasAttribute(area, 'data-area-row-span', rowSpan.toString());
+        const area = blockWithArea.locator(this.blockGridAreasContainer).locator('[data-area-alias="' + areaName + '"]');
+        await (0, test_1.expect)(area).toHaveAttribute('data-area-row-span', rowSpan.toString());
     }
     async clickInlineAddToAreaButton(parentBlockName, areaName, parentIndex = 0, buttonIndex = 1) {
         const parentBlock = this.blockGridEntry.locator(this.blockGridBlock.filter({ hasText: parentBlockName })).nth(parentIndex);
-        const area = parentBlock.locator(this.blockGridAreasContainer).locator(`[data-area-alias="${areaName}"]`);
-        await this.click(area.locator(this.inlineCreateBtn).nth(buttonIndex));
+        const area = parentBlock.locator(this.blockGridAreasContainer).locator('[data-area-alias="' + areaName + '"]');
+        await area.locator(this.inlineCreateBtn).nth(buttonIndex).click();
     }
     async addBlockToAreasWithExistingBlock(blockWithAreaName, areaName, parentIndex = 0, addToIndex = 0) {
         const blockWithArea = this.blockGridEntry.locator(this.blockGridBlock).filter({ hasText: blockWithAreaName }).nth(parentIndex);
-        await this.hover(blockWithArea);
-        const area = blockWithArea.locator(this.blockGridAreasContainer).locator(`[data-area-alias="${areaName}"]`);
+        await (0, test_1.expect)(blockWithArea).toBeVisible();
+        await blockWithArea.hover();
+        const area = blockWithArea.locator(this.blockGridAreasContainer).locator('[data-area-alias="' + areaName + '"]');
         const addBlockBtn = area.locator(this.inlineCreateBtn).nth(addToIndex);
-        await this.hover(addBlockBtn, { force: true });
-        await this.click(addBlockBtn, { force: true });
+        await addBlockBtn.hover({ force: true });
+        await addBlockBtn.click({ force: true });
     }
     async doesBlockGridBlockWithAreaContainCreateLabel(blockWithAreaName, createLabel, index = 0) {
         const blockWithArea = this.blockGridEntry.locator(this.blockGridBlock.filter({ hasText: blockWithAreaName })).nth(index);
-        return await this.isVisible(blockWithArea.locator(this.blockGridAreasContainer).getByLabel(createLabel));
+        return (0, test_1.expect)(blockWithArea.locator(this.blockGridAreasContainer).getByLabel(createLabel)).toBeVisible();
     }
     async doesPropertyContainValue(propertyName, value) {
         await (0, test_1.expect)(this.property.filter({ hasText: propertyName }).locator('input')).toHaveValue(value);
     }
     async clickCreateButtonForModalWithElementTypeNameAndGroupName(headlineName, groupName) {
-        await this.click(this.blockWorkspace.filter({ hasText: `Add ${headlineName}` }).filter({ hasText: groupName }).getByLabel('Create'));
+        await (0, test_1.expect)(this.blockWorkspace.filter({ hasText: 'Add ' + headlineName }).filter({ hasText: groupName }).getByLabel('Create')).toBeVisible();
+        await this.blockWorkspace.filter({ hasText: 'Add ' + headlineName }).filter({ hasText: groupName }).getByLabel('Create').click();
     }
     async clickUpdateButtonForModalWithElementTypeNameAndGroupName(headlineName, groupName) {
-        await this.click(this.blockWorkspace.filter({ hasText: `Edit ${headlineName}` }).filter({ hasText: groupName }).locator(this.updateBtn));
+        await (0, test_1.expect)(this.blockWorkspace.filter({ hasText: 'Edit ' + headlineName }).filter({ hasText: groupName }).locator(this.updateBtn)).toBeVisible();
+        await this.blockWorkspace.filter({ hasText: 'Edit ' + headlineName }).filter({ hasText: groupName }).locator(this.updateBtn).click();
     }
     async clickExactCopyButton() {
-        await this.click(this.exactCopyBtn);
+        await (0, test_1.expect)(this.exactCopyBtn).toBeVisible();
+        await this.exactCopyBtn.click();
     }
     async clickExactReplaceButton() {
-        await this.click(this.replaceExactBtn);
+        await (0, test_1.expect)(this.replaceExactBtn).toBeVisible();
+        await this.replaceExactBtn.click();
     }
     async doesClipboardHaveCopiedBlockWithName(contentName, propertyName, blockName, index = 0) {
-        await this.isVisible(this.clipboardEntryPicker.getByLabel(`${contentName} - ${propertyName} - ${blockName}`).nth(index));
+        await (0, test_1.expect)(this.clipboardEntryPicker.getByLabel(`${contentName} - ${propertyName} - ${blockName}`).nth(index)).toBeVisible();
     }
     async doesClipboardHaveCopiedBlocks(contentName, propertyName, index = 0) {
-        await this.isVisible(this.clipboardEntryPicker.getByLabel(`${contentName} - ${propertyName}`).nth(index));
+        await (0, test_1.expect)(this.clipboardEntryPicker.getByLabel(`${contentName} - ${propertyName}`).nth(index)).toBeVisible();
     }
     async doesClipboardContainCopiedBlocksCount(count) {
-        await this.hasCount(this.clipboardEntryPicker.locator(this.menuItem), count);
+        await (0, test_1.expect)(this.clipboardEntryPicker.locator(this.menuItem)).toHaveCount(count);
     }
     async selectClipboardEntryWithName(contentName, propertyName, blockName, index = 0) {
         await this.doesClipboardHaveCopiedBlockWithName(contentName, propertyName, blockName, index);
-        await this.click(this.clipboardEntryPicker.getByLabel(`${contentName} - ${propertyName} - ${blockName}`).nth(index));
+        await this.clipboardEntryPicker.getByLabel(`${contentName} - ${propertyName} - ${blockName}`).nth(index).click();
     }
     async selectClipboardEntriesWithName(contentName, propertyName, index = 0) {
         await this.doesClipboardHaveCopiedBlocks(contentName, propertyName, index);
-        await this.click(this.clipboardEntryPicker.getByLabel(`${contentName} - ${propertyName}`).nth(index));
+        await this.clipboardEntryPicker.getByLabel(`${contentName} - ${propertyName}`).nth(index).click();
     }
     async goToBlockGridBlockWithName(groupName, propertyName, blockName, index = 0) {
         const blockGridBlock = this.workspaceEditTab.filter({ hasText: groupName }).locator(this.workspaceEditProperties).filter({ hasText: propertyName }).locator(this.blockGridEntry).nth(index).filter({ hasText: blockName });
-        await this.click(blockGridBlock);
+        await (0, test_1.expect)(blockGridBlock).toBeVisible();
+        await blockGridBlock.click();
     }
     async goToBlockListBlockWithName(groupName, propertyName, blockName, index = 0) {
         const blocklistBlock = this.workspaceEditTab.filter({ hasText: groupName }).locator(this.workspaceEditProperties).filter({ hasText: propertyName }).locator(this.blockListEntry).nth(index).filter({ hasText: blockName });
-        await this.click(blocklistBlock);
+        await (0, test_1.expect)(blocklistBlock).toBeVisible();
+        await blocklistBlock.click();
     }
     async doesBlockEditorBlockWithNameContainValue(groupName, propertyName, inputType = ConstantHelper_1.ConstantHelper.inputTypes.general, value) {
         await (0, test_1.expect)(this.blockWorkspaceEditTab.filter({ hasText: groupName }).locator(this.property).filter({ hasText: propertyName }).locator(inputType)).toContainText(value);
     }
     async clickCloseButton() {
-        await this.click(this.closeBtn);
+        await (0, test_1.expect)(this.closeBtn).toBeVisible();
+        await this.closeBtn.click();
     }
     async clickPasteButton() {
-        await this.click(this.pasteBtn, { force: true });
+        await (0, test_1.expect)(this.pasteBtn).toBeVisible();
+        await this.pasteBtn.click({ force: true });
     }
     async doesBlockListPropertyHaveBlockAmount(groupName, propertyName, amount) {
-        await this.hasCount(this.workspaceEditTab.filter({ hasText: groupName }).locator(this.workspaceEditProperties).filter({ hasText: propertyName }).locator(this.blockListEntry), amount);
+        await (0, test_1.expect)(this.workspaceEditTab.filter({ hasText: groupName }).locator(this.workspaceEditProperties).filter({ hasText: propertyName }).locator(this.blockListEntry)).toHaveCount(amount);
     }
     async doesBlockGridPropertyHaveBlockAmount(groupName, propertyName, amount) {
-        await this.hasCount(this.workspaceEditTab.filter({ hasText: groupName }).locator(this.workspaceEditProperties).filter({ hasText: propertyName }).locator(this.blockGridEntry), amount);
+        await (0, test_1.expect)(this.workspaceEditTab.filter({ hasText: groupName }).locator(this.workspaceEditProperties).filter({ hasText: propertyName }).locator(this.blockGridEntry)).toHaveCount(amount);
     }
     async doesPropertyContainValidationMessage(groupName, propertyName, message) {
         await (0, test_1.expect)(this.blockWorkspaceEditTab.filter({ hasText: groupName }).locator(this.property).filter({ hasText: propertyName }).locator(this.validationMessage)).toContainText(message);
     }
     async clickInsertBlockButton() {
-        await this.click(this.insertBlockBtn);
+        await (0, test_1.expect)(this.insertBlockBtn).toBeVisible();
+        await this.insertBlockBtn.click();
     }
     // TipTap
     async enterRTETipTapEditor(value) {
-        await this.enterText(this.tipTapEditor, value);
+        await (0, test_1.expect)(this.tipTapEditor).toBeVisible();
+        await this.tipTapEditor.clear();
+        await this.tipTapEditor.fill(value);
     }
     async enterRTETipTapEditorWithName(name, value) {
-        const tipTapEditorLocator = this.page.locator(`[data-mark="property:${name}"]`).locator(this.tipTapEditor);
-        await this.enterText(tipTapEditorLocator, value);
+        const tipTapEditorLocator = this.page.locator('[data-mark="property:' + name + '"]').locator(this.tipTapEditor);
+        await (0, test_1.expect)(tipTapEditorLocator).toBeVisible();
+        await tipTapEditorLocator.clear();
+        await tipTapEditorLocator.fill(value);
     }
     async clickTipTapToolbarIconWithTitle(iconTitle) {
-        await this.click(this.tipTapPropertyEditor.getByTitle(iconTitle, { exact: true }).locator('svg'));
+        await (0, test_1.expect)(this.tipTapPropertyEditor.getByTitle(iconTitle, { exact: true }).locator('svg')).toBeVisible();
+        await this.tipTapPropertyEditor.getByTitle(iconTitle, { exact: true }).locator('svg').click();
     }
     async doesUploadedSvgThumbnailHaveSrc(imageSrc) {
-        await this.hasAttribute(this.uploadedSvgThumbnail, 'src', imageSrc);
+        await (0, test_1.expect)(this.uploadedSvgThumbnail).toBeVisible();
+        await (0, test_1.expect)(this.uploadedSvgThumbnail).toHaveAttribute('src', imageSrc);
     }
     async doesRichTextEditorBlockContainLabel(richTextEditorAlias, label) {
-        await (0, test_1.expect)(this.page.getByTestId(`property:${richTextEditorAlias}`).locator(this.rteBlock)).toContainText(label);
+        await (0, test_1.expect)(this.page.getByTestId('property:' + richTextEditorAlias).locator(this.rteBlock)).toContainText(label);
     }
     async doesBlockEditorModalContainEditorSize(editorSize, elementName) {
-        await this.isVisible(this.backofficeModalContainer.locator(`[size="${editorSize}"]`).locator(`[headline="Add ${elementName}"]`));
+        await (0, test_1.expect)(this.backofficeModalContainer.locator('[size="' + editorSize + '"]').locator('[headline="Add ' + elementName + '"]')).toBeVisible();
     }
     async doesBlockEditorModalContainInline(richTextEditorAlias, elementName) {
-        await this.containsText(this.page.getByTestId(`property:${richTextEditorAlias}`).locator(this.tiptapInput).locator(this.rteBlockInline), elementName);
+        await (0, test_1.expect)(this.page.getByTestId('property:' + richTextEditorAlias).locator(this.tiptapInput).locator(this.rteBlockInline)).toContainText(elementName);
     }
     async doesBlockHaveBackgroundColor(elementName, backgroundColor) {
-        await this.isVisible(this.page.locator('umb-block-type-card', { hasText: elementName }).locator(`[style="background-color:${backgroundColor};"]`));
+        await (0, test_1.expect)(this.page.locator('umb-block-type-card', { hasText: elementName }).locator('[style="background-color:' + backgroundColor + ';"]')).toBeVisible();
     }
     async doesBlockHaveIconColor(elementName, backgroundColor) {
-        await this.isVisible(this.page.locator('umb-block-type-card', { hasText: elementName }).locator(`[color="${backgroundColor}"]`));
+        await (0, test_1.expect)(this.page.locator('umb-block-type-card', { hasText: elementName }).locator('[color="' + backgroundColor + '"]')).toBeVisible();
     }
     async addDocumentDomain(domainName, languageName) {
         await this.clickCultureAndHostnamesButton();
@@ -1248,144 +1351,161 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
     }
     // Scheduled Publishing
     async clickViewMoreOptionsButton() {
-        await this.click(this.viewMoreOptionsBtn);
+        await (0, test_1.expect)(this.viewMoreOptionsBtn).toBeVisible();
+        await this.viewMoreOptionsBtn.click();
     }
     async clickSchedulePublishButton() {
-        await this.click(this.schedulePublishBtn);
+        await (0, test_1.expect)(this.schedulePublishBtn).toBeVisible();
+        await this.schedulePublishBtn.click();
     }
     async clickSchedulePublishModalButton() {
-        await this.click(this.schedulePublishModalBtn);
+        await (0, test_1.expect)(this.schedulePublishModalBtn).toBeVisible();
+        await this.schedulePublishModalBtn.click();
     }
     async enterPublishTime(time, index = 0) {
         const publishAtTxt = this.documentScheduleModal.locator('.publish-date').nth(index).locator('uui-form-layout-item').first().locator('#input');
-        await this.enterText(publishAtTxt, time);
+        await (0, test_1.expect)(publishAtTxt).toBeVisible();
+        await publishAtTxt.fill(time);
     }
     async enterUnpublishTime(time, index = 0) {
         const unpublishAtTxt = this.documentScheduleModal.locator('.publish-date').nth(index).locator('uui-form-layout-item').last().locator('#input');
-        await this.enterText(unpublishAtTxt, time);
+        await (0, test_1.expect)(unpublishAtTxt).toBeVisible();
+        await unpublishAtTxt.fill(time);
     }
     async doesPublishAtValidationMessageContainText(text) {
-        await this.containsText(this.publishAtValidationMessage, text);
+        await (0, test_1.expect)(this.publishAtValidationMessage).toContainText(text);
     }
     async doesUnpublishAtValidationMessageContainText(text) {
-        await this.containsText(this.unpublishAtValidationMessage, text);
+        await (0, test_1.expect)(this.unpublishAtValidationMessage).toContainText(text);
     }
     async doesLastPublishedContainText(text) {
-        await this.containsText(this.lastPublished, text);
+        await (0, test_1.expect)(this.lastPublished).toContainText(text);
     }
     async doesPublishAtContainText(text) {
-        await this.containsText(this.publishAt, text);
+        await (0, test_1.expect)(this.publishAt).toContainText(text);
     }
     async doesRemoveAtContainText(text) {
-        await this.containsText(this.removeAt, text);
+        await (0, test_1.expect)(this.removeAt).toContainText(text);
     }
     async clickSelectAllCheckbox() {
-        await this.click(this.selectAllCheckbox);
+        await (0, test_1.expect)(this.selectAllCheckbox).toBeVisible();
+        await this.selectAllCheckbox.click();
     }
     async doesSchedulePublishModalButtonContainDisabledTag(hasDisabledTag = false) {
         if (!hasDisabledTag) {
-            await (0, test_1.expect)(this.schedulePublishModalBtn).not.toHaveAttribute('disabled', '');
-        }
-        else {
-            await this.hasAttribute(this.schedulePublishModalBtn, 'disabled', '');
+            return await (0, test_1.expect)(this.schedulePublishModalBtn).not.toHaveAttribute('disabled', '');
         }
+        return await (0, test_1.expect)(this.schedulePublishModalBtn).toHaveAttribute('disabled', '');
     }
     async clickInlineBlockCaretButtonForName(blockEditorName, index = 0) {
         const caretButtonLocator = this.blockListEntry.filter({ hasText: blockEditorName }).nth(index).locator('uui-symbol-expand svg');
-        await this.click(caretButtonLocator);
+        await (0, test_1.expect)(caretButtonLocator).toBeVisible();
+        await caretButtonLocator.click();
     }
     async doesTiptapHaveWordCount(count) {
-        await this.hasText(this.tiptapStatusbarWordCount, `${count} words`);
+        await (0, test_1.expect)(this.tiptapStatusbarWordCount).toHaveText(count.toString() + ' words');
     }
     async doesTiptapHaveCharacterCount(count) {
-        await this.hasText(this.tiptapStatusbarWordCount, `${count} characters`);
+        await (0, test_1.expect)(this.tiptapStatusbarWordCount).toHaveText(count.toString() + ' characters');
     }
     async clickTiptapWordCountButton() {
-        await this.click(this.tiptapStatusbarWordCount);
+        await (0, test_1.expect)(this.tiptapStatusbarWordCount).toBeVisible();
+        await this.tiptapStatusbarWordCount.click();
     }
     async doesElementPathHaveText(text) {
-        await this.hasText(this.tiptapStatusbarElementPath, text);
+        await (0, test_1.expect)(this.tiptapStatusbarElementPath).toHaveText(text);
     }
     async clickConfirmToPublishButton() {
-        await this.click(this.confirmToPublishBtn);
-        // Extra wait to ensure publish process starts
-        await this.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.medium);
+        await this.confirmToPublishBtn.click();
     }
     async clickPublishWithDescendantsButton() {
-        await this.click(this.publishWithDescendantsBtn);
+        await (0, test_1.expect)(this.publishWithDescendantsBtn).toBeVisible();
+        await this.publishWithDescendantsBtn.click();
     }
     async clickIncludeUnpublishedDescendantsToggle() {
-        await this.click(this.includeUnpublishedDescendantsToggle);
+        await (0, test_1.expect)(this.includeUnpublishedDescendantsToggle).toBeVisible();
+        await this.includeUnpublishedDescendantsToggle.click();
     }
     async clickPublishWithDescendantsModalButton() {
-        await this.click(this.publishWithDescendantsModalBtn);
+        await (0, test_1.expect)(this.publishWithDescendantsModalBtn).toBeVisible();
+        await this.publishWithDescendantsModalBtn.click();
     }
     async doesDocumentVariantLanguageItemHaveCount(count) {
-        await this.hasCount(this.documentVariantLanguageItem, count);
+        await (0, test_1.expect)(this.documentVariantLanguageItem).toHaveCount(count);
     }
     async doesDocumentVariantLanguageItemHaveName(name) {
-        await this.containsText(this.documentVariantLanguagePicker, name);
+        await (0, test_1.expect)(this.documentVariantLanguagePicker).toContainText(name);
     }
     async clickSchedulePublishLanguageButton(languageName) {
-        await this.click(this.page.getByRole('menu').filter({ hasText: languageName }));
+        await (0, test_1.expect)(this.page.getByRole('menu').filter({ hasText: languageName })).toBeVisible();
+        await this.page.getByRole('menu').filter({ hasText: languageName }).click();
     }
     async clickBlockCardWithName(name, toForce = false) {
         const blockWithNameLocator = this.page.locator('uui-card-block-type', { hasText: name });
-        await this.click(blockWithNameLocator, { force: toForce });
+        await (0, test_1.expect)(blockWithNameLocator).toBeVisible();
+        await blockWithNameLocator.click({ force: toForce });
     }
     async clickStyleSelectButton() {
-        await this.click(this.styleSelectBtn);
+        await (0, test_1.expect)(this.styleSelectBtn).toBeVisible();
+        await this.styleSelectBtn.click();
     }
     async clickCascadingMenuItemWithName(name) {
-        const menuItemLocator = this.cascadingMenuContainer.locator(`uui-menu-item[label="${name}"]`);
-        await this.click(menuItemLocator);
+        const menuItemLocator = this.cascadingMenuContainer.locator('uui-menu-item[label="' + name + '"]');
+        await (0, test_1.expect)(menuItemLocator).toBeVisible();
+        await menuItemLocator.click();
     }
     async hoverCascadingMenuItemWithName(name) {
-        const menuItemLocator = this.cascadingMenuContainer.locator(`uui-menu-item[label="${name}"]`);
-        await this.hover(menuItemLocator);
+        const menuItemLocator = this.cascadingMenuContainer.locator('uui-menu-item[label="' + name + '"]');
+        await (0, test_1.expect)(menuItemLocator).toBeVisible();
+        await menuItemLocator.hover();
     }
     async selectAllRTETipTapEditorText() {
-        await this.click(this.tipTapEditor);
-        await this.pressKey(this.tipTapEditor, 'Control+A');
+        await (0, test_1.expect)(this.tipTapEditor).toBeVisible();
+        await this.tipTapEditor.click();
+        await this.page.keyboard.press('Control+A');
     }
     async waitForContentToBePublished() {
-        await this.waitForLoadState();
+        await this.page.waitForLoadState();
     }
     async waitForRecycleBinToBeEmptied() {
-        await this.waitForLoadState();
+        await this.page.waitForLoadState();
     }
     async clearTipTapEditor() {
-        await this.waitForVisible(this.tipTapEditor);
+        await (0, test_1.expect)(this.tipTapEditor).toBeVisible();
         // We use the middle mouse button click so we don't accidentally open a block in the RTE. This solution avoids that.
         await this.tipTapEditor.click({ button: "middle" });
-        await this.pressKey(this.tipTapEditor, 'Control+A');
-        await this.pressKey(this.tipTapEditor, 'Backspace');
+        await this.page.keyboard.press('Control+A');
+        await this.page.keyboard.press('Backspace');
     }
     async clickBlockElementInRTEWithName(elementTypeName) {
         const blockElementLocator = this.page.locator('uui-ref-node umb-ufm-render').filter({ hasText: elementTypeName });
-        await this.click(blockElementLocator, { force: true });
+        await (0, test_1.expect)(blockElementLocator).toBeVisible();
+        await blockElementLocator.click({ force: true });
     }
     async doesModalFormValidationMessageContainText(text) {
-        await this.containsText(this.modalFormValidationMessage, text);
+        await (0, test_1.expect)(this.modalFormValidationMessage).toContainText(text);
     }
     async enterSearchKeywordInTreePickerModal(keyword) {
-        await this.enterText(this.treePickerSearchTxt, keyword);
-        await this.pressKey(this.treePickerSearchTxt, 'Enter');
+        await (0, test_1.expect)(this.treePickerSearchTxt).toBeVisible();
+        await this.treePickerSearchTxt.fill(keyword);
+        await this.page.keyboard.press('Enter');
     }
     async enterSearchKeywordInMediaPickerModal(keyword) {
-        await this.enterText(this.mediaPickerSearchTxt, keyword);
-        await this.pressKey(this.mediaPickerSearchTxt, 'Enter');
+        await (0, test_1.expect)(this.mediaPickerSearchTxt).toBeVisible();
+        await this.mediaPickerSearchTxt.fill(keyword);
+        await this.page.keyboard.press('Enter');
     }
     async enterSearchKeywordInMemberPickerModal(keyword) {
-        await this.enterText(this.memberPickerSearchTxt, keyword);
-        await this.pressKey(this.memberPickerSearchTxt, 'Enter');
+        await (0, test_1.expect)(this.memberPickerSearchTxt).toBeVisible();
+        await this.memberPickerSearchTxt.fill(keyword);
+        await this.page.keyboard.press('Enter');
     }
     async isContentNameReadOnly() {
         await (0, test_1.expect)(this.contentNameTxt).toHaveAttribute('readonly');
     }
     // Block Custom View
     async isBlockCustomViewVisible(blockCustomViewLocator, isVisible = true) {
-        await this.isVisible(this.page.locator(blockCustomViewLocator), isVisible);
+        await (0, test_1.expect)(this.page.locator(blockCustomViewLocator)).toBeVisible({ visible: isVisible });
     }
     async isSingleBlockElementVisible(isVisible = true) {
         const count = await this.refListBlock.count();
@@ -1395,109 +1515,119 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         else {
             (0, test_1.expect)(count, `Expected only one element, but found ${count}`).toBe(0);
         }
-        await this.isVisible(this.refListBlock, isVisible);
+        await (0, test_1.expect)(this.refListBlock).toBeVisible({ visible: isVisible });
     }
     async doesBlockCustomViewHaveValue(customBlockViewLocator, valueText) {
         const locator = this.page.locator(`${customBlockViewLocator} p`);
-        await this.waitForVisible(locator);
-        await this.hasText(locator, valueText);
+        await (0, test_1.expect)(locator).toBeVisible();
+        await (0, test_1.expect)(locator).toHaveText(valueText);
     }
     async clickPropertyActionWithName(name) {
-        const actionLocator = this.propertyActionMenu.locator(`umb-property-action uui-menu-item[label="${name}"]`);
-        await this.click(actionLocator);
+        const actionLocator = this.propertyActionMenu.locator('umb-property-action uui-menu-item[label="' + name + '"]');
+        await (0, test_1.expect)(actionLocator).toBeVisible();
+        await actionLocator.click();
     }
     async isContentWithNameVisibleInList(contentName, isVisible = true) {
-        await this.isVisible(this.documentTableColumnName.filter({ hasText: contentName }), isVisible);
+        await (0, test_1.expect)(this.documentTableColumnName.filter({ hasText: contentName })).toBeVisible({ visible: isVisible });
     }
     async selectDocumentBlueprintWithName(blueprintName) {
-        const blueprintLocator = this.documentCreateOptionsModal.locator('uui-menu-item', { hasText: blueprintName });
-        await this.click(blueprintLocator);
+        await (0, test_1.expect)(this.documentCreateOptionsModal.locator('uui-menu-item', { hasText: blueprintName })).toBeVisible();
+        await this.documentCreateOptionsModal.locator('uui-menu-item', { hasText: blueprintName }).click();
     }
     async doesDocumentModalHaveText(text) {
-        await this.containsText(this.documentCreateOptionsModal, text);
+        await (0, test_1.expect)(this.documentCreateOptionsModal).toContainText(text);
     }
     async doesListViewItemsHaveCount(pageSize) {
-        await this.hasCount(this.listViewCustomRows, pageSize);
+        await (0, test_1.expect)(this.listViewCustomRows).toHaveCount(pageSize);
     }
     async isListViewItemWithNameVisible(itemName, index = 0) {
         await (0, test_1.expect)(this.listViewCustomRows.nth(index)).toContainText(itemName);
     }
     async clickPaginationNextButton() {
-        await this.click(this.nextPaginationBtn);
+        await (0, test_1.expect)(this.nextPaginationBtn).toBeVisible();
+        await this.nextPaginationBtn.click();
     }
     // Entity Data Picker
     async chooseCollectionMenuItemWithName(name) {
         await this.clickChooseButton();
-        await this.click(this.collectionMenu.locator('umb-collection-menu-item', { hasText: name }));
+        await this.collectionMenu.locator('umb-collection-menu-item', { hasText: name }).click();
         await this.clickChooseContainerButton();
         await this.page.waitForTimeout(500);
     }
     async chooseTreeMenuItemWithName(name, parentNames = []) {
         await this.clickChooseButton();
         for (const itemName of parentNames) {
-            await this.click(this.entityPickerTree.locator('umb-tree-item').getByLabel(`Expand child items for ${itemName}`));
+            await this.entityPickerTree.locator('umb-tree-item').getByLabel('Expand child items for ' + itemName).click();
         }
-        await this.click(this.container.getByLabel(name));
+        await this.container.getByLabel(name).click();
         await this.clickChooseContainerButton();
         await this.page.waitForTimeout(500);
     }
     async isChooseButtonVisible(isVisible = true) {
-        await this.isVisible(this.chooseBtn, isVisible);
+        await (0, test_1.expect)(this.chooseBtn).toBeVisible({ visible: isVisible });
     }
     async clickDocumentNotificationOptionWithName(name) {
-        const notificationOptionLocator = this.page.locator(`umb-document-notifications-modal [id$="${name}"]`).locator('#toggle');
-        await this.click(notificationOptionLocator);
+        const notificationOptionLocator = this.page.locator('umb-document-notifications-modal [id$="' + name + '"]').locator('#toggle');
+        await (0, test_1.expect)(notificationOptionLocator).toBeVisible();
+        await notificationOptionLocator.click();
     }
     async switchLanguage(languageName) {
-        await this.click(this.languageToggle);
+        await (0, test_1.expect)(this.languageToggle).toBeVisible();
+        await this.languageToggle.click();
         const languageOptionLocator = this.contentVariantDropdown.locator('.culture-variant').filter({ hasText: languageName });
-        await this.click(languageOptionLocator);
+        await (0, test_1.expect)(languageOptionLocator).toBeVisible();
+        await languageOptionLocator.click();
         await (0, test_1.expect)(languageOptionLocator).toContainClass('selected');
     }
     async clickAddBlockListElementWithName(blockName) {
-        const createNewButtonLocator = this.page.getByTestId(`property:${blockName.toLowerCase()}`).getByLabel('Create new');
-        await this.click(createNewButtonLocator);
+        const createNewButtonLocator = this.page.getByTestId('property:' + blockName.toLowerCase()).getByLabel('Create new');
+        await (0, test_1.expect)(createNewButtonLocator).toBeVisible();
+        await createNewButtonLocator.click();
     }
     async isAddBlockListElementWithNameDisabled(blockName) {
-        const createNewButtonLocator = this.page.getByTestId(`property:${blockName.toLowerCase()}`).locator('uui-button[label="Create new"]');
+        const createNewButtonLocator = this.page.getByTestId('property:' + blockName.toLowerCase()).locator('uui-button[label="Create new"]');
         await (0, test_1.expect)(createNewButtonLocator).toHaveAttribute('disabled');
     }
     async isAddBlockListElementWithNameVisible(blockName) {
-        const createNewButtonLocator = this.page.getByTestId(`property:${blockName.toLowerCase()}`).locator('uui-button[label="Create new"]');
-        await this.waitForVisible(createNewButtonLocator);
+        const createNewButtonLocator = this.page.getByTestId('property:' + blockName.toLowerCase()).locator('uui-button[label="Create new"]');
+        await (0, test_1.expect)(createNewButtonLocator).toBeVisible();
         await (0, test_1.expect)(createNewButtonLocator).not.toHaveAttribute('disabled');
     }
     async enterBlockPropertyValue(propertyName, value) {
         const property = this.blockProperty.filter({ hasText: propertyName });
-        await this.enterText(property.locator('input'), value);
+        await (0, test_1.expect)(property).toBeVisible();
+        await property.locator('input').clear();
+        await property.locator('input').fill(value);
     }
     async isBlockPropertyEditable(propertyName, isEditable = true) {
         const propertyLocator = this.blockProperty.filter({ hasText: propertyName }).locator('#input');
-        await this.waitForVisible(propertyLocator);
+        await (0, test_1.expect)(propertyLocator).toBeVisible();
         await (0, test_1.expect)(propertyLocator).toBeEditable({ editable: isEditable });
     }
     async isInlineBlockPropertyVisible(propertyName, isVisible = true) {
         const propertyLocator = this.blockListEntry.locator(this.blockProperty).filter({ hasText: propertyName });
-        await this.isVisible(propertyLocator, isVisible);
+        await (0, test_1.expect)(propertyLocator).toBeVisible({ visible: isVisible });
     }
     async isInlineBlockPropertyVisibleForBlockWithName(blockName, propertyName, isVisible = true, index = 0) {
         const blockEntryLocator = this.blockListEntry.filter({ hasText: blockName }).nth(index);
         const propertyLocator = blockEntryLocator.locator(this.blockProperty).filter({ hasText: propertyName });
-        await this.isVisible(propertyLocator, isVisible);
+        await (0, test_1.expect)(propertyLocator).toBeVisible({ visible: isVisible });
     }
     async enterInlineBlockPropertyValue(propertyName, value, index = 0) {
         const propertyLocator = this.blockListEntry.nth(index).locator(this.blockProperty).filter({ hasText: propertyName });
-        await this.enterText(propertyLocator.locator('input'), value);
+        await (0, test_1.expect)(propertyLocator).toBeVisible();
+        await propertyLocator.locator('input').clear();
+        await propertyLocator.locator('input').fill(value);
     }
     async doesInlineBlockPropertyHaveValue(propertyName, value, index = 0) {
         const propertyLocator = this.blockListEntry.nth(index).locator(this.blockProperty).filter({ hasText: propertyName }).locator('input');
-        await this.hasValue(propertyLocator, value);
+        await (0, test_1.expect)(propertyLocator).toHaveValue(value);
     }
     async removeNotFoundContentPickerWithId(contentPickerId) {
         const hasText = contentPickerId ? contentPickerId : 'Not found';
         const contentPickerLocator = this.entityItem.filter({ hasText: hasText });
-        const removeButton = contentPickerLocator.getByLabel('Remove');
-        await this.hoverAndClick(contentPickerLocator, removeButton);
+        await contentPickerLocator.hover();
+        await contentPickerLocator.getByLabel('Remove').click();
         await this.clickConfirmRemoveButton();
     }
     async isLinkPickerAddButtonEnabled() {
@@ -1507,16 +1637,20 @@ class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
         await (0, test_1.expect)(this.linkPickerAddBtn).toBeDisabled();
     }
     async clickLinkPickerCloseButton() {
-        await this.click(this.linkPickerCloseBtn);
+        await (0, test_1.expect)(this.linkPickerCloseBtn).toBeVisible();
+        await this.linkPickerCloseBtn.click();
     }
     async clickLinkPickerAddButton() {
-        await this.click(this.linkPickerAddBtn);
+        await (0, test_1.expect)(this.linkPickerAddBtn).toBeVisible();
+        await this.linkPickerAddBtn.click();
     }
     async clickLinkPickerTargetToggle() {
-        await this.click(this.linkPickerTargetToggle);
+        await (0, test_1.expect)(this.linkPickerTargetToggle).toBeVisible();
+        await this.linkPickerTargetToggle.click();
     }
     async clickConfirmToResetButton() {
-        await this.click(this.confirmToResetBtn);
+        await (0, test_1.expect)(this.confirmToResetBtn).toBeVisible();
+        await this.confirmToResetBtn.click();
     }
 }
 exports.ContentUiHelper = ContentUiHelper;