@camunda/e2e-test-suite 0.0.1

package/dist/pages/8.7/SignUpPage.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignUpPage = void 0;
+const test_1 = require("@playwright/test");
+class SignUpPage {
+    page;
+    firstNameInput;
+    lastNameInput;
+    passwordInput;
+    passwordInputInvitedUser;
+    signupButton;
+    emailInput;
+    companyInput;
+    createAccountButton;
+    backgroundDrodownList;
+    whatDoYouDoDropdownList;
+    APIClientDropdownList;
+    levelOfExperienceDropdownList;
+    nextButton;
+    runProcessRadioButton;
+    whyAreYouEvaluatingCamunda;
+    confirmSaaSTrial;
+    loginToCamundaButton;
+    backgroundPageHeading;
+    useCasePageHeading;
+    goalPageHeading;
+    camundaPlansPageHeading;
+    setPasswordPageHeading;
+    signUpCompletedPageHeading;
+    verifyEmailText;
+    constructor(page) {
+        this.page = page;
+        this.firstNameInput = page.getByLabel('First Name');
+        this.lastNameInput = page.getByLabel('Last Name');
+        this.passwordInput = page.locator('[id="password"]');
+        this.passwordInputInvitedUser = page.getByLabel('Password (min 12 characters)');
+        this.signupButton = page.getByRole('button', { name: 'Sign up' });
+        this.emailInput = page.getByLabel('Email');
+        this.companyInput = page.getByLabel('Company*');
+        this.createAccountButton = page.getByRole('button', {
+            name: 'Create account',
+        });
+        this.backgroundDrodownList = page.getByLabel('Background*');
+        this.whatDoYouDoDropdownList = page.getByLabel('What do you do?*');
+        this.APIClientDropdownList = page.getByRole('combobox', {
+            name: 'what is your preferred api client?',
+        });
+        this.levelOfExperienceDropdownList = page.getByLabel('what is your level of experience with process design?*');
+        this.nextButton = page.getByRole('button', { name: 'Next' });
+        this.runProcessRadioButton = page.getByRole('radio');
+        this.whyAreYouEvaluatingCamunda = page.getByLabel('Why are you evaluating');
+        this.confirmSaaSTrial = page.getByRole('button', {
+            name: 'Confirm SaaS Trial',
+        });
+        this.loginToCamundaButton = page.getByRole('button', {
+            name: 'log in to camunda',
+        });
+        this.backgroundPageHeading = page.getByRole('heading', {
+            name: 'great! to customize your account, tell us a little about yourself',
+        });
+        this.useCasePageHeading = page.getByRole('heading', {
+            name: 'thank you! how will you use camunda',
+        });
+        this.goalPageHeading = page.getByRole('heading', {
+            name: 'finally, what is your goal with camunda?',
+        });
+        this.camundaPlansPageHeading = page.getByRole('heading', {
+            name: 'Here is your custom recommendation, please confirm your Camunda account below:',
+        });
+        this.setPasswordPageHeading = page.getByRole('heading', {
+            name: 'Finish',
+        });
+        this.signUpCompletedPageHeading = page.getByRole('heading', {
+            name: 'thank you for signing up for camunda',
+        });
+        this.runProcessRadioButton = page.getByRole('radio', { name: 'yes' });
+        this.verifyEmailText = page.getByText('Verify your email');
+    }
+    async signupToC8(emailAddress) {
+        await this.page.goto('https://accounts.ultrawombat.com/signup');
+        await this.clickFirstNameInput();
+        await this.fillFirstNameInput('QA');
+        await this.clickLastNameInput();
+        await this.fillLastNameInput('Camunda');
+        await this.clickEmailInput();
+        await this.fillEmailInput(emailAddress);
+        await this.clickPasswordInput();
+        await this.fillPasswordInput(process.env.C8_PASSWORD);
+        await this.clickSignupButton();
+        await (0, test_1.expect)(this.verifyEmailText.first()).toBeVisible({
+            timeout: 40000,
+        });
+    }
+    async clickFirstNameInput() {
+        await this.firstNameInput.click();
+    }
+    async fillFirstNameInput(firstName) {
+        await this.firstNameInput.fill(firstName);
+    }
+    async clickLastNameInput() {
+        await this.lastNameInput.click();
+    }
+    async fillLastNameInput(lastName) {
+        await this.lastNameInput.fill(lastName);
+    }
+    async clickPasswordInput() {
+        await this.passwordInput.click({ timeout: 30000 });
+    }
+    async fillPasswordInput(password) {
+        await this.passwordInput.fill(password);
+    }
+    async clickPasswordInputInvitedUser() {
+        await this.passwordInputInvitedUser.click({ timeout: 30000 });
+    }
+    async fillPasswordInputInvitedUser(password) {
+        await this.passwordInputInvitedUser.fill(password);
+    }
+    async clickCompanyInput() {
+        await this.companyInput.click();
+    }
+    async fillCompanyInput(company) {
+        await this.companyInput.fill(company);
+    }
+    async clickSignupButton() {
+        await this.signupButton.click();
+    }
+    async clickEmailInput() {
+        await this.emailInput.click();
+    }
+    async fillEmailInput(email) {
+        await this.emailInput.fill(email);
+    }
+    async selectEndpointsToAutomate(endpoint) {
+        // Select the container to expand the dropdown
+        await this.page.getByText('choose all that apply').hover();
+        const dropdownContainerSelector = '.ginput_container_multiselect';
+        await this.page.click(dropdownContainerSelector);
+        // Wait for the dropdown options to appear
+        await this.page.waitForSelector('.multiselect-dropdown-list > div > input[type="checkbox"]');
+        // Select the checkbox
+        const checkboxSelector = `.multiselect-dropdown-list  > div > input[type="checkbox"] + label:has-text("${endpoint}")`;
+        await this.page.click(checkboxSelector, { timeout: 60000 });
+    }
+    async clickCreateAccount() {
+        await this.createAccountButton.click();
+    }
+    async clickNext() {
+        await this.nextButton.click();
+    }
+    async selectBackground(background) {
+        await this.backgroundDrodownList.selectOption(background);
+    }
+    async selectWhatDoYouDo(profession) {
+        await this.whatDoYouDoDropdownList.selectOption(profession);
+    }
+    async selectAPIClient(apiClient) {
+        await this.APIClientDropdownList.selectOption(apiClient, { timeout: 40000 });
+    }
+    async selectLevelOfExperience(experience) {
+        await this.levelOfExperienceDropdownList.selectOption(experience);
+    }
+    async selectRunProcessRadioButton() {
+        await this.runProcessRadioButton.check({ timeout: 30000 });
+    }
+    async selectWhyEvaluatingCamunda(reason) {
+        await this.whyAreYouEvaluatingCamunda.selectOption(reason);
+    }
+    async clickConfirmSaaSTrial() {
+        await this.confirmSaaSTrial.click();
+    }
+    async clickLoginToCamunda() {
+        await this.loginToCamundaButton.click();
+    }
+}
+exports.SignUpPage = SignUpPage;

