@camunda/e2e-test-suite 0.0.1443 → 0.0.1445

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormJsPage = void 0;
+const test_1 = require("@playwright/test");
+const modelerCluster_1 = require("../../utils/modelerCluster");
+const hubDeployDialog_1 = require("../../utils/hubDeployDialog");
+class FormJsPage {
+    page;
+    aiFormGeneratorButton;
+    formRequestInput;
+    generateFormButton;
+    formEditor;
+    filePicker;
+    generalPanel;
+    keyInput;
+    uploadMultipleFilesToggle;
+    documentReferenceInput;
+    documentPreview;
+    deployDialog;
+    deployFormButton;
+    deployModalSubmitButton;
+    deploySuccessNotification;
+    constructor(page) {
+        this.page = page;
+        this.aiFormGeneratorButton = page.getByRole('button', {
+            name: 'AI Form Generator',
+        });
+        this.formRequestInput = page.getByPlaceholder('A form for an american standard loan request');
+        this.generateFormButton = page.getByRole('button', { name: 'Generate form' });
+        this.formEditor = page.getByLabel('Form Definition');
+        this.filePicker = page.locator('button[data-field-type="filepicker"]');
+        this.generalPanel = page.locator('[data-group-id="group-general"]').first();
+        this.keyInput = page.getByRole('textbox', { name: 'key' });
+        this.uploadMultipleFilesToggle = page.locator('div[data-entry-id="multiple"] .bio-properties-panel-toggle-switch__switcher');
+        this.documentReferenceInput = page.getByRole('textbox', {
+            name: 'document reference',
+        });
+        this.documentPreview = page.locator('button[data-field-type="documentPreview"]');
+        this.deployDialog = page.getByRole('dialog');
+        // The Design System shell renders none of Carbon's cds-- classes, so the
+        // editor's Deploy button, the dialog's submit and the success toast are all
+        // matched by role and text instead -- which resolves on both shells.
+        // .first(): once the deploy dialog is open its submit carries the same
+        // accessible name; the editor's button is the earlier one in the DOM.
+        this.deployFormButton = page
+            .getByRole('button', { name: 'Deploy', exact: true })
+            .first();
+        this.deployModalSubmitButton = this.deployDialog
+            .getByRole('button', { name: 'Deploy', exact: true })
+            .or(page.locator('button[data-modal-primary-focus="true"][type="submit"]'))
+            .first();
+        this.deploySuccessNotification = page.getByText('Form deployed!').first();
+    }
+    async clickAIFormGeneratorButton() {
+        await this.aiFormGeneratorButton.click();
+    }
+    async clickFormRequestInput() {
+        await this.formRequestInput.click();
+    }
+    async fillFormRequestInput(formRequest) {
+        await this.formRequestInput.fill(formRequest);
+    }
+    async clickGenerateFormButton() {
+        await this.generateFormButton.click();
+    }
+    async dragAndDrop(source, target) {
+        await source.waitFor();
+        await target.waitFor();
+        await source.dragTo(target);
+    }
+    async clickGeneralPropertiesPanel() {
+        await this.generalPanel.click({ timeout: 60000 });
+    }
+    async fillKeyInput(key) {
+        await this.keyInput.fill(key, { timeout: 60000 });
+    }
+    async enableUploadMultipleFiles() {
+        await this.uploadMultipleFilesToggle.click({ timeout: 60000 });
+    }
+    async filldocumentReferenceInput(key) {
+        await this.documentReferenceInput.fill(key, { timeout: 60000 });
+    }
+    async clickDeployFormButton() {
+        await this.deployFormButton.click({ timeout: 60000 });
+    }
+    async clickDeployModalSubmitButton() {
+        await this.deployModalSubmitButton.click({ timeout: 60000 });
+    }
+    // Since camunda/camunda-hub#25831 a form lives inside a process application,
+    // and Hub scopes Deploy to that application unless the scope is narrowed --
+    // deployProcessApplication, not deployFile, so the "Form deployed!" toast
+    // never fires. Narrowing the scope keeps this a form-deploy test instead of
+    // silently turning it into a process-application deploy. Since
+    // camunda/camunda-hub#29791 Hub preselects "Only this resource" when
+    // deploying from a file, so the shared helper's already-selected guard is
+    // what keeps this from reopening the preselected scope select and failing.
+    async selectOnlyThisResource() {
+        await (0, hubDeployDialog_1.selectOnlyThisResourceInDialog)(this.page, this.deployDialog);
+    }
+    async deployForm() {
+        await this.clickDeployFormButton();
+        await (0, test_1.expect)(this.deployDialog).toBeVisible({ timeout: 30000 });
+        await (0, modelerCluster_1.selectModelerCluster)(this.deployDialog);
+        await this.selectOnlyThisResource();
+        await this.clickDeployModalSubmitButton();
+        await (0, test_1.expect)(this.deploySuccessNotification).toBeVisible({ timeout: 30000 });
+    }
+}
+exports.FormJsPage = FormJsPage;

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

