@camunda/e2e-test-suite 0.0.1443 → 0.0.1445

package/dist/pages/SM-8.11/OCTenantPage.js

@@ -0,0 +1,399 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OCTenantPage = void 0;
+const test_1 = require("@playwright/test");
+const expectTextWithPagination_1 = require("../../utils/assertionHelpers/expectTextWithPagination");
+const ROLE_ID_SEARCH_LABEL = /^(Search by role ID|searchByRoleId)$/i;
+class OCTenantPage {
+    page;
+    createTenantMainButton;
+    enterTenantNameInput;
+    enterTenantIdInput;
+    createTenantSubButton;
+    usersTab;
+    assignUsersButton;
+    usernameInput;
+    assignUserFinalButton;
+    removeUserButton;
+    removeButton;
+    openSidebarButton;
+    logoutButton;
+    assignedApplicationsTab;
+    searchApplicationsInput;
+    assignApplicationsButtonFinal;
+    assignApplicationsButton;
+    tenantDescriptionInput;
+    modalCloseButton;
+    rolesTab;
+    assignRoleButton;
+    roleIdSearchBox;
+    roleIdSearchTrigger;
+    assignRoleSubButton;
+    assignRoleModal;
+    cancelButton;
+    gotItButton;
+    filterTableSearchbox;
+    row;
+    constructor(page) {
+        this.page = page;
+        this.createTenantMainButton = page.getByRole('button', {
+            name: 'Create Tenant',
+        });
+        this.enterTenantNameInput = page.getByPlaceholder('Enter tenant name');
+        this.enterTenantIdInput = page.getByPlaceholder('Enter tenant ID');
+        this.createTenantSubButton = page
+            .getByLabel('Create new tenant')
+            .getByRole('button', { name: 'Create tenant' });
+        this.usersTab = page.getByRole('tab', { name: 'Users' });
+        this.assignUsersButton = page.getByRole('button', { name: 'Assign user' });
+        this.usernameInput = page.getByTitle('Username');
+        this.assignUserFinalButton = page
+            .getByLabel('Assign user')
+            .getByRole('button', { name: 'Assign user' });
+        this.removeUserButton = page
+            .getByRole('dialog', { name: 'Remove user' })
+            .getByRole('button', { name: 'Remove user' });
+        this.removeButton = page.getByRole('button', { name: 'Remove', exact: true });
+        this.openSidebarButton = page.getByLabel('Open User Sidebar');
+        this.logoutButton = page.getByRole('button', { name: 'Log out' });
+        this.assignedApplicationsTab = page.getByRole('tab', {
+            name: 'Assigned applications',
+        });
+        this.searchApplicationsInput = page.getByPlaceholder('Search applications');
+        this.assignApplicationsButtonFinal = page
+            .getByLabel('Assign applications')
+            .getByRole('button', { name: 'Assign applications' });
+        this.assignApplicationsButton = page.getByRole('button', {
+            name: 'Assign applications',
+        });
+        this.tenantDescriptionInput = page.getByTitle('Description');
+        this.modalCloseButton = page
+            .getByRole('dialog')
+            .getByRole('button', { name: 'Close' });
+        this.rolesTab = page.getByRole('tab', { name: 'Roles' });
+        this.assignRoleButton = page.getByRole('button', { name: 'Assign role' });
+        // The design-system Admin shell renders the Assign role modal's search
+        // field as a MultiSelect whose trigger is a div[role="combobox"] carrying
+        // the label as a child span - it has no placeholder and is not editable,
+        // so scope the trigger to the dialog and keep the legacy searchbox match
+        // as a fallback, the same dual-shell pattern the table filter locator
+        // below uses.
+        this.roleIdSearchTrigger = page
+            .getByRole('dialog', { name: 'Assign role' })
+            .getByRole('combobox', { name: ROLE_ID_SEARCH_LABEL })
+            .or(page.getByRole('searchbox', { name: 'Search by Role ID' }))
+            .first();
+        // Clicking that trigger opens a Radix popover that portals to <body> as a
+        // sibling of the dialog, and the editable field is the cmdk <input> inside
+        // it. Nothing opened that popover before, so the placeholder-bearing input
+        // never existed and the click at it timed out. Match the popover's input,
+        // falling back to the placeholder/searchbox that pre-design-system builds
+        // render instead of the trigger/popover pair.
+        this.roleIdSearchBox = page
+            .locator('[data-slot="multi-select-content"] input[cmdk-input]')
+            .or(page.getByPlaceholder('Search by role ID'))
+            .or(page.getByRole('searchbox', { name: 'Search by Role ID' }))
+            .first();
+        this.assignRoleModal = page.getByLabel('Assign role');
+        this.assignRoleSubButton = this.assignRoleModal.getByRole('button', {
+            name: 'Assign role',
+        });
+        this.cancelButton = page
+            .getByRole('dialog')
+            .getByRole('button', { name: 'Cancel' });
+        this.gotItButton = page.getByRole('button', { name: 'Got it' });
+        // The design-system Admin shell replaced Carbon's table toolbar search
+        // (labelled "Filter table") with an input whose aria-label is its
+        // placeholder, so match the new shell first and fall back to the legacy
+        // one - the same dual-shell pattern the Admin nav locators use.
+        this.filterTableSearchbox = page
+            .getByRole('searchbox', { name: 'Search by tenant ID' })
+            .or(page.getByRole('searchbox', { name: 'Filter table' }))
+            .first();
+        this.row = (name) => this.page.getByRole('row').filter({ hasText: name }).first();
+    }
+    async clickCreateTenantMainButton() {
+        await this.createTenantMainButton.click({ timeout: 60000 });
+    }
+    async clickCreateTenantSubButton() {
+        await this.createTenantSubButton.click({ timeout: 60000 });
+    }
+    async clickEnterTenantNameInput() {
+        await this.enterTenantNameInput.click();
+    }
+    async fillEnterTenantNameInput(tenantName) {
+        await this.enterTenantNameInput.fill(tenantName);
+    }
+    async clickEnterTenantIdInput() {
+        await this.enterTenantIdInput.click();
+    }
+    async fillEnterTenantIdInput(tenantId) {
+        await this.enterTenantIdInput.fill(tenantId);
+    }
+    async clickUsersTab() {
+        await this.usersTab.click({ timeout: 60000 });
+    }
+    async clickAssignUsersButton() {
+        await this.assignUsersButton.click();
+    }
+    async clickUsernameInput() {
+        await this.usernameInput.click();
+    }
+    async fillUsernameInput(user) {
+        await this.usernameInput.fill(user);
+    }
+    async clickAssignUserFinalButton() {
+        try {
+            await this.assignUserFinalButton.click();
+            await (0, test_1.expect)(this.page.getByRole('dialog')).not.toBeVisible();
+        }
+        catch (e) {
+            if (await this.page.getByText('ALREADY_EXISTS').first().isVisible()) {
+                console.log('User is already assigned to tenant');
+                await this.clickCancelButton();
+            }
+            else {
+                throw new Error('Assigning user to tenant failed' + e);
+            }
+        }
+    }
+    async clickRemoveUserButton() {
+        await this.removeUserButton.click();
+    }
+    async clickRemoveButton() {
+        await this.removeButton.click();
+    }
+    async clickTenantDescriptionInput() {
+        await this.tenantDescriptionInput.click();
+    }
+    async fillTenantDescriptionInput(description) {
+        await this.tenantDescriptionInput.fill(description);
+    }
+    async createTenant(tenantName) {
+        await this.clickCreateTenantMainButton();
+        await this.clickEnterTenantNameInput();
+        await this.fillEnterTenantNameInput(tenantName);
+        await this.clickEnterTenantIdInput();
+        await this.fillEnterTenantIdInput(tenantName);
+        await this.clickTenantDescriptionInput();
+        await this.fillTenantDescriptionInput('This is a test');
+        await this.clickCreateTenantSubButton();
+        await this.assertTenantCreated();
+    }
+    async assertTenantCreated() {
+        try {
+            await (0, test_1.expect)(this.page.getByText('successfully created')).toBeVisible({
+                timeout: 8000,
+            });
+            await this.clickGotItButton();
+        }
+        catch (error) {
+            if (await this.page.getByText('ALREADY_EXISTS').first().isVisible()) {
+                await this.clickCancelButton();
+            }
+            else {
+                throw new Error('Creating tenant failed' + error);
+            }
+        }
+    }
+    async clickCancelButton() {
+        await this.cancelButton.click({ timeout: 30000 });
+    }
+    async clickGotItButton() {
+        await this.gotItButton.click({ timeout: 30000 });
+    }
+    async filterTable(tenantName) {
+        await this.filterTableSearchbox.click({ timeout: 60000 });
+        await this.filterTableSearchbox.fill(tenantName);
+        await this.filterTableSearchbox.press('Enter');
+    }
+    async clickTenant(tenantName) {
+        const maxRetries = 10;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await this.page.reload();
+                await this.page.waitForLoadState('networkidle');
+                await this.filterTable(tenantName);
+                const tenant = this.page.getByText(tenantName).first();
+                await (0, test_1.expect)(tenant).toBeVisible({ timeout: 30000 });
+                await tenant.click({ timeout: 30000 });
+                return;
+            }
+            catch (error) {
+                console.warn(`Attempt ${attempt} to click tenant '${tenantName}' failed. Retrying...`, error);
+                if (attempt === maxRetries) {
+                    throw new Error(`Failed to click tenant '${tenantName}' after ${maxRetries} attempts. Last error: ${error}`);
+                }
+            }
+        }
+    }
+    async assignUserToTenant(user) {
+        await this.clickUsersTab();
+        await this.clickAssignUsersButton();
+        await this.clickUsernameInput();
+        await this.fillUsernameInput(user);
+        await this.clickAssignUserFinalButton();
+    }
+    async removeUserFromTenant(tenantName) {
+        await (0, expectTextWithPagination_1.expectTextWithPagination)(this.page, tenantName);
+        await this.page.getByText(tenantName).first().click();
+        await this.clickUsersTab();
+        await this.clickRemoveButton();
+        await this.clickRemoveUserButton();
+        await (0, test_1.expect)(this.page.getByText('Tenant member has been removed.')).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    async clickOpenSidebarButton() {
+        await this.openSidebarButton.click({ timeout: 60000 });
+    }
+    async clickLogoutButton() {
+        await this.logoutButton.click({ timeout: 60000 });
+    }
+    async assignClientToTenant(clientName) {
+        await this.clickAssignedApplicationsTab();
+        if (await this.page.getByText(clientName, { exact: true }).isVisible()) {
+            return;
+        }
+        else {
+            await this.clickAssignApplicationsButton();
+            await this.clickSearchApplicationsInput();
+            await this.fillSearchApplicationsInput(clientName);
+            await this.page.getByText(clientName, { exact: true }).click();
+            await this.clickAssignApplicationsFinalButton();
+            await (0, test_1.expect)(this.page.getByText('Applications assigned')).toBeVisible({
+                timeout: 60000,
+            });
+        }
+    }
+    async clickAssignedApplicationsTab() {
+        await this.assignedApplicationsTab.click({ timeout: 60000 });
+    }
+    async clickSearchApplicationsInput() {
+        await this.searchApplicationsInput.click({ timeout: 60000 });
+    }
+    async fillSearchApplicationsInput(clientName) {
+        await this.searchApplicationsInput.fill(clientName);
+    }
+    async clickAssignApplicationsFinalButton() {
+        await this.assignApplicationsButtonFinal.click({ timeout: 60000 });
+    }
+    async clickAssignApplicationsButton() {
+        await this.assignApplicationsButton.click({ timeout: 60000 });
+    }
+    async clickRolesTab() {
+        await this.rolesTab.click();
+    }
+    async clickAssignRoleButton() {
+        await this.assignRoleButton.click();
+    }
+    async clickRoleIdSearchBox() {
+        await this.roleIdSearchTrigger.click({ timeout: 60000 });
+        await (0, test_1.expect)(this.roleIdSearchBox).toBeVisible({ timeout: 60000 });
+    }
+    // Selecting an option or losing focus dismisses the popover, which unmounts
+    // the search input, so reopen it before the next term is typed.
+    async ensureRoleIdSearchBoxOpen() {
+        const open = await this.roleIdSearchBox
+            .waitFor({ state: 'visible', timeout: 5000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!open) {
+            await this.clickRoleIdSearchBox();
+        }
+    }
+    async fillRoleIdSearchBox(roleId, roleIdentifier) {
+        // The option row renders the ID followed by the name, so the name is the
+        // tail of `roleIdentifier`.
+        const roleName = roleIdentifier.startsWith(roleId)
+            ? roleIdentifier.slice(roleId.length)
+            : '';
+        // The design-system row separates the two parts with an em dash
+        // ('connectors — Connectors') while the legacy Carbon row concatenates
+        // them ('connectorsConnectors'), so match both with an optional
+        // dash/whitespace run between the ID and the name.
+        const escapeForRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const rolePattern = new RegExp(`${escapeForRegExp(roleId)}[-\\s\\u2010-\\u2015]*${escapeForRegExp(roleName)}`);
+        // The design-system shell portals the matches into a listbox rendered as
+        // a sibling of the dialog, so they cannot be scoped to the modal. The
+        // legacy Carbon list stays inside it and must remain scoped: the tenant's
+        // own roles table sits behind the modal and carries the same role text, so
+        // an unscoped match resolves to that row and its click is intercepted by
+        // the modal overlay.
+        const result = this.page
+            .getByRole('option')
+            .filter({ hasText: rolePattern })
+            .or(this.assignRoleModal.getByText(rolePattern))
+            .first();
+        // The dropdown no longer filters client-side: it queries
+        // `/v2/roles/search` with `name: {$like: '*<typed>*'}`, which is
+        // case-sensitive, so the role ID ('connectors') never matches the default
+        // role's name ('Connectors'): search the ID first for the shells that
+        // still match on it, then fall back to the name.
+        const searchTerms = [roleId];
+        if (roleName !== '' && roleName !== roleId) {
+            searchTerms.push(roleName);
+        }
+        // The dropdown only queries for a non-empty value, so clearing the box
+        // between terms resets it before the next one is typed.
+        await (0, test_1.expect)(async () => {
+            for (const searchTerm of searchTerms) {
+                await this.ensureRoleIdSearchBoxOpen();
+                await this.roleIdSearchBox.fill('');
+                await this.page.waitForLoadState('networkidle');
+                // The cmdk input only issues its server-side query on real
+                // keystrokes, so type the term in rather than setting it in one shot.
+                await this.roleIdSearchBox.pressSequentially(searchTerm);
+                const offered = await result
+                    .waitFor({ state: 'visible', timeout: 15000 })
+                    .then(() => true)
+                    .catch(() => false);
+                if (offered) {
+                    return;
+                }
+            }
+            throw new Error(`Role ${roleIdentifier} was not offered by the assign role search for` +
+                ` any of: ${searchTerms.join(', ')}`);
+        }).toPass({ timeout: 120000, intervals: [2000] });
+        await result.click();
+    }
+    async clickAssignRoleSubButton() {
+        await this.assignRoleSubButton.click();
+    }
+    async isRoleAssigned(roleId) {
+        return this.row(roleId)
+            .waitFor({ state: 'visible', timeout: 15000 })
+            .then(() => true)
+            .catch(() => false);
+    }
+    async assignRoleToTenant(roleId, roleIdentifier) {
+        await this.clickRolesTab();
+        await this.page.waitForLoadState('networkidle');
+        // The roles table renders from its own fetch, which `networkidle` can
+        // resolve ahead of, so an immediate `isVisible()` reads the table as empty
+        // and reopens the modal for a role that is already assigned. The assign
+        // dropdown never offers an already-assigned role, so that attempt can
+        // never converge.
+        if (await this.isRoleAssigned(roleId)) {
+            console.log(`Role ${roleId} is already assigned to tenant`);
+            return;
+        }
+        await this.clickAssignRoleButton();
+        await this.page.waitForLoadState('networkidle');
+        await this.clickRoleIdSearchBox();
+        await this.fillRoleIdSearchBox(roleId, roleIdentifier);
+        await this.clickAssignRoleSubButton();
+        await (0, test_1.expect)(this.page.getByLabel('Assign role')).not.toBeVisible({
+            timeout: 30000,
+        });
+        // Use retry-with-reload pattern for role visibility (MT operations need time for data replication)
+        await (0, test_1.expect)(async () => {
+            if (!(await this.row(roleId).isVisible())) {
+                await this.page.reload();
+                await this.page.waitForLoadState('networkidle');
+            }
+            await (0, test_1.expect)(this.row(roleId)).toBeVisible({ timeout: 10000 });
+        }).toPass({ timeout: 60000, intervals: [5000] });
+    }
+}
+exports.OCTenantPage = OCTenantPage;

package/dist/pages/SM-8.11/OperateHomePage.d.ts

@@ -0,0 +1,26 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateHomePage {
+    private page;
+    readonly operateBanner: Locator;
+    readonly processesTab: Locator;
+    readonly informationDialog: Locator;
+    readonly editVariableButton: Locator;
+    readonly variableValueInput: Locator;
+    readonly saveVariableButton: Locator;
+    readonly editVariableSpinner: Locator;
+    readonly licenseKeyTagNonProduction: Locator;
+    readonly licenseKeyTagProduction: Locator;
+    readonly processPageHeading: Locator;
+    readonly applyButton: Locator;
+    readonly openButton: Locator;
+    constructor(page: Page);
+    clickProcessesTab(): Promise<void>;
+    closeInformationDialog(): Promise<void>;
+    clickEditVariableButton(variableName: string): Promise<void>;
+    clickVariableValueInput(): Promise<void>;
+    clearVariableValueInput(): Promise<void>;
+    fillVariableValueInput(newValue: string): Promise<void>;
+    clickSaveVariableButton(): Promise<void>;
+    openProcess(processName: string): Promise<void>;
+}
+export { OperateHomePage };

package/dist/pages/SM-8.11/OperateHomePage.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateHomePage = void 0;
+const test_1 = require("@playwright/test");
+const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+const constants_1 = require("../../utils/constants");
+class OperateHomePage {
+    page;
+    operateBanner;
+    processesTab;
+    informationDialog;
+    editVariableButton;
+    variableValueInput;
+    saveVariableButton;
+    editVariableSpinner;
+    licenseKeyTagNonProduction;
+    licenseKeyTagProduction;
+    processPageHeading;
+    applyButton;
+    openButton;
+    constructor(page) {
+        this.page = page;
+        // Same Design System header rollout NavigationPage.operatePageBanner
+        // covers: the home link is aria-label="Camunda Operate" once
+        // `navV2Enabled` is on, and "Camunda logo Operate" while it is off.
+        this.operateBanner = page
+            .getByRole('link', { name: 'Camunda logo Operate' })
+            .or(page.getByRole('link', { name: 'Camunda Operate', exact: true }))
+            .first();
+        this.processesTab = page.getByRole('link', {
+            name: 'Processes',
+            exact: true,
+        });
+        this.informationDialog = page.getByRole('button', {
+            name: 'Close this dialog',
+        });
+        this.editVariableButton = page.getByTestId('edit-variable-button');
+        this.variableValueInput = page.getByTestId('edit-variable-value');
+        this.saveVariableButton = page.getByLabel('Save variable');
+        this.editVariableSpinner = page
+            .getByTestId('variable-operation-spinner')
+            .locator('circle')
+            .nth(1);
+        this.licenseKeyTagNonProduction = page
+            .getByText('Non-production license')
+            .first();
+        this.licenseKeyTagProduction = page.getByText('Production license').first();
+        this.processPageHeading = page
+            .getByTestId('expanded-panel')
+            .getByRole('heading', { name: 'Process' });
+        this.applyButton = page.getByRole('button', { name: 'Apply' });
+        this.openButton = page
+            .getByTestId('variable-testVariable')
+            .getByLabel('Open');
+    }
+    async clickProcessesTab() {
+        // Called right after navigating into Operate, a Vite SPA whose nav bar can
+        // take longer than clickLocatorWithRetry's default 10s visibilityTimeout to
+        // render on a loaded cluster — so all 3 attempts could burn inside 30s and
+        // throw while the link was still on its way. Give each attempt the 30s the
+        // callers that pre-wait this same link already assume.
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.processesTab, {
+            totalTimeout: 120000,
+            visibilityTimeout: 30000,
+        });
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.processPageHeading, {
+            // Defaults (10s per attempt, 60s total) gave the Processes panel less
+            // budget than the tab click above already assumes it needs on a loaded
+            // cluster, so all three attempts could expire while the view was still
+            // rendering. Match the 30s/120s the click uses.
+            visibilityTimeout: 30000,
+            totalTimeout: 120000,
+            preAction: async () => {
+                await (0, test_1.expect)(this.processesTab).toBeVisible({
+                    timeout: constants_1._1_SECOND_IN_MS * 4,
+                });
+                await this.processesTab.click({ timeout: constants_1._1_SECOND_IN_MS * 4 });
+            },
+            postAction: async () => {
+                // Operate is a Vite SPA: a transient module/CSS preload failure
+                // renders a "Something went wrong - Please reload the page" screen
+                // on which the Processes tab click is a no-op. Reload to fetch fresh
+                // assets so the next attempt can render the Processes view.
+                await this.page.reload({ waitUntil: 'domcontentloaded' });
+            },
+        });
+    }
+    async closeInformationDialog() {
+        await this.informationDialog.click();
+    }
+    async clickEditVariableButton(variableName) {
+        const editVariableButton = 'variable-' + variableName;
+        const button = this.page.getByTestId(editVariableButton).getByLabel('Edit');
+        await (0, test_1.expect)(button).toBeVisible({ timeout: 30000 });
+        await button.click();
+    }
+    async clickVariableValueInput() {
+        await this.variableValueInput.click();
+    }
+    async clearVariableValueInput() {
+        await this.variableValueInput.clear();
+    }
+    async fillVariableValueInput(newValue) {
+        await this.openButton.click();
+        await this.page
+            .getByLabel('Edit Variable "testVariable"')
+            .getByText('"testValue"')
+            .click();
+        // Replace the whole JSON document in one shot. Typing it per-character
+        // raced the editor's re-render: after a couple of keystrokes the caret
+        // jumped outside the closing quote, leaving invalid JSON such as
+        // `"up"datedValue`. Apply then rejects it silently, the modal stays open
+        // and the old value is still on screen, so the caller's
+        // `not.toBeVisible('"testValue"')` assertion times out. insertText emits a
+        // single input event, so there is no intermediate state to race.
+        //
+        // Pass only the OPENING quote: Monaco auto-closes it. Supplying both ends
+        // yields `"updatedValue""` -- invalid JSON, and Apply rejects it exactly
+        // like the per-character version did. Same recipe as
+        // pages/c8Run-8.10/OperateHomePage.ts.
+        //
+        // Select with Home + Shift+End rather than ControlOrMeta+A: headless
+        // Chromium on macOS does not apply Meta+A as select-all inside Monaco's
+        // native edit context, so the insert landed mid-string. The value is a
+        // single-line JSON string, so selecting the line selects the document on
+        // every platform.
+        await this.page.keyboard.press('Home');
+        await this.page.keyboard.press('Shift+End');
+        await this.page.keyboard.insertText(`"${newValue}`);
+    }
+    async clickSaveVariableButton() {
+        await this.applyButton.click();
+    }
+    async openProcess(processName) {
+        await this.page.getByText(processName).click();
+    }
+}
+exports.OperateHomePage = OperateHomePage;