package/dist/pages/8.7/TaskDetailsPage.d.ts

@@ -0,0 +1,69 @@
+import { Page, Locator } from '@playwright/test';
+declare class TaskDetailsPage {
+    private page;
+    readonly assignToMeButton: Locator;
+    readonly completeButton: Locator;
+    readonly unassignButton: Locator;
+    readonly assignee: Locator;
+    readonly completeTaskButton: Locator;
+    readonly addVariableButton: Locator;
+    readonly detailsPanel: Locator;
+    readonly detailsHeader: Locator;
+    readonly pendingTaskDescription: Locator;
+    readonly pickATaskHeader: Locator;
+    readonly emptyTaskMessage: Locator;
+    readonly nameInput: Locator;
+    readonly addressInput: Locator;
+    readonly ageInput: Locator;
+    readonly variablesTable: Locator;
+    readonly nameColumnHeader: Locator;
+    readonly valueColumnHeader: Locator;
+    readonly form: Locator;
+    readonly numberInput: Locator;
+    readonly incrementButton: Locator;
+    readonly decrementButton: Locator;
+    readonly dateInput: Locator;
+    readonly timeInput: Locator;
+    readonly checkbox: Locator;
+    readonly selectDropdown: Locator;
+    readonly tagList: Locator;
+    readonly detailsInfo: Locator;
+    readonly textInput: Locator;
+    readonly assignedToMeText: Locator;
+    readonly textBox: Locator;
+    readonly noPreviewContainer: Locator;
+    readonly previewContainer: Locator;
+    constructor(page: Page);
+    clickAssignToMeButton(): Promise<void>;
+    clickUnassignButton(): Promise<void>;
+    clickCompleteTaskButton(): Promise<void>;
+    clickAddVariableButton(): Promise<void>;
+    replaceExistingVariableValue(values: {
+        name: string;
+        value: string;
+    }): Promise<void>;
+    getNthVariableNameInput(nth: number): Locator;
+    getNthVariableValueInput(nth: number): Locator;
+    addVariable(payload: {
+        name: string;
+        value: string;
+    }): Promise<void>;
+    fillNumber(number: string): Promise<void>;
+    clickIncrementButton(): Promise<void>;
+    clickDecrementButton(): Promise<void>;
+    fillDate(date: string): Promise<void>;
+    enterTime(time: string): Promise<void>;
+    checkCheckbox(): Promise<void>;
+    selectDropdownValue(value: string): Promise<void>;
+    clickRadioButton(radioBtnLabel: string): Promise<void>;
+    checkChecklistBox(label: string): Promise<void>;
+    enterTwoValuesInTagList(value1: string, value2: string): Promise<void>;
+    clickTextInput(): Promise<void>;
+    fillTextInput(value: string): Promise<void>;
+    fillTextBox(text: string): Promise<void>;
+    fillName(nameInput: string): Promise<void>;
+    assertDocumentDownloadButton(documentName: string): Promise<void>;
+    assertLoadedImage(documentName: string): Promise<void>;
+    assertPdfPreviewViewerExists(): Promise<void>;
+}
+export { TaskDetailsPage };