@@ -0,0 +1,20 @@
+import { Page, Locator } from '@playwright/test';
+declare class HomePage {
+    private page;
+    readonly dashboardTab: Locator;
+    readonly clusterTab: Locator;
+    readonly organizationTab: Locator;
+    readonly organizationViewTitle: Locator;
+    readonly welcomeMessage: Locator;
+    readonly informationDialog: Locator;
+    readonly camundaAppsButton: Locator;
+    readonly camundaComponentsButton: Locator;
+    constructor(page: Page);
+    clickClusters(): Promise<void>;
+    clickDashboard(): Promise<void>;
+    clickOrganization(): Promise<void>;
+    closeInformationDialog(): Promise<void>;
+    clickCamundaComponents(): Promise<void>;
+    clickCamundaApps(): Promise<void>;
+}
+export { HomePage };

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HomePage = void 0;
+class HomePage {
+    page;
+    dashboardTab;
+    clusterTab;
+    organizationTab;
+    organizationViewTitle;
+    welcomeMessage;
+    informationDialog;
+    camundaAppsButton;
+    camundaComponentsButton;
+    constructor(page) {
+        this.page = page;
+        this.dashboardTab = page.getByRole('link', { name: 'Dashboard' });
+        this.clusterTab = page.getByRole('link', { name: 'Clusters' });
+        this.organizationTab = page.getByRole('link', { name: 'Organization' });
+        this.organizationViewTitle = page.getByText('Organization Management');
+        this.welcomeMessage = page.getByText('Welcome, demo').first();
+        this.informationDialog = page.getByRole('button', {
+            name: 'Close this dialog',
+        });
+        this.camundaComponentsButton = page.getByLabel('Camunda components');
+        this.camundaAppsButton = page.getByLabel('Camunda apps');
+    }
+    async clickClusters() {
+        await this.clusterTab.click({ timeout: 90000 });
+    }
+    async clickDashboard() {
+        await this.dashboardTab.click({ timeout: 90000 });
+    }
+    async clickOrganization() {
+        await this.organizationTab.click({ timeout: 90000 });
+    }
+    async closeInformationDialog() {
+        const isLocalTest = process.env.LOCAL_TEST;
+        if (isLocalTest) {
+            await this.informationDialog.click();
+        }
+    }
+    async clickCamundaComponents() {
+        await this.camundaComponentsButton.click({ timeout: 90000 });
+    }
+    async clickCamundaApps() {
+        await this.camundaAppsButton.click({ timeout: 90000 });
+    }
+}
+exports.HomePage = HomePage;

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