package/dist/pages/SM-8.11/OperateProcessInstancePage.d.ts

@@ -0,0 +1,30 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateProcessInstancePage {
+    private page;
+    readonly diagram: Locator;
+    readonly completedIcon: Locator;
+    readonly diagramSpinner: Locator;
+    readonly activeIcon: Locator;
+    readonly incidentIcon: Locator;
+    readonly variablesList: Locator;
+    readonly messageVariable: Locator;
+    constructor(page: Page);
+    connectorResultVariableName(name: string): Promise<Locator>;
+    connectorResultVariableValue(variableName: string): Promise<Locator>;
+    completedIconAssertion(): Promise<void>;
+    activeIconAssertion(): Promise<void>;
+    activeUserTaskIconVisibleAssertion(taskName: string): Promise<void>;
+    activeUserTaskIconNotVisibleAssertion(taskName: string): Promise<void>;
+    tenantNameAssertion(name: string): Promise<void>;
+    incidentIconAssertion(): Promise<void>;
+    assertEitherIncidentOrActiveIconVisible(): Promise<string>;
+    assertEitherIncidentOrCompletedIconVisible(): Promise<string>;
+    assertProcessCompleteStatusWithRetry(timeout?: number, maxRetries?: number): Promise<void>;
+    assertProcessVariableContainsText(variableName: string, text: string): Promise<void>;
+    private captureVariableJsonValue;
+    assertResultVariableVisibleWithRetry(variableName: string): Promise<void>;
+    assertActiveTokenIsPresent(): Promise<void>;
+    assertBusinessIdVisible(businessId: string): Promise<void>;
+    assertVariablesListVisible(timeout?: number): Promise<void>;
+}
+export { OperateProcessInstancePage };