package/dist/pages/8.7/TaskDetailsPage.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskDetailsPage = void 0;
+const test_1 = require("@playwright/test");
+const UtilitiesPage_1 = require("../8.7/UtilitiesPage");
+function cardinalToOrdinal(numberValue) {
+    const realOrderIndex = numberValue.toString();
+    if (['11', '12', '13'].includes(realOrderIndex.slice(-2))) {
+        return `${realOrderIndex}th`;
+    }
+    switch (realOrderIndex.slice(-1)) {
+        case '1':
+            return `${realOrderIndex}st`;
+        case '2':
+            return `${realOrderIndex}nd`;
+        case '3':
+            return `${realOrderIndex}rd`;
+        default:
+            return `${realOrderIndex}th`;
+    }
+}
+class TaskDetailsPage {
+    page;
+    assignToMeButton;
+    completeButton;
+    unassignButton;
+    assignee;
+    completeTaskButton;
+    addVariableButton;
+    detailsPanel;
+    detailsHeader;
+    pendingTaskDescription;
+    pickATaskHeader;
+    emptyTaskMessage;
+    nameInput;
+    addressInput;
+    ageInput;
+    variablesTable;
+    nameColumnHeader;
+    valueColumnHeader;
+    form;
+    numberInput;
+    incrementButton;
+    decrementButton;
+    dateInput;
+    timeInput;
+    checkbox;
+    selectDropdown;
+    tagList;
+    detailsInfo;
+    textInput;
+    assignedToMeText;
+    textBox;
+    noPreviewContainer;
+    previewContainer;
+    constructor(page) {
+        this.page = page;
+        this.assignToMeButton = page.getByRole('button', { name: 'Assign to me' });
+        this.completeButton = page.getByRole('button', { name: 'Complete' });
+        this.unassignButton = page.getByRole('button', { name: 'Unassign' });
+        this.assignee = page.getByTestId('assignee');
+        this.completeTaskButton = page.getByRole('button', { name: 'Complete Task' });
+        this.addVariableButton = page.getByRole('button', { name: 'Add Variable' });
+        this.detailsPanel = this.page.getByRole('complementary', {
+            name: 'Task details right panel',
+        });
+        this.detailsHeader = page.getByTitle('Task details header');
+        this.pendingTaskDescription = page.getByText('Pending task');
+        this.pickATaskHeader = page.getByRole('heading', {
+            name: 'Pick a task to work on',
+        });
+        this.emptyTaskMessage = page.getByRole('heading', {
+            name: /task has no variables/i,
+        });
+        this.nameInput = page.getByLabel('Full Name');
+        this.addressInput = page.getByLabel('Address*');
+        this.ageInput = page.getByLabel('Age');
+        this.variablesTable = page.getByTestId('variables-table');
+        this.nameColumnHeader = this.variablesTable.getByRole('columnheader', {
+            name: 'Name',
+        });
+        this.valueColumnHeader = this.variablesTable.getByRole('columnheader', {
+            name: 'Value',
+        });
+        this.form = page.getByTestId('embedded-form');
+        this.numberInput = this.form.getByLabel('Count');
+        this.incrementButton = page.getByRole('button', { name: 'Increment' });
+        this.decrementButton = page.getByRole('button', { name: 'Decrement' });
+        this.dateInput = page.getByLabel('Date of Birth');
+        this.timeInput = page.getByPlaceholder('hh:mm ?m');
+        this.checkbox = this.form.getByLabel('Agree');
+        this.selectDropdown = this.form.getByText('Select').last();
+        this.tagList = page.getByPlaceholder('Search');
+        this.detailsInfo = page.getByTestId('details-info');
+        this.textInput = page.locator('[class="fjs-input"]');
+        this.assignedToMeText = this.page
+            .getByTestId('assignee')
+            .getByText('Assigned to me');
+        this.textBox = this.page.getByLabel('Text Box');
+        this.noPreviewContainer = this.page.locator('[class = "fjs-documentPreview-non-preview-item fjs-documentPreview-single-document-container"]');
+        this.previewContainer = this.page.locator('[class = "fjs-documentPreview-single-document-container"]');
+    }
+    async clickAssignToMeButton() {
+        await this.assignToMeButton.click({ timeout: 60000 });
+        await (0, test_1.expect)(this.page.getByText('Assigning...')).not.toBeVisible({
+            timeout: 180000,
+        });
+        await (0, test_1.expect)(this.assignedToMeText).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    async clickUnassignButton() {
+        await this.unassignButton.click();
+    }
+    async clickCompleteTaskButton() {
+        await this.completeTaskButton.click({ timeout: 120000 });
+    }
+    async clickAddVariableButton() {
+        await this.addVariableButton.click();
+    }
+    async replaceExistingVariableValue(values) {
+        const { name, value } = values;
+        await this.page.getByTitle(name).clear();
+        await this.page.getByTitle(name).fill(value);
+    }
+    getNthVariableNameInput(nth) {
+        return this.page.getByRole('textbox', {
+            name: `${cardinalToOrdinal(nth)} variable name`,
+        });
+    }
+    getNthVariableValueInput(nth) {
+        return this.page.getByRole('textbox', {
+            name: `${cardinalToOrdinal(nth)} variable value`,
+        });
+    }
+    async addVariable(payload) {
+        const { name, value } = payload;
+        this.clickAddVariableButton();
+        await this.getNthVariableNameInput(1).fill(name);
+        await this.getNthVariableValueInput(1).fill(value);
+    }
+    async fillNumber(number) {
+        await this.numberInput.fill(number);
+    }
+    async clickIncrementButton() {
+        await this.incrementButton.click();
+    }
+    async clickDecrementButton() {
+        await this.decrementButton.click();
+    }
+    async fillDate(date) {
+        await this.dateInput.click();
+        await this.dateInput.fill(date);
+        await this.dateInput.press('Enter');
+    }
+    async enterTime(time) {
+        await this.timeInput.click();
+        await this.page.getByText(time).click();
+    }
+    async checkCheckbox() {
+        await this.checkbox.check();
+    }
+    async selectDropdownValue(value) {
+        await this.selectDropdown.click();
+        await this.page.getByText(value).click();
+    }
+    async clickRadioButton(radioBtnLabel) {
+        await this.page.getByText(radioBtnLabel).click();
+    }
+    async checkChecklistBox(label) {
+        await this.page.getByLabel(label).check();
+    }
+    async enterTwoValuesInTagList(value1, value2) {
+        await this.tagList.click();
+        await this.page.getByText(value1).click();
+        await this.page.getByText(value2, { exact: true }).click();
+    }
+    async clickTextInput() {
+        const maxRetries = 10;
+        let attempts = 0;
+        while (attempts < maxRetries) {
+            try {
+                await this.textInput.click({ timeout: 90000 });
+                break;
+            }
+            catch (error) {
+                attempts += 1;
+                if (attempts < maxRetries) {
+                    console.warn(`Attempt ${attempts} failed. Reloading page and retrying...`);
+                    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+                    await sleep(10000);
+                    await this.page.reload();
+                }
+                else {
+                    throw new Error(`Failed to click text input after ${maxRetries} attempts`);
+                }
+            }
+        }
+    }
+    async fillTextInput(value) {
+        await this.textInput.fill(value, { timeout: 90000 });
+    }
+    async fillTextBox(text) {
+        await this.textBox.fill(text);
+    }
+    async fillName(nameInput) {
+        await this.nameInput.fill(nameInput);
+    }
+    async assertDocumentDownloadButton(documentName) {
+        await (0, test_1.expect)(this.page.locator(`button[aria-label="Download ${documentName}"]`)).toBeVisible({ timeout: 60000 });
+    }
+    async assertLoadedImage(documentName) {
+        await (0, UtilitiesPage_1.assertLocatorVisibleWithRetry)(this.page, this.page.locator(`img[alt="${documentName}"]`), documentName, 60000, 6);
+    }
+    async assertPdfPreviewViewerExists() {
+        const containers = this.page.locator('[class="fjs-documentPreview-single-document-container"]');
+        const firstPdfViewer = containers
+            .first()
+            .locator('.fjs-documentPreview-pdf-viewer');
+        const lastPdfViewer = containers
+            .last()
+            .locator('.fjs-documentPreview-pdf-viewer');
+        await (0, test_1.expect)(firstPdfViewer.or(lastPdfViewer)).toBeVisible();
+    }
+}
+exports.TaskDetailsPage = TaskDetailsPage;

package/dist/pages/8.7/TaskPanelPage.d.ts

@@ -0,0 +1,18 @@
+import { Page, Locator } from '@playwright/test';
+declare class TaskPanelPage {
+    private page;
+    readonly availableTasks: Locator;
+    readonly filterPanel: Locator;
+    readonly taskListPageBanner: Locator;
+    readonly processesPageTab: Locator;
+    readonly tasksTab: Locator;
+    constructor(page: Page);
+    openTask(name: string): Promise<void>;
+    filterBy(option: 'All open' | 'Unassigned' | 'Assigned to me' | 'Completed'): Promise<void>;
+    taskCount(name: string): Promise<number>;
+    clickTasksTab(): Promise<void>;
+    scrollToLastTask(name: string): Promise<void>;
+    scrollToFirstTask(name: string): Promise<void>;
+    clickProcessesTab(): Promise<void>;
+}
+export { TaskPanelPage };

package/dist/pages/8.7/TaskPanelPage.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskPanelPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class TaskPanelPage {
+    page;
+    availableTasks;
+    filterPanel;
+    taskListPageBanner;
+    processesPageTab;
+    tasksTab;
+    constructor(page) {
+        this.page = page;
+        this.availableTasks = page.getByTitle('Available tasks');
+        this.filterPanel = page.locator('[aria-controls="task-nav-bar"]');
+        this.taskListPageBanner = page.getByRole('link', {
+            name: 'Camunda logo Tasklist',
+        });
+        this.processesPageTab = page.getByRole('link', { name: 'Processes' });
+        this.tasksTab = page.getByRole('link', { name: 'Tasks', exact: true });
+    }
+    async openTask(name) {
+        let attempts = 0;
+        const maxAttempts = 3;
+        while (attempts < maxAttempts) {
+            try {
+                await this.availableTasks
+                    .getByText(name, { exact: true })
+                    .nth(0)
+                    .click({ timeout: 120000 });
+                return;
+            }
+            catch (error) {
+                attempts++;
+                if (attempts >= maxAttempts) {
+                    throw error;
+                }
+                await this.page.reload();
+            }
+        }
+    }
+    async filterBy(option) {
+        await this.filterPanel.click({ timeout: 120000 });
+        await (0, test_1.expect)(this.page.getByRole('link', { name: option }).getByText(option)).toBeVisible({ timeout: 120000 });
+        await this.page
+            .getByRole('link', { name: option })
+            .getByText(option)
+            .click({ timeout: 120000 });
+    }
+    async taskCount(name) {
+        await (0, sleep_1.sleep)(20000);
+        return this.availableTasks.getByText(name, { exact: true }).count();
+    }
+    async clickTasksTab() {
+        await this.tasksTab.click();
+    }
+    async scrollToLastTask(name) {
+        await this.page.getByText(name).last().scrollIntoViewIfNeeded();
+    }
+    async scrollToFirstTask(name) {
+        await this.page.getByText(name).first().scrollIntoViewIfNeeded();
+    }
+    async clickProcessesTab() {
+        await this.processesPageTab.click();
+    }
+}
+exports.TaskPanelPage = TaskPanelPage;

package/dist/pages/8.7/TaskProcessesPage.d.ts

@@ -0,0 +1,11 @@
+import { Page, Locator } from '@playwright/test';
+declare class TaskProcessesPage {
+    private page;
+    readonly popupContinueButton: Locator;
+    readonly popup: Locator;
+    readonly processes: Locator;
+    constructor(page: Page);
+    clickpopupContinueButton(): Promise<void>;
+    startProcess(name: string): Promise<void>;
+}
+export { TaskProcessesPage };

package/dist/pages/8.7/TaskProcessesPage.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskProcessesPage = void 0;
+const test_1 = require("@playwright/test");
+class TaskProcessesPage {
+    page;
+    popupContinueButton;
+    popup;
+    processes;
+    constructor(page) {
+        this.page = page;
+        this.popupContinueButton = page.getByRole('button', { name: 'Continue' });
+        this.popup = page.getByLabel('Start your process on demand');
+        this.processes = page.locator('[data-testid="process-tile"]');
+    }
+    async clickpopupContinueButton() {
+        try {
+            await this.popupContinueButton.click({ timeout: 60000 });
+        }
+        catch (error) {
+            console.log('Popup not present');
+        }
+    }
+    async startProcess(name) {
+        await this.processes
+            .filter({ hasText: name })
+            .nth(0)
+            .getByRole('button', { name: 'Start process' })
+            .click({ timeout: 60000 });
+        await (0, test_1.expect)(this.page.getByText('Waiting for tasks...')).not.toBeVisible({
+            timeout: 60000,
+        });
+    }
+}
+exports.TaskProcessesPage = TaskProcessesPage;

package/dist/pages/8.7/UtilitiesPage.d.ts

@@ -0,0 +1,35 @@
+import { Page, Locator } from '@playwright/test';
+import { ModelerCreatePage } from './ModelerCreatePage';
+import { ModelerHomePage } from './ModelerHomePage';
+import { MailSlurp } from 'mailslurp-client';
+import { HomePage } from './HomePage';
+import { ClusterPage } from './ClusterPage';
+import { ClusterDetailsPage } from './ClusterDetailsPage';
+import { AppsPage } from './AppsPage';
+import { TaskPanelPage } from './TaskPanelPage';
+import { TaskDetailsPage } from './TaskDetailsPage';
+import { OperateProcessesPage } from './OperateProcessesPage';
+import { OperateProcessInstancePage } from './OperateProcessInstancePage';
+import { ConsoleOrganizationPage } from './ConsoleOrganizationPage';
+import { LoginPage } from './LoginPage';
+import { ConnectorSettingsPage } from './ConnectorSettingsPage';
+import { ConnectorMarketplacePage } from './ConnectorMarketplacePage';
+import { ConnectorTemplatePage } from './ConnectorTemplatePage';
+export declare function loginWithRetry(page: Page, loginPage: LoginPage, timeout: number, maxRetries?: number): Promise<void>;
+export declare function modelRestConnector(modelerCreatePage: ModelerCreatePage, connectorSettingsPage: ConnectorSettingsPage, processName: string, url: string, auth: string, resultExpression: string, resultVariable?: string, basicAuthCredentials?: {
+    username: string;
+    password: string;
+}): Promise<void>;
+export declare function assertLocatorVisibleWithRetry(page: Page | OperateProcessesPage | OperateProcessInstancePage | ModelerHomePage, locator: Locator, text: string, timeout?: number, maxRetries?: number): Promise<void>;
+export declare function assertPageTextWithRetry(page: Page, text: string, notVisible?: boolean, timeout?: number, maxRetries?: number): Promise<void>;
+export declare function completeTaskWithRetry(taskPanelPage: TaskPanelPage, taskDetailsPage: TaskDetailsPage, taskName: string, taskPriority: string, maxRetries?: number): Promise<void>;
+export declare function runProcess(clusterName: string, page: Page, modelerHomePage: ModelerHomePage, modelerCreatePage: ModelerCreatePage, processName: string, processId?: string, rbaEnabled?: boolean): Promise<void>;
+export declare function runMultipleProcesses(clusterName: string, page: Page, modelerHomePage: ModelerHomePage, modelerCreatePage: ModelerCreatePage, numberOfProcesses: number, processName: string, processId?: string, rbaEnabled?: boolean): Promise<void>;
+export declare function disableRBA(clusterName: string, homePage: HomePage, clusterPage: ClusterPage, clusterDetailsPage: ClusterDetailsPage, appsPage: AppsPage): Promise<void>;
+export declare function enableRBA(clusterName: string, homePage: HomePage, clusterPage: ClusterPage, clusterDetailsPage: ClusterDetailsPage, appsPage: AppsPage): Promise<void>;
+export declare function clickInvitationLinkInEmail(page: Page, id: string, mailSlurp: MailSlurp): Promise<void>;
+export declare function assertTestUsesCorrectOrganization(page: Page): Promise<void>;
+export declare function deleteAllUserGroups(homePage: HomePage, organizationPage: ConsoleOrganizationPage, appsPage: AppsPage): Promise<void>;
+export declare function deleteCluster(clusterName: string, homePage: HomePage, clusterPage: ClusterPage, appsPage: AppsPage): Promise<void>;
+export declare function modelAndRunConnectorsDocHandlingDiagram(modelerCreatePage: ModelerCreatePage, modelerHomePage: ModelerHomePage, processName: string, page: Page, connectorMarketplacePage: ConnectorMarketplacePage, clusterName: string, zeebeUrl: string, zeebeClientId: string, zeebeClientSecret: string): Promise<void>;
+export declare function modelAndRunConnectorsTimerEventDiagram(modelerCreatePage: ModelerCreatePage, modelerHomePage: ModelerHomePage, processName: string, page: Page, connectorMarketplacePage: ConnectorMarketplacePage, clusterName: string, connectorTemplatePage: ConnectorTemplatePage): Promise<void>;