@@ -0,0 +1,53 @@
+import { Page, Locator } from '@playwright/test';
+declare class IdentityTenantPage {
+    private page;
+    readonly createTenantMainButton: Locator;
+    readonly enterTenantNameInput: Locator;
+    readonly enterTenantIdInput: Locator;
+    readonly createTenantSubButton: Locator;
+    readonly assignedUsersTab: Locator;
+    readonly assignUsersButton: Locator;
+    readonly searchUsersInput: Locator;
+    readonly assignUserFinalButton: Locator;
+    readonly removeUserButton: Locator;
+    readonly removeButton: Locator;
+    readonly openSidebarButton: Locator;
+    readonly logoutButton: Locator;
+    readonly assignedApplicationsTab: Locator;
+    readonly searchApplicationsInput: Locator;
+    readonly assignApplicationsButtonFinal: Locator;
+    readonly assignApplicationsButton: Locator;
+    readonly modalCloseButton: Locator;
+    readonly cancelButton: Locator;
+    readonly dialog: Locator;
+    readonly row: (name: string) => Locator;
+    readonly usersTab: Locator;
+    constructor(page: Page);
+    clickCreateTenantMainButton(): Promise<void>;
+    clickCreateTenantSubButton(): Promise<void>;
+    clickEnterTenantNameInput(): Promise<void>;
+    fillEnterTenantNameInput(tenantName: string): Promise<void>;
+    clickEnterTenantIdInput(): Promise<void>;
+    fillEnterTenantIdInput(tenantId: string): Promise<void>;
+    clickAssignedUsersTab(): Promise<void>;
+    clickAssignUsersButton(): Promise<void>;
+    clickSearchUsersInput(): Promise<void>;
+    fillSearchUsersInput(user: string): Promise<void>;
+    clickAssignUserFinalButton(): Promise<void>;
+    clickRemoveUserButton(): Promise<void>;
+    clickRemoveButton(): Promise<void>;
+    createTenant(tenantName: string): Promise<void>;
+    clickTenant(tenantName: string): Promise<void>;
+    private isRowVisible;
+    assignUserToTenant(tenantName: string, user: string, userEmail: string): Promise<void>;
+    removeUserFromTenant(tenantName: string): Promise<void>;
+    clickOpenSidebarButton(): Promise<void>;
+    clickLogoutButton(): Promise<void>;
+    assignClientToTenant(clientName: string): Promise<void>;
+    clickAssignedApplicationsTab(): Promise<void>;
+    clickSearchApplicationsInput(): Promise<void>;
+    fillSearchApplicationsInput(clientName: string): Promise<void>;
+    clickAssignApplicationsFinalButton(): Promise<void>;
+    clickAssignApplicationsButton(): Promise<void>;
+}
+export { IdentityTenantPage };

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityTenantPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const expectLocatorWithPagination_1 = require("../../utils/assertionHelpers/expectLocatorWithPagination");
+const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
+class IdentityTenantPage {
+    page;
+    createTenantMainButton;
+    enterTenantNameInput;
+    enterTenantIdInput;
+    createTenantSubButton;
+    assignedUsersTab;
+    assignUsersButton;
+    searchUsersInput;
+    assignUserFinalButton;
+    removeUserButton;
+    removeButton;
+    openSidebarButton;
+    logoutButton;
+    assignedApplicationsTab;
+    searchApplicationsInput;
+    assignApplicationsButtonFinal;
+    assignApplicationsButton;
+    modalCloseButton;
+    cancelButton;
+    dialog;
+    row;
+    usersTab;
+    constructor(page) {
+        this.page = page;
+        this.createTenantMainButton = page.getByRole('button', {
+            name: 'Create Tenant',
+        });
+        this.usersTab = page.getByRole('tab', { name: 'Users' });
+        this.enterTenantNameInput = page.getByPlaceholder('Enter tenant name');
+        this.enterTenantIdInput = page.getByPlaceholder('Enter tenant ID');
+        this.createTenantSubButton = page.getByRole('button', {
+            name: 'Create tenant',
+            exact: true,
+        });
+        this.assignedUsersTab = page.getByRole('tab', { name: 'Assigned users' });
+        this.assignUsersButton = page.getByRole('button', { name: 'Assign users' });
+        this.searchUsersInput = page.getByPlaceholder('Search users');
+        this.assignUserFinalButton = page
+            .getByRole('dialog', { name: 'Assign users' })
+            .getByRole('button', { name: 'Assign users' });
+        this.removeUserButton = page.getByLabel('Remove user');
+        this.removeButton = page.getByRole('button', { name: 'danger Remove' });
+        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.modalCloseButton = page
+            .getByRole('dialog')
+            .getByRole('button', { name: 'Close' });
+        this.cancelButton = page
+            .getByRole('dialog')
+            .getByRole('button', { name: 'Cancel' });
+        this.dialog = page.getByRole('dialog');
+        this.row = (name) => this.page.getByRole('row').filter({ hasText: name }).first();
+    }
+    async clickCreateTenantMainButton() {
+        await (0, test_1.expect)(this.createTenantMainButton).toBeVisible({ timeout: 60000 });
+        await this.createTenantMainButton.click({ timeout: 60000 });
+    }
+    async clickCreateTenantSubButton() {
+        await (0, test_1.expect)(this.createTenantSubButton).toBeVisible({ timeout: 60000 });
+        await this.createTenantSubButton.click({ timeout: 60000 });
+    }
+    async clickEnterTenantNameInput() {
+        await (0, test_1.expect)(this.enterTenantNameInput).toBeVisible({ timeout: 60000 });
+        await this.enterTenantNameInput.click();
+    }
+    async fillEnterTenantNameInput(tenantName) {
+        await this.enterTenantNameInput.fill(tenantName);
+    }
+    async clickEnterTenantIdInput() {
+        await (0, test_1.expect)(this.enterTenantIdInput).toBeVisible({ timeout: 60000 });
+        await this.enterTenantIdInput.click();
+    }
+    async fillEnterTenantIdInput(tenantId) {
+        await this.enterTenantIdInput.fill(tenantId);
+    }
+    async clickAssignedUsersTab() {
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.assignedUsersTab, {
+            postAction: async () => {
+                await this.page.reload();
+            },
+        });
+    }
+    async clickAssignUsersButton() {
+        await (0, test_1.expect)(this.assignUsersButton).toBeVisible({ timeout: 60000 });
+        await this.assignUsersButton.click();
+    }
+    async clickSearchUsersInput() {
+        await this.searchUsersInput.click();
+    }
+    async fillSearchUsersInput(user) {
+        await this.searchUsersInput.fill(user);
+    }
+    async clickAssignUserFinalButton() {
+        await (0, test_1.expect)(this.assignUserFinalButton).toBeVisible({ timeout: 60000 });
+        await this.assignUserFinalButton.click();
+        const successToast = this.page.getByText('Users assigned', { exact: true });
+        const errorToast = this.page.getByText('An error occurred');
+        const alreadyExists = this.page.getByText('ALREADY_EXISTS');
+        await (0, test_1.expect)(successToast.or(errorToast).or(alreadyExists)).toBeVisible({
+            timeout: 30000,
+        });
+        if (await alreadyExists.isVisible()) {
+            console.log('User already assigned to tenant');
+            await this.cancelButton.click();
+            await (0, test_1.expect)(this.dialog).not.toBeVisible({ timeout: 15000 });
+            return;
+        }
+        if (await errorToast.isVisible()) {
+            await this.cancelButton.click().catch(() => { });
+            await (0, test_1.expect)(this.dialog)
+                .not.toBeVisible({ timeout: 15000 })
+                .catch(() => { });
+            throw new Error('Identity API returned "An error occurred" when assigning user to tenant');
+        }
+        // success: "Users assigned" toast visible
+    }
+    async clickRemoveUserButton() {
+        await this.removeUserButton.click();
+    }
+    async clickRemoveButton() {
+        await this.removeButton.click();
+    }
+    async createTenant(tenantName) {
+        if (await this.isRowVisible(tenantName)) {
+            return;
+        }
+        await this.clickCreateTenantMainButton();
+        await this.clickEnterTenantNameInput();
+        await this.fillEnterTenantNameInput(tenantName);
+        await this.clickEnterTenantIdInput();
+        await this.fillEnterTenantIdInput(tenantName);
+        await this.clickCreateTenantSubButton();
+        await (0, test_1.expect)(this.page.getByText('Tenant created')).toBeVisible({
+            timeout: 60000,
+        });
+        await (0, sleep_1.sleep)(30000);
+    }
+    async clickTenant(tenantName) {
+        const maxRetries = 5;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await this.page.waitForLoadState('domcontentloaded').catch(() => { });
+                const tenantRow = this.row(tenantName);
+                await (0, expectLocatorWithPagination_1.expectLocatorWithPagination)(this.page, tenantRow);
+                await tenantRow.locator('td').first().click({ timeout: 30000 });
+                await this.usersTab.waitFor({ state: 'visible', 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.`);
+                }
+                await this.page.reload({ timeout: 30000 }).catch(() => { });
+                await (0, sleep_1.sleep)(3000);
+            }
+        }
+    }
+    async isRowVisible(name) {
+        await (0, sleep_1.sleep)(1000);
+        if (await this.row(name).isVisible()) {
+            console.log(`Row ${name} already exists.`);
+            return true;
+        }
+        return false;
+    }
+    async assignUserToTenant(tenantName, user, userEmail) {
+        const MAX_ATTEMPTS = 3;
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+            await (0, sleep_1.sleep)(attempt === 1 ? 1000 : 10000);
+            await this.clickTenant(tenantName);
+            await this.clickAssignedUsersTab();
+            if (await this.isRowVisible(userEmail)) {
+                return;
+            }
+            try {
+                await this.clickAssignUsersButton();
+                await this.clickSearchUsersInput();
+                await this.fillSearchUsersInput(user);
+                await (0, test_1.expect)(this.page.getByText(userEmail)).toBeVisible({
+                    timeout: 30000,
+                });
+                await this.page.getByText(userEmail).click({ timeout: 30000 });
+                await this.clickAssignUserFinalButton();
+                return;
+            }
+            catch (e) {
+                console.log(`Attempt ${attempt} to assign user '${user}' to tenant '${tenantName}' failed: ${e}.`);
+                if (attempt >= MAX_ATTEMPTS) {
+                    throw new Error(`Failed to assign user '${user}' to tenant '${tenantName}' after ${MAX_ATTEMPTS} attempts: ${e}`);
+                }
+                await this.page.reload({ timeout: 30000 }).catch(() => { });
+                await (0, sleep_1.sleep)(5000);
+            }
+        }
+    }
+    async removeUserFromTenant(tenantName) {
+        await this.page.getByText(tenantName).first().click();
+        await this.clickAssignedUsersTab();
+        await this.clickRemoveUserButton();
+        await this.clickRemoveButton();
+        await (0, test_1.expect)(this.page.getByText('users.Entity 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();
+        await (0, sleep_1.sleep)(3000);
+        if (await this.isRowVisible(clientName)) {
+            return;
+        }
+        await this.clickAssignApplicationsButton();
+        await this.clickSearchApplicationsInput();
+        await this.fillSearchApplicationsInput(clientName);
+        await (0, test_1.expect)(this.page.getByText(clientName, { exact: true })).toBeVisible({
+            timeout: 15000,
+        });
+        await this.page.getByText(clientName, { exact: true }).click();
+        await this.clickAssignApplicationsFinalButton();
+        await (0, test_1.expect)(this.page.getByText('Applications assigned').first()).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 });
+    }
+}
+exports.IdentityTenantPage = IdentityTenantPage;

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

@@ -0,0 +1,92 @@
+import { Page, Locator } from '@playwright/test';
+declare class IdentityUsersPage {
+    private page;
+    readonly usersTab: Locator;
+    readonly optionsButton: Locator;
+    readonly editUserMenuItem: Locator;
+    readonly operationsEngineerCheckbox: Locator;
+    readonly developerCheckbox: Locator;
+    readonly analystCheckbox: Locator;
+    readonly confirmButton: Locator;
+    readonly settingsTab: Locator;
+    readonly optInButton: Locator;
+    readonly optInCheckbox: Locator;
+    readonly newContextPadButton: Locator;
+    readonly newContextPadButtonText: Locator;
+    readonly mainUser: Locator;
+    readonly authorizations: Locator;
+    readonly noAuthorizedResourceMessage: Locator;
+    readonly dialog: Locator;
+    readonly deleteAuthorisedResourceButton: Locator;
+    readonly deleteAuthorisedResourceSubButton: Locator;
+    readonly createResourceAuthorizationButton: Locator;
+    readonly createResourceAuthorizationDialog: Locator;
+    readonly nextButton: Locator;
+    readonly createButton: Locator;
+    readonly idComboBox: Locator;
+    readonly readPermissionCheckbox: Locator;
+    readonly startProcessIPermissionCheckbox: Locator;
+    readonly optInAICheckbox: Locator;
+    readonly rows: Locator;
+    readonly groupsTab: Locator;
+    readonly createGroupButton: Locator;
+    readonly createGroupSubButton: Locator;
+    readonly groupNameInput: Locator;
+    readonly noGroupsHeading: Locator;
+    readonly createFirstGroupButton: Locator;
+    readonly createGroupDialoge: Locator;
+    readonly assignMembersButton: Locator;
+    readonly assignMembersSubButton: Locator;
+    readonly assignMembersSearchbox: Locator;
+    readonly assignMembersSearchResult: Locator;
+    readonly organizationManagementLink: Locator;
+    readonly deleteSubButton: Locator;
+    readonly deleteButton: Locator;
+    readonly filterTableSearchbox: Locator;
+    readonly assignAuthorizationButton: Locator;
+    readonly assignedRolesTab: Locator;
+    constructor(page: Page);
+    clickCreateAuthorizedResourceButton(): Promise<void>;
+    processIdResourceAssertion(processId: string): Promise<void>;
+    clickCreateResourceAuthorizationButton(): Promise<void>;
+    clickNextButton(): Promise<void>;
+    clickProcessIdInput(): Promise<void>;
+    fillProcessIdInput(processId: string): Promise<void>;
+    checkReadPermissionCheckbox(): Promise<void>;
+    checkStartInstancePermissionCheckbox(): Promise<void>;
+    clickUsersTab(): Promise<void>;
+    clickOptionsButton(): Promise<void>;
+    clickEditUserMenuItem(): Promise<void>;
+    clickOperationsEngineerCheckbox(): Promise<void>;
+    checkDeveloperCheckbox(): Promise<void>;
+    uncheckDeveloperCheckbox(): Promise<void>;
+    checkAnalystCheckbox(): Promise<void>;
+    uncheckAnalystCheckbox(): Promise<void>;
+    clickConfirmButton(): Promise<void>;
+    clickSettingsTab(): Promise<void>;
+    clickOptInButton(): Promise<void>;
+    enableAlphaFeature(name: string): Promise<void>;
+    scrollToOptInCheckbox(): Promise<void>;
+    checkOptInCheckbox(): Promise<void>;
+    clickMainUser(): Promise<void>;
+    clickAuthorizations(): Promise<void>;
+    authorizedResourceAssertion(processId: string, maxRetries?: number, timeout?: number): Promise<void>;
+    clickNewContextPadButton(): Promise<void>;
+    optInToAlphaFeatures(): Promise<void>;
+    clickGroupsTab(): Promise<void>;
+    clickCreateGroupButton(): Promise<void>;
+    fillGroupNameInput(name: string): Promise<void>;
+    clickCreateGroupSubButton(): Promise<void>;
+    clickUserGroup(name: string): Promise<void>;
+    clickAssignMembers(): Promise<void>;
+    fillAssignMembers(names: string[]): Promise<void>;
+    filterTable(names: string[]): Promise<void>;
+    clickAssignSubButton(): Promise<void>;
+    clickOrganizationManagementLink(): Promise<void>;
+    deleteAllGroups(): Promise<void>;
+    createResourceAuthorization(processId: string): Promise<void>;
+    clickAssignAuthorizationButton(): Promise<void>;
+    clickAssignedRolesTab(): Promise<void>;
+    assertUserIsAssignedCorrectRole(username: string, roles: (string | string[])[]): Promise<void>;
+}
+export { IdentityUsersPage };